From dbe6896dba707d5eaf42d68a494f8ce63e3201df Mon Sep 17 00:00:00 2001 From: Marko Baricevic Date: Wed, 22 Jan 2025 11:29:38 +0100 Subject: [PATCH 1/4] create proto patches --- .../proto/tendermint/abci/types.proto.patch | 143 ++++++++++++++++++ .../tendermint/mempool/types.proto.patch | 24 +++ .../tendermint/rpc/grpc/types.proto.patch | 143 ++++++++++++++++++ .../proto/tendermint/state/types.proto.patch | 12 ++ .../proto/tendermint/store/types.proto.patch | 20 +++ .../proto/tendermint/types/types.proto.patch | 126 +++++++++++++++ 6 files changed, 468 insertions(+) create mode 100644 patches/proto/tendermint/abci/types.proto.patch create mode 100644 patches/proto/tendermint/mempool/types.proto.patch create mode 100644 patches/proto/tendermint/rpc/grpc/types.proto.patch create mode 100644 patches/proto/tendermint/state/types.proto.patch create mode 100644 patches/proto/tendermint/store/types.proto.patch create mode 100644 patches/proto/tendermint/types/types.proto.patch diff --git a/patches/proto/tendermint/abci/types.proto.patch b/patches/proto/tendermint/abci/types.proto.patch new file mode 100644 index 00000000000..d12ffcb86c3 --- /dev/null +++ b/patches/proto/tendermint/abci/types.proto.patch @@ -0,0 +1,143 @@ +diff --git a/proto/tendermint/abci/types.proto b/proto/tendermint/abci/types.proto +index 44f861129..2adc2ba79 100644 +--- a/proto/tendermint/abci/types.proto ++++ b/proto/tendermint/abci/types.proto +@@ -11,6 +11,7 @@ import "tendermint/crypto/keys.proto"; + import "tendermint/types/params.proto"; + import "google/protobuf/timestamp.proto"; + import "gogoproto/gogo.proto"; ++import "google/protobuf/duration.proto"; + + // This file is copied from http://github.com/tendermint/abci + // NOTE: When using custom types, mind the warnings. +@@ -36,6 +37,8 @@ message Request { + RequestOfferSnapshot offer_snapshot = 13; + RequestLoadSnapshotChunk load_snapshot_chunk = 14; + RequestApplySnapshotChunk apply_snapshot_chunk = 15; ++ RequestPrepareProposal prepare_proposal = 16; ++ RequestProcessProposal process_proposal = 17; + } + } + +@@ -45,6 +48,11 @@ message RequestEcho { + + message RequestFlush {} + ++message TimeoutsInfo { ++ google.protobuf.Duration timeout_propose = 1 [(gogoproto.nullable) = false, (gogoproto.stdduration) = true]; ++ google.protobuf.Duration timeout_commit = 2 [(gogoproto.nullable) = false, (gogoproto.stdduration) = true]; ++} ++ + message RequestInfo { + string version = 1; + uint64 block_version = 2; +@@ -106,8 +114,9 @@ message RequestListSnapshots {} + + // offers a snapshot to the application + message RequestOfferSnapshot { +- Snapshot snapshot = 1; // snapshot offered by peers +- bytes app_hash = 2; // light client-verified app hash for snapshot height ++ Snapshot snapshot = 1; // snapshot offered by peers ++ bytes app_hash = 2; // light client-verified app hash for snapshot height ++ uint64 app_version = 3; // The application version at which the snapshot was taken + } + + // loads a snapshot chunk +@@ -124,6 +133,28 @@ message RequestApplySnapshotChunk { + string sender = 3; + } + ++message RequestPrepareProposal { ++ // BlockData is a slice of candidate transactions that may be included in a ++ // block. BlockData is sent to the application so that the application can ++ // filter and re-arrange the slice of candidate transactions. ++ tendermint.types.Data block_data = 1; ++ // BlockDataSize is the maximum size (in bytes) that BlockData should be. ++ int64 block_data_size = 2; ++ // chain_id is a unique identifier for the blockchain network this proposal ++ // belongs to (e.g. mocha-1). ++ string chain_id = 3; ++ // height is the height of the proposal block ++ int64 height = 4; ++ // time is the time that will end up in the header. This is the voting power ++ // weighted median of the last commit. ++ google.protobuf.Timestamp time = 5 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; ++} ++ ++message RequestProcessProposal { ++ tendermint.types.Header header = 1 [(gogoproto.nullable) = false]; ++ tendermint.types.Data block_data = 2; ++} ++ + //---------------------------------------- + // Response types + +@@ -145,6 +176,8 @@ message Response { + ResponseOfferSnapshot offer_snapshot = 14; + ResponseLoadSnapshotChunk load_snapshot_chunk = 15; + ResponseApplySnapshotChunk apply_snapshot_chunk = 16; ++ ResponsePrepareProposal prepare_proposal = 17; ++ ResponseProcessProposal process_proposal = 18; + } + } + +@@ -167,6 +200,8 @@ message ResponseInfo { + + int64 last_block_height = 4; + bytes last_block_app_hash = 5; ++ ++ TimeoutsInfo timeouts = 6 [(gogoproto.nullable) = false]; + } + + // nondeterministic +@@ -181,6 +216,7 @@ message ResponseInitChain { + ConsensusParams consensus_params = 1; + repeated ValidatorUpdate validators = 2 [(gogoproto.nullable) = false]; + bytes app_hash = 3; ++ TimeoutsInfo timeouts = 4 [(gogoproto.nullable) = false]; + } + + message ResponseQuery { +@@ -238,6 +274,7 @@ message ResponseEndBlock { + ConsensusParams consensus_param_updates = 2; + repeated Event events = 3 + [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"]; ++ TimeoutsInfo timeouts = 4 [(gogoproto.nullable) = false]; + } + + message ResponseCommit { +@@ -282,6 +319,21 @@ message ResponseApplySnapshotChunk { + } + } + ++message ResponsePrepareProposal { ++ tendermint.types.Data block_data = 1; ++} ++ ++message ResponseProcessProposal { ++ Result result = 1; ++ repeated bytes evidence = 2; ++ ++ enum Result { ++ UNKNOWN = 0; // Unknown result, invalidate ++ ACCEPT = 1; // proposal verified, vote on the proposal ++ REJECT = 2; // proposal invalidated ++ } ++} ++ + //---------------------------------------- + // Misc. + +@@ -406,8 +458,8 @@ service ABCIApplication { + rpc EndBlock(RequestEndBlock) returns (ResponseEndBlock); + rpc ListSnapshots(RequestListSnapshots) returns (ResponseListSnapshots); + rpc OfferSnapshot(RequestOfferSnapshot) returns (ResponseOfferSnapshot); +- rpc LoadSnapshotChunk(RequestLoadSnapshotChunk) +- returns (ResponseLoadSnapshotChunk); +- rpc ApplySnapshotChunk(RequestApplySnapshotChunk) +- returns (ResponseApplySnapshotChunk); ++ rpc LoadSnapshotChunk(RequestLoadSnapshotChunk) returns (ResponseLoadSnapshotChunk); ++ rpc ApplySnapshotChunk(RequestApplySnapshotChunk) returns (ResponseApplySnapshotChunk); ++ rpc PrepareProposal(RequestPrepareProposal) returns (ResponsePrepareProposal); ++ rpc ProcessProposal(RequestProcessProposal) returns (ResponseProcessProposal); + } diff --git a/patches/proto/tendermint/mempool/types.proto.patch b/patches/proto/tendermint/mempool/types.proto.patch new file mode 100644 index 00000000000..b53bf82a648 --- /dev/null +++ b/patches/proto/tendermint/mempool/types.proto.patch @@ -0,0 +1,24 @@ +diff --git a/proto/tendermint/mempool/types.proto b/proto/tendermint/mempool/types.proto +index b55d9717b..75602411d 100644 +--- a/proto/tendermint/mempool/types.proto ++++ b/proto/tendermint/mempool/types.proto +@@ -7,8 +7,18 @@ message Txs { + repeated bytes txs = 1; + } + ++message SeenTx { ++ bytes tx_key = 1; ++} ++ ++message WantTx { ++ bytes tx_key = 1; ++} ++ + message Message { + oneof sum { +- Txs txs = 1; ++ Txs txs = 1; ++ SeenTx seen_tx = 2; ++ WantTx want_tx = 3; + } + } diff --git a/patches/proto/tendermint/rpc/grpc/types.proto.patch b/patches/proto/tendermint/rpc/grpc/types.proto.patch new file mode 100644 index 00000000000..03ffc87b08e --- /dev/null +++ b/patches/proto/tendermint/rpc/grpc/types.proto.patch @@ -0,0 +1,143 @@ +diff --git a/proto/tendermint/rpc/grpc/types.proto b/proto/tendermint/rpc/grpc/types.proto +index ee948a406..f6886a658 100644 +--- a/proto/tendermint/rpc/grpc/types.proto ++++ b/proto/tendermint/rpc/grpc/types.proto +@@ -3,6 +3,12 @@ package tendermint.rpc.grpc; + option go_package = "github.com/tendermint/tendermint/rpc/grpc;coregrpc"; + + import "tendermint/abci/types.proto"; ++import "tendermint/types/types.proto"; ++import "tendermint/p2p/types.proto"; ++import "tendermint/crypto/keys.proto"; ++import "tendermint/types/validator.proto"; ++import "google/protobuf/timestamp.proto"; ++import "gogoproto/gogo.proto"; + + //---------------------------------------- + // Request types +@@ -13,6 +19,38 @@ message RequestBroadcastTx { + bytes tx = 1; + } + ++message BlockByHashRequest { ++ bytes hash = 1; ++ bool prove = 2; ++} ++ ++message BlockByHeightRequest { ++ // Height the requested block height. ++ // If height is equal to 0, the latest height stored in the block store ++ // will be used. ++ int64 height = 1; ++ // Prove set to true to return the parts proofs. ++ bool prove = 2; ++} ++ ++message CommitRequest { ++ // Height the requested block commit height. ++ // If height is equal to 0, the latest height stored in the block store ++ // will be used. ++ int64 height = 1; ++} ++ ++message ValidatorSetRequest { ++ // Height the requested validator set height. ++ // If height is equal to 0, the latest height stored in the block store ++ // will be used. ++ int64 height = 1; ++} ++ ++message SubscribeNewHeightsRequest {} ++ ++message StatusRequest {} ++ + //---------------------------------------- + // Response types + +@@ -23,6 +61,73 @@ message ResponseBroadcastTx { + tendermint.abci.ResponseDeliverTx deliver_tx = 2; + } + ++message StreamedBlockByHashResponse { ++ tendermint.types.Part block_part = 1; ++ // Commit is only set in the first part, and ++ // it stays nil in the remaining ones. ++ tendermint.types.Commit commit = 2; ++ // ValidatorSet is only set in the first part, and ++ // it stays nil in the remaining ones. ++ tendermint.types.ValidatorSet validator_set = 3; ++ bool is_last = 4; ++} ++ ++message StreamedBlockByHeightResponse { ++ tendermint.types.Part block_part = 1; ++ // Commit is only set in the first part, and ++ // it stays nil in the remaining ones. ++ tendermint.types.Commit commit = 2; ++ // ValidatorSet is only set in the first part, and ++ // it stays nil in the remaining ones. ++ tendermint.types.ValidatorSet validator_set = 3; ++ bool is_last = 4; ++} ++ ++message CommitResponse { ++ tendermint.types.Commit commit = 1; ++} ++ ++message ValidatorSetResponse { ++ // ValidatorSet the requested validator set. ++ tendermint.types.ValidatorSet validator_set = 1; ++ // Height the height corresponding to the returned ++ // validator set. ++ int64 height = 2; ++} ++ ++message NewHeightEvent { ++ int64 height = 1; ++ bytes hash = 2; ++} ++ ++message StatusResponse { ++ tendermint.p2p.DefaultNodeInfo node_info = 1; ++ SyncInfo sync_info = 2; ++ ValidatorInfo validator_info = 3; ++} ++ ++message SyncInfo { ++ bytes latest_block_hash = 1; ++ bytes latest_app_hash = 2; ++ int64 latest_block_height = 3; ++ google.protobuf.Timestamp latest_block_time = 4 ++ [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; ++ ++ bytes earliest_block_hash = 5; ++ bytes earliest_app_hash = 6; ++ int64 earliest_block_height = 7; ++ google.protobuf.Timestamp earliest_block_time = 8 ++ [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; ++ ++ bool catching_up = 9; ++} ++ ++message ValidatorInfo { ++ bytes address = 1; ++ tendermint.crypto.PublicKey pub_key = 2; ++ int64 voting_power = 3; ++} ++ + //---------------------------------------- + // Service Definition + +@@ -30,3 +135,12 @@ service BroadcastAPI { + rpc Ping(RequestPing) returns (ResponsePing); + rpc BroadcastTx(RequestBroadcastTx) returns (ResponseBroadcastTx); + } ++ ++service BlockAPI { ++ rpc BlockByHash(BlockByHashRequest) returns (stream StreamedBlockByHashResponse); ++ rpc BlockByHeight(BlockByHeightRequest) returns (stream StreamedBlockByHeightResponse); ++ rpc Commit(CommitRequest) returns (CommitResponse); ++ rpc ValidatorSet(ValidatorSetRequest) returns (ValidatorSetResponse); ++ rpc SubscribeNewHeights(SubscribeNewHeightsRequest) returns (stream NewHeightEvent); ++ rpc Status(StatusRequest) returns (StatusResponse); ++} diff --git a/patches/proto/tendermint/state/types.proto.patch b/patches/proto/tendermint/state/types.proto.patch new file mode 100644 index 00000000000..4df556070e5 --- /dev/null +++ b/patches/proto/tendermint/state/types.proto.patch @@ -0,0 +1,12 @@ +diff --git a/proto/tendermint/state/types.proto b/proto/tendermint/state/types.proto +index f3fdc0ef3..9796a8fc5 100644 +--- a/proto/tendermint/state/types.proto ++++ b/proto/tendermint/state/types.proto +@@ -77,4 +77,7 @@ message State { + + // the latest AppHash we've received from calling abci.Commit() + bytes app_hash = 13; ++ ++ // timeouts to be used for the next block height ++ tendermint.abci.TimeoutsInfo timeouts = 15 [(gogoproto.nullable) = false]; + } diff --git a/patches/proto/tendermint/store/types.proto.patch b/patches/proto/tendermint/store/types.proto.patch new file mode 100644 index 00000000000..678614e03ad --- /dev/null +++ b/patches/proto/tendermint/store/types.proto.patch @@ -0,0 +1,20 @@ +diff --git a/proto/tendermint/store/types.proto b/proto/tendermint/store/types.proto +index af2f97ad0..64a32d1f7 100644 +--- a/proto/tendermint/store/types.proto ++++ b/proto/tendermint/store/types.proto +@@ -7,3 +7,15 @@ message BlockStoreState { + int64 base = 1; + int64 height = 2; + } ++ ++// TxInfo describes the location of a tx inside a committed block ++// as well as the result of executing the transaction and the error log output. ++message TxInfo { ++ int64 height = 1; ++ uint32 index = 2; ++ // The response code of executing the tx. 0 means ++ // successfully executed, all others are error codes. ++ uint32 code = 3; ++ // The error log output generated if the transaction execution fails. ++ string error = 4; ++} diff --git a/patches/proto/tendermint/types/types.proto.patch b/patches/proto/tendermint/types/types.proto.patch new file mode 100644 index 00000000000..2685e5add2e --- /dev/null +++ b/patches/proto/tendermint/types/types.proto.patch @@ -0,0 +1,126 @@ +diff --git a/proto/tendermint/types/types.proto b/proto/tendermint/types/types.proto +index 3ce169459..d3ccf4a28 100644 +--- a/proto/tendermint/types/types.proto ++++ b/proto/tendermint/types/types.proto +@@ -81,12 +81,37 @@ message Header { + bytes proposer_address = 14; // original proposer of the block + } + +-// Data contains the set of transactions included in the block ++// Data contains all the information needed for a consensus full node to ++// reconstruct an extended data square. + message Data { +- // Txs that will be applied by state @ block.Height+1. +- // NOTE: not all txs here are valid. We're just agreeing on the order first. +- // This means that block.AppHash does not include these txs. ++ // Txs that will be applied to state in block.Height + 1 because deferred execution. ++ // This means that the block.AppHash of this block does not include these txs. ++ // NOTE: not all txs here are valid. We're just agreeing on the order first. + repeated bytes txs = 1; ++ ++ reserved 2, 3, 4; ++ // field number 2 is reserved for intermediate state roots ++ // field number 3 is reserved for evidence ++ // field number 4 is reserved for blobs ++ ++ // SquareSize is the number of rows or columns in the original data square. ++ uint64 square_size = 5; ++ ++ // Hash is the root of a binary Merkle tree where the leaves of the tree are ++ // the row and column roots of an extended data square. Hash is often referred ++ // to as the "data root". ++ bytes hash = 6; ++} ++ ++// Blob (named after binary large object) is a chunk of data submitted by a user ++// to be published to the Celestia blockchain. The data of a Blob is published ++// to a namespace and is encoded into shares based on the format specified by ++// share_version. ++message Blob { ++ bytes namespace_id = 1; ++ bytes data = 2; ++ uint32 share_version = 3; ++ uint32 namespace_version = 4; + } + + // Vote represents a prevote, precommit, or commit vote from validators for +@@ -149,9 +174,78 @@ message BlockMeta { + int64 num_txs = 4; + } + +-// TxProof represents a Merkle proof of the presence of a transaction in the Merkle tree. ++// TxProof represents a Merkle proof of the presence of a transaction in the ++// Merkle tree. ++// ++// Note: TxProof is not used in celestia-core because of modifications to the ++// data root. In a normal Cosmos chain, the data root is the root of a Merkle ++// tree of transactions in the block. However, in Celestia the data root is the ++// root of the row and column roots in the extended data square. See ++// https://github.com/celestiaorg/celestia-app/blob/852a229f11f0f269021b36f7621609f432bb858b/pkg/da/data_availability_header.go ++// for more details. Therefore, TxProof isn't sufficient to prove the existence ++// of a transaction in a Celestia block and ShareProof was defined instead. See ++// ShareProof for more details. + message TxProof { + bytes root_hash = 1; + bytes data = 2; + tendermint.crypto.Proof proof = 3; + } ++ ++// IndexWrapper adds index metadata to a transaction. This is used to track ++// transactions that pay for blobs, and where the blobs start in the square. ++message IndexWrapper { ++ bytes tx = 1; ++ repeated uint32 share_indexes = 2; ++ string type_id = 3; ++} ++ ++// BlobTx wraps an encoded sdk.Tx with a second field to contain blobs of data. ++// The raw bytes of the blobs are not signed over, instead we verify each blob ++// using the relevant MsgPayForBlobs that is signed over in the encoded sdk.Tx. ++message BlobTx { ++ bytes tx = 1; ++ repeated Blob blobs = 2; ++ string type_id = 3; ++} ++ ++// ShareProof is an NMT proof that a set of shares exist in a set of rows and a ++// Merkle proof that those rows exist in a Merkle tree with a given data root. ++message ShareProof { ++ repeated bytes data = 1; ++ repeated NMTProof share_proofs = 2; ++ bytes namespace_id = 3; ++ RowProof row_proof = 4; ++ uint32 namespace_version = 5; ++} ++ ++// RowProof is a Merkle proof that a set of rows exist in a Merkle tree with a ++// given data root. ++message RowProof { ++ repeated bytes row_roots = 1; ++ repeated tendermint.crypto.Proof proofs = 2; ++ bytes root = 3; ++ uint32 start_row = 4; ++ uint32 end_row = 5; ++} ++ ++// NMTProof is a proof of a namespace.ID in an NMT. ++// In case this proof proves the absence of a namespace.ID ++// in a tree it also contains the leaf hashes of the range ++// where that namespace would be. ++message NMTProof { ++ // Start index of this proof. ++ int32 start = 1; ++ // End index of this proof. ++ int32 end = 2; ++ // Nodes that together with the corresponding leaf values can be used to ++ // recompute the root and verify this proof. Nodes should consist of the max ++ // and min namespaces along with the actual hash, resulting in each being 48 ++ // bytes each ++ repeated bytes nodes = 3; ++ // leafHash are nil if the namespace is present in the NMT. In case the ++ // namespace to be proved is in the min/max range of the tree but absent, this ++ // will contain the leaf hash necessary to verify the proof of absence. Leaf ++ // hashes should consist of the namespace along with the actual hash, ++ // resulting 40 bytes total. ++ bytes leaf_hash = 4; ++} From 0f62c42358eb32af99de355ce9043e3fd0a7f0e6 Mon Sep 17 00:00:00 2001 From: Marko Baricevic Date: Wed, 22 Jan 2025 11:50:58 +0100 Subject: [PATCH 2/4] add proto changes --- .../proto/tendermint/abci/types.proto.patch | 143 ----------------- .../tendermint/mempool/types.proto.patch | 24 --- .../tendermint/rpc/grpc/types.proto.patch | 143 ----------------- .../proto/tendermint/state/types.proto.patch | 12 -- .../proto/tendermint/store/types.proto.patch | 20 --- .../proto/tendermint/types/types.proto.patch | 126 --------------- proto/cometbft/abci/v2/types.proto | 1 + proto/cometbft/mempool/v2/types.proto | 5 + proto/cometbft/rpc/grpc/v1beta3/types.proto | 144 +++++++++++++++++- proto/cometbft/state/v2/types.proto | 12 ++ proto/cometbft/types/v2/types.proto | 89 ++++++++++- 11 files changed, 247 insertions(+), 472 deletions(-) delete mode 100644 patches/proto/tendermint/abci/types.proto.patch delete mode 100644 patches/proto/tendermint/mempool/types.proto.patch delete mode 100644 patches/proto/tendermint/rpc/grpc/types.proto.patch delete mode 100644 patches/proto/tendermint/state/types.proto.patch delete mode 100644 patches/proto/tendermint/store/types.proto.patch delete mode 100644 patches/proto/tendermint/types/types.proto.patch diff --git a/patches/proto/tendermint/abci/types.proto.patch b/patches/proto/tendermint/abci/types.proto.patch deleted file mode 100644 index d12ffcb86c3..00000000000 --- a/patches/proto/tendermint/abci/types.proto.patch +++ /dev/null @@ -1,143 +0,0 @@ -diff --git a/proto/tendermint/abci/types.proto b/proto/tendermint/abci/types.proto -index 44f861129..2adc2ba79 100644 ---- a/proto/tendermint/abci/types.proto -+++ b/proto/tendermint/abci/types.proto -@@ -11,6 +11,7 @@ import "tendermint/crypto/keys.proto"; - import "tendermint/types/params.proto"; - import "google/protobuf/timestamp.proto"; - import "gogoproto/gogo.proto"; -+import "google/protobuf/duration.proto"; - - // This file is copied from http://github.com/tendermint/abci - // NOTE: When using custom types, mind the warnings. -@@ -36,6 +37,8 @@ message Request { - RequestOfferSnapshot offer_snapshot = 13; - RequestLoadSnapshotChunk load_snapshot_chunk = 14; - RequestApplySnapshotChunk apply_snapshot_chunk = 15; -+ RequestPrepareProposal prepare_proposal = 16; -+ RequestProcessProposal process_proposal = 17; - } - } - -@@ -45,6 +48,11 @@ message RequestEcho { - - message RequestFlush {} - -+message TimeoutsInfo { -+ google.protobuf.Duration timeout_propose = 1 [(gogoproto.nullable) = false, (gogoproto.stdduration) = true]; -+ google.protobuf.Duration timeout_commit = 2 [(gogoproto.nullable) = false, (gogoproto.stdduration) = true]; -+} -+ - message RequestInfo { - string version = 1; - uint64 block_version = 2; -@@ -106,8 +114,9 @@ message RequestListSnapshots {} - - // offers a snapshot to the application - message RequestOfferSnapshot { -- Snapshot snapshot = 1; // snapshot offered by peers -- bytes app_hash = 2; // light client-verified app hash for snapshot height -+ Snapshot snapshot = 1; // snapshot offered by peers -+ bytes app_hash = 2; // light client-verified app hash for snapshot height -+ uint64 app_version = 3; // The application version at which the snapshot was taken - } - - // loads a snapshot chunk -@@ -124,6 +133,28 @@ message RequestApplySnapshotChunk { - string sender = 3; - } - -+message RequestPrepareProposal { -+ // BlockData is a slice of candidate transactions that may be included in a -+ // block. BlockData is sent to the application so that the application can -+ // filter and re-arrange the slice of candidate transactions. -+ tendermint.types.Data block_data = 1; -+ // BlockDataSize is the maximum size (in bytes) that BlockData should be. -+ int64 block_data_size = 2; -+ // chain_id is a unique identifier for the blockchain network this proposal -+ // belongs to (e.g. mocha-1). -+ string chain_id = 3; -+ // height is the height of the proposal block -+ int64 height = 4; -+ // time is the time that will end up in the header. This is the voting power -+ // weighted median of the last commit. -+ google.protobuf.Timestamp time = 5 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; -+} -+ -+message RequestProcessProposal { -+ tendermint.types.Header header = 1 [(gogoproto.nullable) = false]; -+ tendermint.types.Data block_data = 2; -+} -+ - //---------------------------------------- - // Response types - -@@ -145,6 +176,8 @@ message Response { - ResponseOfferSnapshot offer_snapshot = 14; - ResponseLoadSnapshotChunk load_snapshot_chunk = 15; - ResponseApplySnapshotChunk apply_snapshot_chunk = 16; -+ ResponsePrepareProposal prepare_proposal = 17; -+ ResponseProcessProposal process_proposal = 18; - } - } - -@@ -167,6 +200,8 @@ message ResponseInfo { - - int64 last_block_height = 4; - bytes last_block_app_hash = 5; -+ -+ TimeoutsInfo timeouts = 6 [(gogoproto.nullable) = false]; - } - - // nondeterministic -@@ -181,6 +216,7 @@ message ResponseInitChain { - ConsensusParams consensus_params = 1; - repeated ValidatorUpdate validators = 2 [(gogoproto.nullable) = false]; - bytes app_hash = 3; -+ TimeoutsInfo timeouts = 4 [(gogoproto.nullable) = false]; - } - - message ResponseQuery { -@@ -238,6 +274,7 @@ message ResponseEndBlock { - ConsensusParams consensus_param_updates = 2; - repeated Event events = 3 - [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"]; -+ TimeoutsInfo timeouts = 4 [(gogoproto.nullable) = false]; - } - - message ResponseCommit { -@@ -282,6 +319,21 @@ message ResponseApplySnapshotChunk { - } - } - -+message ResponsePrepareProposal { -+ tendermint.types.Data block_data = 1; -+} -+ -+message ResponseProcessProposal { -+ Result result = 1; -+ repeated bytes evidence = 2; -+ -+ enum Result { -+ UNKNOWN = 0; // Unknown result, invalidate -+ ACCEPT = 1; // proposal verified, vote on the proposal -+ REJECT = 2; // proposal invalidated -+ } -+} -+ - //---------------------------------------- - // Misc. - -@@ -406,8 +458,8 @@ service ABCIApplication { - rpc EndBlock(RequestEndBlock) returns (ResponseEndBlock); - rpc ListSnapshots(RequestListSnapshots) returns (ResponseListSnapshots); - rpc OfferSnapshot(RequestOfferSnapshot) returns (ResponseOfferSnapshot); -- rpc LoadSnapshotChunk(RequestLoadSnapshotChunk) -- returns (ResponseLoadSnapshotChunk); -- rpc ApplySnapshotChunk(RequestApplySnapshotChunk) -- returns (ResponseApplySnapshotChunk); -+ rpc LoadSnapshotChunk(RequestLoadSnapshotChunk) returns (ResponseLoadSnapshotChunk); -+ rpc ApplySnapshotChunk(RequestApplySnapshotChunk) returns (ResponseApplySnapshotChunk); -+ rpc PrepareProposal(RequestPrepareProposal) returns (ResponsePrepareProposal); -+ rpc ProcessProposal(RequestProcessProposal) returns (ResponseProcessProposal); - } diff --git a/patches/proto/tendermint/mempool/types.proto.patch b/patches/proto/tendermint/mempool/types.proto.patch deleted file mode 100644 index b53bf82a648..00000000000 --- a/patches/proto/tendermint/mempool/types.proto.patch +++ /dev/null @@ -1,24 +0,0 @@ -diff --git a/proto/tendermint/mempool/types.proto b/proto/tendermint/mempool/types.proto -index b55d9717b..75602411d 100644 ---- a/proto/tendermint/mempool/types.proto -+++ b/proto/tendermint/mempool/types.proto -@@ -7,8 +7,18 @@ message Txs { - repeated bytes txs = 1; - } - -+message SeenTx { -+ bytes tx_key = 1; -+} -+ -+message WantTx { -+ bytes tx_key = 1; -+} -+ - message Message { - oneof sum { -- Txs txs = 1; -+ Txs txs = 1; -+ SeenTx seen_tx = 2; -+ WantTx want_tx = 3; - } - } diff --git a/patches/proto/tendermint/rpc/grpc/types.proto.patch b/patches/proto/tendermint/rpc/grpc/types.proto.patch deleted file mode 100644 index 03ffc87b08e..00000000000 --- a/patches/proto/tendermint/rpc/grpc/types.proto.patch +++ /dev/null @@ -1,143 +0,0 @@ -diff --git a/proto/tendermint/rpc/grpc/types.proto b/proto/tendermint/rpc/grpc/types.proto -index ee948a406..f6886a658 100644 ---- a/proto/tendermint/rpc/grpc/types.proto -+++ b/proto/tendermint/rpc/grpc/types.proto -@@ -3,6 +3,12 @@ package tendermint.rpc.grpc; - option go_package = "github.com/tendermint/tendermint/rpc/grpc;coregrpc"; - - import "tendermint/abci/types.proto"; -+import "tendermint/types/types.proto"; -+import "tendermint/p2p/types.proto"; -+import "tendermint/crypto/keys.proto"; -+import "tendermint/types/validator.proto"; -+import "google/protobuf/timestamp.proto"; -+import "gogoproto/gogo.proto"; - - //---------------------------------------- - // Request types -@@ -13,6 +19,38 @@ message RequestBroadcastTx { - bytes tx = 1; - } - -+message BlockByHashRequest { -+ bytes hash = 1; -+ bool prove = 2; -+} -+ -+message BlockByHeightRequest { -+ // Height the requested block height. -+ // If height is equal to 0, the latest height stored in the block store -+ // will be used. -+ int64 height = 1; -+ // Prove set to true to return the parts proofs. -+ bool prove = 2; -+} -+ -+message CommitRequest { -+ // Height the requested block commit height. -+ // If height is equal to 0, the latest height stored in the block store -+ // will be used. -+ int64 height = 1; -+} -+ -+message ValidatorSetRequest { -+ // Height the requested validator set height. -+ // If height is equal to 0, the latest height stored in the block store -+ // will be used. -+ int64 height = 1; -+} -+ -+message SubscribeNewHeightsRequest {} -+ -+message StatusRequest {} -+ - //---------------------------------------- - // Response types - -@@ -23,6 +61,73 @@ message ResponseBroadcastTx { - tendermint.abci.ResponseDeliverTx deliver_tx = 2; - } - -+message StreamedBlockByHashResponse { -+ tendermint.types.Part block_part = 1; -+ // Commit is only set in the first part, and -+ // it stays nil in the remaining ones. -+ tendermint.types.Commit commit = 2; -+ // ValidatorSet is only set in the first part, and -+ // it stays nil in the remaining ones. -+ tendermint.types.ValidatorSet validator_set = 3; -+ bool is_last = 4; -+} -+ -+message StreamedBlockByHeightResponse { -+ tendermint.types.Part block_part = 1; -+ // Commit is only set in the first part, and -+ // it stays nil in the remaining ones. -+ tendermint.types.Commit commit = 2; -+ // ValidatorSet is only set in the first part, and -+ // it stays nil in the remaining ones. -+ tendermint.types.ValidatorSet validator_set = 3; -+ bool is_last = 4; -+} -+ -+message CommitResponse { -+ tendermint.types.Commit commit = 1; -+} -+ -+message ValidatorSetResponse { -+ // ValidatorSet the requested validator set. -+ tendermint.types.ValidatorSet validator_set = 1; -+ // Height the height corresponding to the returned -+ // validator set. -+ int64 height = 2; -+} -+ -+message NewHeightEvent { -+ int64 height = 1; -+ bytes hash = 2; -+} -+ -+message StatusResponse { -+ tendermint.p2p.DefaultNodeInfo node_info = 1; -+ SyncInfo sync_info = 2; -+ ValidatorInfo validator_info = 3; -+} -+ -+message SyncInfo { -+ bytes latest_block_hash = 1; -+ bytes latest_app_hash = 2; -+ int64 latest_block_height = 3; -+ google.protobuf.Timestamp latest_block_time = 4 -+ [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; -+ -+ bytes earliest_block_hash = 5; -+ bytes earliest_app_hash = 6; -+ int64 earliest_block_height = 7; -+ google.protobuf.Timestamp earliest_block_time = 8 -+ [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; -+ -+ bool catching_up = 9; -+} -+ -+message ValidatorInfo { -+ bytes address = 1; -+ tendermint.crypto.PublicKey pub_key = 2; -+ int64 voting_power = 3; -+} -+ - //---------------------------------------- - // Service Definition - -@@ -30,3 +135,12 @@ service BroadcastAPI { - rpc Ping(RequestPing) returns (ResponsePing); - rpc BroadcastTx(RequestBroadcastTx) returns (ResponseBroadcastTx); - } -+ -+service BlockAPI { -+ rpc BlockByHash(BlockByHashRequest) returns (stream StreamedBlockByHashResponse); -+ rpc BlockByHeight(BlockByHeightRequest) returns (stream StreamedBlockByHeightResponse); -+ rpc Commit(CommitRequest) returns (CommitResponse); -+ rpc ValidatorSet(ValidatorSetRequest) returns (ValidatorSetResponse); -+ rpc SubscribeNewHeights(SubscribeNewHeightsRequest) returns (stream NewHeightEvent); -+ rpc Status(StatusRequest) returns (StatusResponse); -+} diff --git a/patches/proto/tendermint/state/types.proto.patch b/patches/proto/tendermint/state/types.proto.patch deleted file mode 100644 index 4df556070e5..00000000000 --- a/patches/proto/tendermint/state/types.proto.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff --git a/proto/tendermint/state/types.proto b/proto/tendermint/state/types.proto -index f3fdc0ef3..9796a8fc5 100644 ---- a/proto/tendermint/state/types.proto -+++ b/proto/tendermint/state/types.proto -@@ -77,4 +77,7 @@ message State { - - // the latest AppHash we've received from calling abci.Commit() - bytes app_hash = 13; -+ -+ // timeouts to be used for the next block height -+ tendermint.abci.TimeoutsInfo timeouts = 15 [(gogoproto.nullable) = false]; - } diff --git a/patches/proto/tendermint/store/types.proto.patch b/patches/proto/tendermint/store/types.proto.patch deleted file mode 100644 index 678614e03ad..00000000000 --- a/patches/proto/tendermint/store/types.proto.patch +++ /dev/null @@ -1,20 +0,0 @@ -diff --git a/proto/tendermint/store/types.proto b/proto/tendermint/store/types.proto -index af2f97ad0..64a32d1f7 100644 ---- a/proto/tendermint/store/types.proto -+++ b/proto/tendermint/store/types.proto -@@ -7,3 +7,15 @@ message BlockStoreState { - int64 base = 1; - int64 height = 2; - } -+ -+// TxInfo describes the location of a tx inside a committed block -+// as well as the result of executing the transaction and the error log output. -+message TxInfo { -+ int64 height = 1; -+ uint32 index = 2; -+ // The response code of executing the tx. 0 means -+ // successfully executed, all others are error codes. -+ uint32 code = 3; -+ // The error log output generated if the transaction execution fails. -+ string error = 4; -+} diff --git a/patches/proto/tendermint/types/types.proto.patch b/patches/proto/tendermint/types/types.proto.patch deleted file mode 100644 index 2685e5add2e..00000000000 --- a/patches/proto/tendermint/types/types.proto.patch +++ /dev/null @@ -1,126 +0,0 @@ -diff --git a/proto/tendermint/types/types.proto b/proto/tendermint/types/types.proto -index 3ce169459..d3ccf4a28 100644 ---- a/proto/tendermint/types/types.proto -+++ b/proto/tendermint/types/types.proto -@@ -81,12 +81,37 @@ message Header { - bytes proposer_address = 14; // original proposer of the block - } - --// Data contains the set of transactions included in the block -+// Data contains all the information needed for a consensus full node to -+// reconstruct an extended data square. - message Data { -- // Txs that will be applied by state @ block.Height+1. -- // NOTE: not all txs here are valid. We're just agreeing on the order first. -- // This means that block.AppHash does not include these txs. -+ // Txs that will be applied to state in block.Height + 1 because deferred execution. -+ // This means that the block.AppHash of this block does not include these txs. -+ // NOTE: not all txs here are valid. We're just agreeing on the order first. - repeated bytes txs = 1; -+ -+ reserved 2, 3, 4; -+ // field number 2 is reserved for intermediate state roots -+ // field number 3 is reserved for evidence -+ // field number 4 is reserved for blobs -+ -+ // SquareSize is the number of rows or columns in the original data square. -+ uint64 square_size = 5; -+ -+ // Hash is the root of a binary Merkle tree where the leaves of the tree are -+ // the row and column roots of an extended data square. Hash is often referred -+ // to as the "data root". -+ bytes hash = 6; -+} -+ -+// Blob (named after binary large object) is a chunk of data submitted by a user -+// to be published to the Celestia blockchain. The data of a Blob is published -+// to a namespace and is encoded into shares based on the format specified by -+// share_version. -+message Blob { -+ bytes namespace_id = 1; -+ bytes data = 2; -+ uint32 share_version = 3; -+ uint32 namespace_version = 4; - } - - // Vote represents a prevote, precommit, or commit vote from validators for -@@ -149,9 +174,78 @@ message BlockMeta { - int64 num_txs = 4; - } - --// TxProof represents a Merkle proof of the presence of a transaction in the Merkle tree. -+// TxProof represents a Merkle proof of the presence of a transaction in the -+// Merkle tree. -+// -+// Note: TxProof is not used in celestia-core because of modifications to the -+// data root. In a normal Cosmos chain, the data root is the root of a Merkle -+// tree of transactions in the block. However, in Celestia the data root is the -+// root of the row and column roots in the extended data square. See -+// https://github.com/celestiaorg/celestia-app/blob/852a229f11f0f269021b36f7621609f432bb858b/pkg/da/data_availability_header.go -+// for more details. Therefore, TxProof isn't sufficient to prove the existence -+// of a transaction in a Celestia block and ShareProof was defined instead. See -+// ShareProof for more details. - message TxProof { - bytes root_hash = 1; - bytes data = 2; - tendermint.crypto.Proof proof = 3; - } -+ -+// IndexWrapper adds index metadata to a transaction. This is used to track -+// transactions that pay for blobs, and where the blobs start in the square. -+message IndexWrapper { -+ bytes tx = 1; -+ repeated uint32 share_indexes = 2; -+ string type_id = 3; -+} -+ -+// BlobTx wraps an encoded sdk.Tx with a second field to contain blobs of data. -+// The raw bytes of the blobs are not signed over, instead we verify each blob -+// using the relevant MsgPayForBlobs that is signed over in the encoded sdk.Tx. -+message BlobTx { -+ bytes tx = 1; -+ repeated Blob blobs = 2; -+ string type_id = 3; -+} -+ -+// ShareProof is an NMT proof that a set of shares exist in a set of rows and a -+// Merkle proof that those rows exist in a Merkle tree with a given data root. -+message ShareProof { -+ repeated bytes data = 1; -+ repeated NMTProof share_proofs = 2; -+ bytes namespace_id = 3; -+ RowProof row_proof = 4; -+ uint32 namespace_version = 5; -+} -+ -+// RowProof is a Merkle proof that a set of rows exist in a Merkle tree with a -+// given data root. -+message RowProof { -+ repeated bytes row_roots = 1; -+ repeated tendermint.crypto.Proof proofs = 2; -+ bytes root = 3; -+ uint32 start_row = 4; -+ uint32 end_row = 5; -+} -+ -+// NMTProof is a proof of a namespace.ID in an NMT. -+// In case this proof proves the absence of a namespace.ID -+// in a tree it also contains the leaf hashes of the range -+// where that namespace would be. -+message NMTProof { -+ // Start index of this proof. -+ int32 start = 1; -+ // End index of this proof. -+ int32 end = 2; -+ // Nodes that together with the corresponding leaf values can be used to -+ // recompute the root and verify this proof. Nodes should consist of the max -+ // and min namespaces along with the actual hash, resulting in each being 48 -+ // bytes each -+ repeated bytes nodes = 3; -+ // leafHash are nil if the namespace is present in the NMT. In case the -+ // namespace to be proved is in the min/max range of the tree but absent, this -+ // will contain the leaf hash necessary to verify the proof of absence. Leaf -+ // hashes should consist of the namespace along with the actual hash, -+ // resulting 40 bytes total. -+ bytes leaf_hash = 4; -+} diff --git a/proto/cometbft/abci/v2/types.proto b/proto/cometbft/abci/v2/types.proto index b3a54f747f0..8961790f036 100644 --- a/proto/cometbft/abci/v2/types.proto +++ b/proto/cometbft/abci/v2/types.proto @@ -107,6 +107,7 @@ message ListSnapshotsRequest {} message OfferSnapshotRequest { Snapshot snapshot = 1; // snapshot offered by peers bytes app_hash = 2; // light client-verified app hash for snapshot height + uint64 app_version = 3; // The application version at which the snapshot was taken } // Request to load a snapshot chunk. diff --git a/proto/cometbft/mempool/v2/types.proto b/proto/cometbft/mempool/v2/types.proto index 1f568cfd63e..e58b61777dd 100644 --- a/proto/cometbft/mempool/v2/types.proto +++ b/proto/cometbft/mempool/v2/types.proto @@ -14,6 +14,10 @@ message HaveTx { bytes tx_key = 1; } +message WantTx { + bytes tx_key = 1; +} + // ResetRoute is sent by the DOG protocol to signal a peer to reset a (random) // route to the sender. message ResetRoute { @@ -26,5 +30,6 @@ message Message { Txs txs = 1; HaveTx have_tx = 2; ResetRoute reset_route = 3; + WantTx want_tx = 4; } } diff --git a/proto/cometbft/rpc/grpc/v1beta3/types.proto b/proto/cometbft/rpc/grpc/v1beta3/types.proto index 2d25cace57a..5ce89075d53 100644 --- a/proto/cometbft/rpc/grpc/v1beta3/types.proto +++ b/proto/cometbft/rpc/grpc/v1beta3/types.proto @@ -3,13 +3,19 @@ package cometbft.rpc.grpc.v1beta3; option go_package = "github.com/cometbft/cometbft/api/cometbft/rpc/grpc/v1beta3"; import "cometbft/rpc/grpc/v1beta1/types.proto"; +import "cometbft/abci/v2/types.proto"; -import "cometbft/abci/v1beta3/types.proto"; +import "cometbft/v2/types/types.proto"; +import "cometbft/v1/p2p/types.proto"; +import "cometbft/v1/crypto/keys.proto"; +import "cometbft/v2/types/validator.proto"; +import "google/protobuf/timestamp.proto"; +import "gogoproto/gogo.proto"; // ResponseBroadcastTx is a response of broadcasting the transaction. message ResponseBroadcastTx { - cometbft.abci.v1beta3.ResponseCheckTx check_tx = 1; - cometbft.abci.v1beta3.ExecTxResult tx_result = 2; + cometbft.abci.v2.ResponseCheckTx check_tx = 1; + cometbft.abci.v2.ExecTxResult tx_result = 2; } // BroadcastAPI is an API for broadcasting transactions. @@ -22,3 +28,135 @@ service BroadcastAPI { // BroadcastTx broadcasts a transaction. rpc BroadcastTx(v1beta1.RequestBroadcastTx) returns (v1beta3.ResponseBroadcastTx); } + +// BlockAPI is an API for querying blocks. + +service BlockAPI { + // BlockByHash returns a block by its hash. + rpc BlockByHash(BlockByHashRequest) returns (stream StreamedBlockByHashResponse); + // BlockByHeight returns a block by its height. + rpc BlockByHeight(BlockByHeightRequest) returns (stream StreamedBlockByHeightResponse); + // Commit returns the commit of a block. + rpc Commit(CommitRequest) returns (CommitResponse); + // ValidatorSet returns the validator set of a block. + rpc ValidatorSet(ValidatorSetRequest) returns (ValidatorSetResponse); + // SubscribeNewHeights subscribes to new heights. + rpc SubscribeNewHeights(SubscribeNewHeightsRequest) returns (stream NewHeightEvent); + // Status returns the status of the node. + rpc Status(StatusRequest) returns (StatusResponse); +} + + +// BlockByHashRequest is a request to get a block by its hash. +message BlockByHashRequest { + bytes hash = 1; + bool prove = 2; + } + + // BlockByHeightRequest is a request to get a block by its height. + message BlockByHeightRequest { + // Height the requested block height. + // If height is equal to 0, the latest height stored in the block store + // will be used. + int64 height = 1; + // Prove set to true to return the parts proofs. + bool prove = 2; + } + + // CommitRequest is a request to get the commit of a block. + message CommitRequest { + // Height the requested block commit height. + // If height is equal to 0, the latest height stored in the block store + // will be used. + int64 height = 1; + } + + // ValidatorSetRequest is a request to get the validator set of a block. + message ValidatorSetRequest { + // Height the requested validator set height. + // If height is equal to 0, the latest height stored in the block store + // will be used. + int64 height = 1; + } + + // SubscribeNewHeightsRequest is a request to subscribe to new heights. + message SubscribeNewHeightsRequest {} + + // StatusRequest is a request to get the status of the node. + message StatusRequest {} + + + // StreamedBlockByHashResponse is a response to a BlockByHashRequest. + message StreamedBlockByHashResponse { + tendermint.types.Part block_part = 1; + // Commit is only set in the first part, and + // it stays nil in the remaining ones. + tendermint.types.Commit commit = 2; + // ValidatorSet is only set in the first part, and + // it stays nil in the remaining ones. + tendermint.types.ValidatorSet validator_set = 3; + bool is_last = 4; + } + + // StreamedBlockByHeightResponse is a response to a BlockByHeightRequest. + message StreamedBlockByHeightResponse { + tendermint.types.Part block_part = 1; + // Commit is only set in the first part, and + // it stays nil in the remaining ones. + tendermint.types.Commit commit = 2; + // ValidatorSet is only set in the first part, and + // it stays nil in the remaining ones. + tendermint.types.ValidatorSet validator_set = 3; + bool is_last = 4; + } + + // CommitResponse is a response to a CommitRequest. + message CommitResponse { + tendermint.types.Commit commit = 1; + } + + // ValidatorSetResponse is a response to a ValidatorSetRequest. + message ValidatorSetResponse { + // ValidatorSet the requested validator set. + tendermint.types.ValidatorSet validator_set = 1; + // Height the height corresponding to the returned + // validator set. + int64 height = 2; + } + + // NewHeightEvent is an event that indicates a new height. + message NewHeightEvent { + int64 height = 1; + bytes hash = 2; + } + + // StatusResponse is a response to a StatusRequest. + message StatusResponse { + tendermint.p2p.DefaultNodeInfo node_info = 1; + SyncInfo sync_info = 2; + ValidatorInfo validator_info = 3; + } + + // SyncInfo is information about the node's sync status. + message SyncInfo { + bytes latest_block_hash = 1; + bytes latest_app_hash = 2; + int64 latest_block_height = 3; + google.protobuf.Timestamp latest_block_time = 4 + [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; + + bytes earliest_block_hash = 5; + bytes earliest_app_hash = 6; + int64 earliest_block_height = 7; + google.protobuf.Timestamp earliest_block_time = 8 + [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; + + bool catching_up = 9; + } + + // ValidatorInfo is information about a validator. + message ValidatorInfo { + bytes address = 1; + tendermint.crypto.PublicKey pub_key = 2; + int64 voting_power = 3; + } \ No newline at end of file diff --git a/proto/cometbft/state/v2/types.proto b/proto/cometbft/state/v2/types.proto index fed728de8b9..6736109cf3f 100644 --- a/proto/cometbft/state/v2/types.proto +++ b/proto/cometbft/state/v2/types.proto @@ -114,3 +114,15 @@ message State { (gogoproto.stdduration) = true ]; } + +// TxInfo describes the location of a tx inside a committed block +// as well as the result of executing the transaction and the error log output. +message TxInfo { + int64 height = 1; + uint32 index = 2; + // The response code of executing the tx. 0 means + // successfully executed, all others are error codes. + uint32 code = 3; + // The error log output generated if the transaction execution fails. + string error = 4; +} diff --git a/proto/cometbft/types/v2/types.proto b/proto/cometbft/types/v2/types.proto index 5721b8b148c..1f248c3e9de 100644 --- a/proto/cometbft/types/v2/types.proto +++ b/proto/cometbft/types/v2/types.proto @@ -77,7 +77,31 @@ message Data { // NOTE: not all txs here are valid. We're just agreeing on the order first. // This means that block.AppHash does not include these txs. repeated bytes txs = 1; -} + + reserved 2, 3, 4; + // field number 2 is reserved for intermediate state roots + // field number 3 is reserved for evidence + // field number 4 is reserved for blobs + + // SquareSize is the number of rows or columns in the original data square. + uint64 square_size = 5; + + // Hash is the root of a binary Merkle tree where the leaves of the tree are + // the row and column roots of an extended data square. Hash is often referred + // to as the "data root". + bytes hash = 6; + } + + // Blob (named after binary large object) is a chunk of data submitted by a user + // to be published to the Celestia blockchain. The data of a Blob is published + // to a namespace and is encoded into shares based on the format specified by + // share_version. + message Blob { + bytes namespace_id = 1; + bytes data = 2; + uint32 share_version = 3; + uint32 namespace_version = 4; + } // Vote represents a prevote or precommit vote from validators for // consensus. @@ -198,3 +222,66 @@ message TxProof { bytes data = 2; cometbft.crypto.v1.Proof proof = 3; } + + + + +// IndexWrapper adds index metadata to a transaction. This is used to track +// transactions that pay for blobs, and where the blobs start in the square. +message IndexWrapper { + bytes tx = 1; + repeated uint32 share_indexes = 2; + string type_id = 3; + } + + // BlobTx wraps an encoded sdk.Tx with a second field to contain blobs of data. + // The raw bytes of the blobs are not signed over, instead we verify each blob + // using the relevant MsgPayForBlobs that is signed over in the encoded sdk.Tx. + message BlobTx { + bytes tx = 1; + repeated Blob blobs = 2; + string type_id = 3; + } + + // ShareProof is an NMT proof that a set of shares exist in a set of rows and a + // Merkle proof that those rows exist in a Merkle tree with a given data root. + message ShareProof { + repeated bytes data = 1; + repeated NMTProof share_proofs = 2; + bytes namespace_id = 3; + RowProof row_proof = 4; + uint32 namespace_version = 5; + } + + // RowProof is a Merkle proof that a set of rows exist in a Merkle tree with a + // given data root. + message RowProof { + repeated bytes row_roots = 1; + repeated cometbft.crypto.v1.Proof proofs = 2; + bytes root = 3; + uint32 start_row = 4; + uint32 end_row = 5; + } + + // NMTProof is a proof of a namespace.ID in an NMT. + // In case this proof proves the absence of a namespace.ID + // in a tree it also contains the leaf hashes of the range + // where that namespace would be. + message NMTProof { + // Start index of this proof. + int32 start = 1; + // End index of this proof. + int32 end = 2; + // Nodes that together with the corresponding leaf values can be used to + // recompute the root and verify this proof. Nodes should consist of the max + // and min namespaces along with the actual hash, resulting in each being 48 + // bytes each + repeated bytes nodes = 3; + // leafHash are nil if the namespace is present in the NMT. In case the + // namespace to be proved is in the min/max range of the tree but absent, this + // will contain the leaf hash necessary to verify the proof of absence. Leaf + // hashes should consist of the namespace along with the actual hash, + // resulting 40 bytes total. + bytes leaf_hash = 4; + } + \ No newline at end of file From 91ec4106d0226f6e36b82f87c30832ac19349bcb Mon Sep 17 00:00:00 2001 From: Marko Baricevic Date: Wed, 22 Jan 2025 12:03:05 +0100 Subject: [PATCH 3/4] generate protos --- api/cometbft/abci/v2/types.pb.go | 463 +- api/cometbft/mempool/v2/types.pb.go | 297 +- api/cometbft/rpc/grpc/v1beta3/types.pb.go | 4176 ++++++++++++++- api/cometbft/state/v2/types.pb.go | 413 +- api/cometbft/types/v2/types.pb.go | 5322 +++++++++++++------ proto/cometbft/rpc/grpc/v1beta3/types.proto | 34 +- 6 files changed, 8578 insertions(+), 2127 deletions(-) diff --git a/api/cometbft/abci/v2/types.pb.go b/api/cometbft/abci/v2/types.pb.go index d6e7770f191..7d12ed59c34 100644 --- a/api/cometbft/abci/v2/types.pb.go +++ b/api/cometbft/abci/v2/types.pb.go @@ -957,8 +957,9 @@ var xxx_messageInfo_ListSnapshotsRequest proto.InternalMessageInfo // Request offering a snapshot to the application. type OfferSnapshotRequest struct { - Snapshot *Snapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"` - AppHash []byte `protobuf:"bytes,2,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"` + Snapshot *Snapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"` + AppHash []byte `protobuf:"bytes,2,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"` + AppVersion uint64 `protobuf:"varint,3,opt,name=app_version,json=appVersion,proto3" json:"app_version,omitempty"` } func (m *OfferSnapshotRequest) Reset() { *m = OfferSnapshotRequest{} } @@ -1008,6 +1009,13 @@ func (m *OfferSnapshotRequest) GetAppHash() []byte { return nil } +func (m *OfferSnapshotRequest) GetAppVersion() uint64 { + if m != nil { + return m.AppVersion + } + return 0 +} + // Request to load a snapshot chunk. type LoadSnapshotChunkRequest struct { Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` @@ -3840,218 +3848,218 @@ func init() { func init() { proto.RegisterFile("cometbft/abci/v2/types.proto", fileDescriptor_6f0a5b1025f81964) } var fileDescriptor_6f0a5b1025f81964 = []byte{ - // 3365 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0x4b, 0x6c, 0x1b, 0xd7, - 0xb9, 0xf6, 0xf0, 0x25, 0xf2, 0xe7, 0x43, 0xa3, 0x23, 0xc9, 0xa6, 0x15, 0x47, 0x92, 0xc7, 0x71, - 0xec, 0xd8, 0x89, 0x74, 0xad, 0xe4, 0xe6, 0x79, 0x93, 0x80, 0xa2, 0xa9, 0x48, 0xb2, 0x2c, 0x31, - 0x43, 0x5a, 0x37, 0xf6, 0x7d, 0x4c, 0x46, 0xe4, 0xa1, 0x38, 0x31, 0x39, 0x33, 0x99, 0x39, 0x54, - 0xa4, 0x7b, 0x57, 0x2d, 0x9a, 0xa2, 0xc8, 0x2a, 0x9b, 0x02, 0x45, 0x81, 0x02, 0x05, 0x8a, 0x6e, - 0xbb, 0xe8, 0xbe, 0xbb, 0xa2, 0xc8, 0xaa, 0xc9, 0xb2, 0xab, 0xb4, 0x48, 0xd0, 0x4d, 0xf7, 0x05, - 0x0a, 0x74, 0x53, 0x9c, 0xc7, 0xbc, 0xc8, 0x19, 0xc9, 0x76, 0xd2, 0x45, 0xd1, 0xee, 0x78, 0xce, - 0xf9, 0xfe, 0x7f, 0xce, 0xf9, 0xcf, 0x39, 0xff, 0xe3, 0x3b, 0x84, 0x4b, 0x1d, 0x6b, 0x88, 0xc9, - 0x41, 0x8f, 0xac, 0xea, 0x07, 0x1d, 0x63, 0xf5, 0x68, 0x6d, 0x95, 0x9c, 0xd8, 0xd8, 0x5d, 0xb1, - 0x1d, 0x8b, 0x58, 0x48, 0xf6, 0x46, 0x57, 0xe8, 0xe8, 0xca, 0xd1, 0xda, 0xc2, 0xa2, 0x8f, 0xef, - 0x38, 0x27, 0x36, 0xb1, 0x56, 0x8f, 0x6e, 0xad, 0xda, 0x8e, 0x65, 0xf5, 0xb8, 0x44, 0x68, 0x9c, - 0xe9, 0xa1, 0x0a, 0x6d, 0xdd, 0xd1, 0x87, 0x42, 0xe3, 0xc2, 0xe5, 0xc9, 0xf1, 0x23, 0x7d, 0x60, - 0x74, 0x75, 0x62, 0x39, 0x02, 0x32, 0x77, 0x68, 0x1d, 0x5a, 0xec, 0xe7, 0x2a, 0xfd, 0x25, 0x7a, - 0x97, 0x0e, 0x2d, 0xeb, 0x70, 0x80, 0x57, 0x59, 0xeb, 0x60, 0xd4, 0x5b, 0x25, 0xc6, 0x10, 0xbb, - 0x44, 0x1f, 0xda, 0xde, 0x97, 0xc7, 0x01, 0xdd, 0x91, 0xa3, 0x13, 0xc3, 0x32, 0xf9, 0xb8, 0xf2, - 0x79, 0x01, 0xa6, 0x54, 0xfc, 0xe1, 0x08, 0xbb, 0x04, 0xbd, 0x08, 0x19, 0xdc, 0xe9, 0x5b, 0x55, - 0x69, 0x59, 0xba, 0x5e, 0x5c, 0x7b, 0x7a, 0x65, 0x7c, 0x99, 0x2b, 0x8d, 0x4e, 0xdf, 0x12, 0xe0, - 0xcd, 0x73, 0x2a, 0x03, 0xa3, 0x97, 0x21, 0xdb, 0x1b, 0x8c, 0xdc, 0x7e, 0x35, 0xc5, 0xa4, 0x16, - 0x27, 0xa5, 0x36, 0xe8, 0x70, 0x20, 0xc6, 0xe1, 0xf4, 0x63, 0x86, 0xd9, 0xb3, 0xaa, 0xe9, 0xa4, - 0x8f, 0x6d, 0x99, 0xbd, 0xf0, 0xc7, 0x28, 0x18, 0xd5, 0x01, 0x0c, 0xd3, 0x20, 0x5a, 0xa7, 0xaf, - 0x1b, 0x66, 0x35, 0xcb, 0x44, 0x95, 0x38, 0x51, 0x83, 0xd4, 0x29, 0x24, 0x90, 0x2f, 0x18, 0x5e, - 0x1f, 0x9d, 0xf1, 0x87, 0x23, 0xec, 0x9c, 0x54, 0x73, 0x49, 0x33, 0x7e, 0x97, 0x0e, 0x87, 0x66, - 0xcc, 0xe0, 0xe8, 0x4d, 0xc8, 0x77, 0xfa, 0xb8, 0xf3, 0x50, 0x23, 0xc7, 0xd5, 0x3c, 0x13, 0x5d, - 0x9e, 0x14, 0xad, 0x53, 0x44, 0xfb, 0x38, 0x10, 0x9e, 0xea, 0xf0, 0x1e, 0xf4, 0x1a, 0xe4, 0x3a, - 0xd6, 0x70, 0x68, 0x90, 0x6a, 0x91, 0x09, 0x2f, 0xc5, 0x08, 0xb3, 0xf1, 0x40, 0x56, 0x08, 0xa0, - 0x3d, 0xa8, 0x0c, 0x0c, 0x97, 0x68, 0xae, 0xa9, 0xdb, 0x6e, 0xdf, 0x22, 0x6e, 0xb5, 0xc4, 0x54, - 0x3c, 0x3b, 0xa9, 0x62, 0xc7, 0x70, 0x49, 0xcb, 0x83, 0x05, 0x9a, 0xca, 0x83, 0x70, 0x3f, 0x55, - 0x68, 0xf5, 0x7a, 0xd8, 0xf1, 0x35, 0x56, 0xcb, 0x49, 0x0a, 0xf7, 0x28, 0xce, 0x93, 0x0c, 0x29, - 0xb4, 0xc2, 0xfd, 0xe8, 0xbf, 0x61, 0x76, 0x60, 0xe9, 0x5d, 0x5f, 0x9f, 0xd6, 0xe9, 0x8f, 0xcc, - 0x87, 0xd5, 0x0a, 0xd3, 0x7a, 0x23, 0x66, 0x9a, 0x96, 0xde, 0xf5, 0x84, 0xeb, 0x14, 0x1a, 0x68, - 0x9e, 0x19, 0x8c, 0x8f, 0x21, 0x0d, 0xe6, 0x74, 0xdb, 0x1e, 0x9c, 0x8c, 0xab, 0x9f, 0x66, 0xea, - 0x6f, 0x4e, 0xaa, 0xaf, 0x51, 0x74, 0x82, 0x7e, 0xa4, 0x4f, 0x0c, 0xa2, 0x7b, 0x20, 0xdb, 0x0e, - 0xb6, 0x75, 0x07, 0x6b, 0xb6, 0x63, 0xd9, 0x96, 0xab, 0x0f, 0xaa, 0x32, 0x53, 0x7e, 0x7d, 0x52, - 0x79, 0x93, 0x23, 0x9b, 0x02, 0x18, 0x68, 0x9e, 0xb6, 0xa3, 0x23, 0x5c, 0xad, 0xd5, 0xc1, 0xae, - 0x1b, 0xa8, 0x9d, 0x49, 0x56, 0xcb, 0x90, 0xb1, 0x6a, 0x23, 0x23, 0x68, 0x03, 0x8a, 0xf8, 0x98, - 0x60, 0xb3, 0xab, 0x1d, 0x59, 0x04, 0x57, 0x11, 0xd3, 0x78, 0x25, 0xe6, 0xba, 0x32, 0xd0, 0xbe, - 0x45, 0x70, 0xa0, 0x0c, 0xb0, 0xdf, 0x89, 0x0e, 0x60, 0xfe, 0x08, 0x3b, 0x46, 0xef, 0x84, 0xe9, - 0xd1, 0xd8, 0x88, 0x6b, 0x58, 0x66, 0x75, 0x96, 0x69, 0x7c, 0x7e, 0x52, 0xe3, 0x3e, 0x83, 0x53, - 0xe1, 0x86, 0x07, 0x0e, 0x54, 0xcf, 0x1e, 0x4d, 0x8e, 0xd2, 0x93, 0xd6, 0x33, 0x4c, 0x7d, 0x60, - 0xfc, 0x1f, 0xd6, 0x0e, 0x06, 0x56, 0xe7, 0x61, 0x75, 0x2e, 0xe9, 0xa4, 0x6d, 0x08, 0xdc, 0x3a, - 0x85, 0x85, 0x4e, 0x5a, 0x2f, 0xdc, 0xbf, 0x3e, 0x05, 0xd9, 0x23, 0x7d, 0x30, 0xc2, 0xdb, 0x99, - 0x7c, 0x46, 0xce, 0x6e, 0x67, 0xf2, 0x53, 0x72, 0x7e, 0x3b, 0x93, 0x2f, 0xc8, 0xb0, 0x9d, 0xc9, - 0x83, 0x5c, 0x54, 0xae, 0x41, 0x31, 0xe4, 0xa7, 0x50, 0x15, 0xa6, 0x86, 0xd8, 0x75, 0xf5, 0x43, - 0xcc, 0xfc, 0x5a, 0x41, 0xf5, 0x9a, 0x4a, 0x05, 0x4a, 0x61, 0xd7, 0xa4, 0x7c, 0x2a, 0x41, 0x31, - 0xe4, 0x74, 0xa8, 0xe4, 0x11, 0x76, 0x98, 0x41, 0x84, 0xa4, 0x68, 0xa2, 0x2b, 0x50, 0x66, 0x6b, - 0xd1, 0xbc, 0x71, 0xea, 0xfb, 0x32, 0x6a, 0x89, 0x75, 0xee, 0x0b, 0xd0, 0x12, 0x14, 0xed, 0x35, - 0xdb, 0x87, 0xa4, 0x19, 0x04, 0xec, 0x35, 0xdb, 0x03, 0x5c, 0x86, 0x12, 0x5d, 0xba, 0x8f, 0xc8, - 0xb0, 0x8f, 0x14, 0x69, 0x9f, 0x80, 0x28, 0xbf, 0x4d, 0x81, 0x3c, 0xee, 0xcc, 0xd0, 0xab, 0x90, - 0xa1, 0x5e, 0x5e, 0xb8, 0xe9, 0x85, 0x15, 0xee, 0xe1, 0x57, 0x3c, 0x0f, 0xbf, 0xd2, 0xf6, 0x42, - 0xc0, 0x7a, 0xfe, 0xb3, 0x2f, 0x97, 0xce, 0x7d, 0xfa, 0xfb, 0x25, 0x49, 0x65, 0x12, 0xe8, 0x22, - 0xf5, 0x60, 0xba, 0x61, 0x6a, 0x46, 0x97, 0x4d, 0xb9, 0x40, 0xbd, 0x93, 0x6e, 0x98, 0x5b, 0x5d, - 0x74, 0x17, 0xe4, 0x8e, 0x65, 0xba, 0xd8, 0x74, 0x47, 0xae, 0xc6, 0x63, 0x93, 0x70, 0xcd, 0x21, - 0xff, 0xca, 0x83, 0x20, 0x73, 0x54, 0x02, 0xda, 0x64, 0x48, 0x75, 0xba, 0x13, 0xed, 0x40, 0xef, - 0x00, 0xf8, 0x01, 0xcc, 0xad, 0x66, 0x96, 0xd3, 0xd7, 0x8b, 0x6b, 0x97, 0x63, 0xce, 0x93, 0x87, - 0xb9, 0x67, 0x77, 0x75, 0x82, 0xd7, 0x33, 0x74, 0xc2, 0x6a, 0x48, 0x14, 0x3d, 0x0b, 0xd3, 0xba, - 0x6d, 0x6b, 0x2e, 0xd1, 0x09, 0xd6, 0x0e, 0x4e, 0x08, 0x76, 0x99, 0xdb, 0x2f, 0xa9, 0x65, 0xdd, - 0xb6, 0x5b, 0xb4, 0x77, 0x9d, 0x76, 0xa2, 0xab, 0x50, 0xa1, 0x1e, 0xde, 0xd0, 0x07, 0x5a, 0x1f, - 0x1b, 0x87, 0x7d, 0xc2, 0xbc, 0x7b, 0x5a, 0x2d, 0x8b, 0xde, 0x4d, 0xd6, 0xa9, 0x74, 0xa1, 0x14, - 0x76, 0xee, 0x08, 0x41, 0xa6, 0xab, 0x13, 0x9d, 0xd9, 0xb2, 0xa4, 0xb2, 0xdf, 0xb4, 0xcf, 0xd6, - 0x49, 0x5f, 0x58, 0x88, 0xfd, 0x46, 0xe7, 0x21, 0x27, 0xd4, 0xa6, 0x99, 0x5a, 0xd1, 0x42, 0x73, - 0x90, 0xb5, 0x1d, 0xeb, 0x08, 0xb3, 0xcd, 0xcb, 0xab, 0xbc, 0xa1, 0xdc, 0x87, 0x4a, 0x34, 0x0e, - 0xa0, 0x0a, 0xa4, 0xc8, 0xb1, 0xf8, 0x4a, 0x8a, 0x1c, 0xa3, 0x5b, 0x90, 0xa1, 0xc6, 0x64, 0xda, - 0x2a, 0x71, 0xd1, 0x4f, 0xc8, 0xb7, 0x4f, 0x6c, 0xac, 0x32, 0xe8, 0x76, 0x26, 0x9f, 0x92, 0xd3, - 0xca, 0x34, 0x94, 0x23, 0x51, 0x42, 0x39, 0x0f, 0x73, 0x71, 0x3e, 0x5f, 0x31, 0x60, 0x2e, 0xce, - 0x75, 0xa3, 0x97, 0x21, 0xef, 0x3b, 0x7d, 0xef, 0x04, 0x4d, 0x7c, 0xdd, 0x17, 0xf2, 0xb1, 0xf4, - 0xec, 0xd0, 0x8d, 0xe8, 0xeb, 0x22, 0xd4, 0x97, 0xd4, 0x29, 0xdd, 0xb6, 0x37, 0x75, 0xb7, 0xaf, - 0xbc, 0x0f, 0xd5, 0x24, 0x7f, 0x1e, 0x32, 0x9c, 0xc4, 0x2e, 0x80, 0x67, 0xb8, 0xf3, 0x90, 0xeb, - 0x59, 0xce, 0x50, 0x27, 0x4c, 0x59, 0x59, 0x15, 0x2d, 0x6a, 0x50, 0xee, 0xdb, 0xd3, 0xac, 0x9b, - 0x37, 0x14, 0x0d, 0x2e, 0x26, 0xba, 0x74, 0x2a, 0x62, 0x98, 0x5d, 0xcc, 0xcd, 0x5b, 0x56, 0x79, - 0x23, 0x50, 0xc4, 0x27, 0xcb, 0x1b, 0xf4, 0xb3, 0x2e, 0x36, 0xbb, 0xd8, 0x61, 0xfa, 0x0b, 0xaa, - 0x68, 0x29, 0x3f, 0x4e, 0xc3, 0xf9, 0x78, 0xbf, 0x8e, 0x96, 0xa1, 0x34, 0xd4, 0x8f, 0x35, 0x72, - 0x2c, 0x8e, 0x9f, 0xc4, 0x0e, 0x00, 0x0c, 0xf5, 0xe3, 0xf6, 0x31, 0x3f, 0x7b, 0x32, 0xa4, 0xc9, - 0xb1, 0x5b, 0x4d, 0x2d, 0xa7, 0xaf, 0x97, 0x54, 0xfa, 0x13, 0xed, 0xc3, 0xcc, 0xc0, 0xea, 0xe8, - 0x03, 0x6d, 0xa0, 0xbb, 0x44, 0x13, 0x61, 0x9f, 0x5f, 0xa7, 0x67, 0x92, 0xfc, 0x34, 0xee, 0xf2, - 0x8d, 0xa5, 0x2e, 0x48, 0x5c, 0x84, 0x69, 0xa6, 0x64, 0x47, 0x77, 0x09, 0x1f, 0x42, 0x0d, 0x28, - 0x0e, 0x0d, 0xf7, 0x00, 0xf7, 0xf5, 0x23, 0xc3, 0x72, 0xc4, 0xbd, 0x8a, 0x39, 0x3d, 0x77, 0x03, - 0x90, 0x50, 0x15, 0x96, 0x0b, 0x6d, 0x4a, 0x36, 0x72, 0x9a, 0x3d, 0xcf, 0x92, 0x7b, 0x6c, 0xcf, - 0xf2, 0x6f, 0x30, 0x67, 0xe2, 0x63, 0xa2, 0x05, 0x37, 0x97, 0x9f, 0x94, 0x29, 0x66, 0x7c, 0x44, - 0xc7, 0xfc, 0xbb, 0xee, 0xd2, 0x43, 0x83, 0x9e, 0x63, 0xb1, 0xd1, 0xb6, 0x5c, 0xec, 0x68, 0x7a, - 0xb7, 0xeb, 0x60, 0xd7, 0x65, 0x59, 0x55, 0x89, 0xc5, 0x3b, 0xd6, 0x5f, 0xe3, 0xdd, 0xca, 0x27, - 0x6c, 0x73, 0xe2, 0xa2, 0xa3, 0x67, 0x7a, 0x29, 0x30, 0x7d, 0x1b, 0xe6, 0x84, 0x7c, 0x37, 0x62, - 0x7d, 0x9e, 0x9e, 0x5e, 0x4a, 0x4a, 0xba, 0x42, 0x56, 0x47, 0x9e, 0x7c, 0xb2, 0xe1, 0xd3, 0x4f, - 0x68, 0x78, 0x04, 0x19, 0x66, 0x96, 0x0c, 0x77, 0x37, 0xf4, 0xf7, 0x3f, 0xda, 0x66, 0x7c, 0x9c, - 0x86, 0x99, 0x89, 0xc4, 0xc2, 0x5f, 0x98, 0x14, 0xbb, 0xb0, 0x54, 0xec, 0xc2, 0xd2, 0x8f, 0xbd, - 0x30, 0xb1, 0xdb, 0x99, 0xb3, 0x77, 0x3b, 0xfb, 0x6d, 0xee, 0x76, 0xee, 0x09, 0x77, 0xfb, 0xef, - 0xba, 0x0f, 0x9f, 0x4b, 0xb0, 0x90, 0x9c, 0x8e, 0xc5, 0x6e, 0xc8, 0x4d, 0x98, 0xf1, 0xa7, 0xe2, - 0xab, 0xe7, 0xee, 0x51, 0xf6, 0x07, 0x84, 0xfe, 0xc4, 0x88, 0x77, 0x15, 0x2a, 0x63, 0xd9, 0x22, - 0x3f, 0xcc, 0xe5, 0xa3, 0x48, 0xde, 0x77, 0x0b, 0xe6, 0x4d, 0xcb, 0xd4, 0x1c, 0x7b, 0x3c, 0xb7, - 0xcc, 0x8a, 0xc5, 0x5b, 0xa6, 0x6a, 0x47, 0x66, 0xae, 0xfc, 0x32, 0x0d, 0x73, 0x71, 0x39, 0x60, - 0xcc, 0x25, 0x57, 0x61, 0xb6, 0x8b, 0x3b, 0x46, 0xf7, 0x89, 0xef, 0xf8, 0x8c, 0x10, 0xff, 0xd7, - 0x15, 0x9f, 0x3c, 0x5a, 0xe8, 0x06, 0xcc, 0xb8, 0x27, 0x66, 0xc7, 0x30, 0x0f, 0x35, 0x62, 0x79, - 0xe9, 0x54, 0x81, 0xcd, 0x7c, 0x5a, 0x0c, 0xb4, 0x2d, 0x91, 0x50, 0xfd, 0x1c, 0x20, 0xaf, 0x62, - 0xd7, 0xa6, 0xf9, 0x1f, 0xaa, 0x43, 0x01, 0x1f, 0x77, 0xb0, 0x4d, 0xbc, 0x9c, 0x39, 0xa1, 0x2c, - 0x11, 0x10, 0x4f, 0x8e, 0x96, 0xe7, 0xbe, 0x1c, 0x7a, 0x49, 0xb0, 0x10, 0x89, 0x7c, 0x02, 0xcf, - 0xee, 0x7d, 0x51, 0x4e, 0x43, 0xbc, 0xe2, 0xd1, 0x10, 0xe9, 0xa4, 0xe2, 0x5a, 0xe4, 0xfa, 0xbe, - 0x9c, 0xe0, 0x21, 0x5e, 0x12, 0x3c, 0x44, 0x26, 0xe9, 0x73, 0xbc, 0x24, 0x08, 0x3e, 0xc7, 0x88, - 0x88, 0xdb, 0x11, 0x22, 0x22, 0x97, 0xb4, 0xd4, 0x50, 0xee, 0x1e, 0x2c, 0x35, 0x60, 0x22, 0x5e, - 0xf1, 0x98, 0x88, 0xa9, 0xa4, 0x49, 0x8b, 0x64, 0x35, 0x98, 0x34, 0xa7, 0x22, 0xde, 0x0a, 0x51, - 0x11, 0x05, 0x26, 0x7b, 0xf9, 0x14, 0x2a, 0xc2, 0x97, 0xf6, 0xb9, 0x88, 0xd7, 0x7d, 0x2e, 0xa2, - 0x94, 0x48, 0x64, 0x88, 0x2c, 0xd3, 0x17, 0xf6, 0xc8, 0x88, 0xe6, 0x04, 0x19, 0xc1, 0xb9, 0x83, - 0x6b, 0x67, 0x92, 0x11, 0xbe, 0xaa, 0x31, 0x36, 0xa2, 0x39, 0xc1, 0x46, 0x54, 0x92, 0x34, 0x8e, - 0xa5, 0xb4, 0x81, 0xc6, 0x28, 0x1d, 0xf1, 0x3f, 0xf1, 0x74, 0x44, 0x22, 0x5f, 0x10, 0x93, 0xbe, - 0xfa, 0xaa, 0x63, 0xf8, 0x88, 0xf7, 0x13, 0xf8, 0x08, 0x39, 0xa9, 0x6e, 0x8e, 0x4b, 0x5e, 0xfd, - 0x0f, 0xc4, 0x11, 0x12, 0xfb, 0x31, 0x84, 0x04, 0x67, 0x0e, 0x9e, 0x7b, 0x04, 0x42, 0xc2, 0x57, - 0x3d, 0xc1, 0x48, 0xec, 0xc7, 0x30, 0x12, 0x28, 0x59, 0xef, 0x58, 0xce, 0x15, 0xd6, 0x1b, 0xa5, - 0x24, 0xde, 0x89, 0x52, 0x12, 0xb3, 0xa7, 0xa7, 0xba, 0x3c, 0x73, 0xf0, 0xb5, 0x85, 0x39, 0x89, - 0x4e, 0x12, 0x27, 0xc1, 0x69, 0x83, 0x17, 0x1e, 0x91, 0x93, 0xf0, 0x75, 0xc7, 0x92, 0x12, 0xcd, - 0x09, 0x52, 0x62, 0x3e, 0xe9, 0xc0, 0x8d, 0x05, 0xa4, 0xe0, 0xc0, 0x25, 0xb2, 0x12, 0x59, 0x39, - 0xb7, 0x9d, 0xc9, 0xe7, 0xe5, 0x02, 0xe7, 0x23, 0xb6, 0x33, 0xf9, 0xa2, 0x5c, 0x52, 0x9e, 0xa3, - 0x59, 0xd3, 0x98, 0xdf, 0xa3, 0x35, 0x0a, 0x76, 0x1c, 0xcb, 0x11, 0xfc, 0x02, 0x6f, 0x28, 0xd7, - 0xa1, 0x14, 0x76, 0x71, 0xa7, 0x30, 0x18, 0xd3, 0x50, 0x8e, 0x78, 0x35, 0xe5, 0xaf, 0x29, 0x28, - 0x85, 0xfd, 0x55, 0xa4, 0xbe, 0x2d, 0x88, 0xfa, 0x36, 0xc4, 0x6b, 0xa4, 0xa2, 0xbc, 0xc6, 0x12, - 0x14, 0x69, 0x8d, 0x37, 0x46, 0x59, 0xe8, 0xb6, 0x4f, 0x59, 0xdc, 0x80, 0x19, 0x16, 0x6f, 0x39, - 0xfb, 0x21, 0x22, 0x43, 0x86, 0x47, 0x06, 0x3a, 0xc0, 0x8c, 0xc1, 0x23, 0x03, 0x7a, 0x01, 0x66, - 0x43, 0x58, 0xbf, 0x76, 0xe4, 0xf1, 0x5f, 0xf6, 0xd1, 0x35, 0x5e, 0x44, 0xa2, 0xff, 0x82, 0xe9, - 0x81, 0x6e, 0xd2, 0xe3, 0x6e, 0x58, 0x8e, 0x41, 0x0c, 0xec, 0x8a, 0xbc, 0x6b, 0xed, 0x74, 0x97, - 0xbc, 0xb2, 0xa3, 0x9b, 0xb8, 0xe9, 0x0b, 0x35, 0x4c, 0xe2, 0x9c, 0xa8, 0x95, 0x41, 0xa4, 0x13, - 0x5d, 0x86, 0x52, 0x17, 0xf7, 0xf4, 0xd1, 0x80, 0x68, 0x74, 0x84, 0xf9, 0xdb, 0x82, 0x5a, 0x14, - 0x7d, 0x54, 0xc3, 0x42, 0x0d, 0x66, 0x63, 0x34, 0xd1, 0xdc, 0xe3, 0x21, 0x3e, 0x11, 0xf6, 0xa3, - 0x3f, 0xe9, 0xa6, 0xb1, 0xad, 0x16, 0x85, 0x2b, 0x6f, 0xbc, 0x9e, 0x7a, 0x55, 0x52, 0x7e, 0x23, - 0xc1, 0xcc, 0x84, 0xc7, 0x8f, 0x65, 0x56, 0xa4, 0x6f, 0x8b, 0x59, 0x49, 0x3d, 0x39, 0xb3, 0x12, - 0x2e, 0xe8, 0xd3, 0xd1, 0x82, 0xfe, 0x2f, 0x12, 0x94, 0x23, 0x91, 0x87, 0x9e, 0xa3, 0x8e, 0xd5, - 0xc5, 0xa2, 0xc4, 0x66, 0xbf, 0xa9, 0x69, 0x06, 0xd6, 0xa1, 0x28, 0xa4, 0xe9, 0x4f, 0x8a, 0xf2, - 0x63, 0x69, 0x41, 0x44, 0x4a, 0xbf, 0x3a, 0xe7, 0xa9, 0x8f, 0xa8, 0xce, 0x85, 0x59, 0x73, 0xec, - 0xbb, 0x51, 0xb3, 0xf2, 0x14, 0x86, 0x37, 0xd0, 0x6b, 0x50, 0x60, 0xef, 0x28, 0x9a, 0x65, 0xbb, - 0x82, 0x74, 0x0f, 0xa5, 0x77, 0xfc, 0xb1, 0x65, 0xe5, 0xe8, 0x16, 0x75, 0x55, 0x56, 0x6f, 0xcf, - 0x76, 0xd5, 0xbc, 0x2d, 0x7e, 0x85, 0x92, 0xae, 0x42, 0x24, 0xe9, 0xba, 0x04, 0x05, 0x3a, 0x7d, - 0xd7, 0xd6, 0x3b, 0xb8, 0x0a, 0x6c, 0xa6, 0x41, 0x87, 0xf2, 0xeb, 0x14, 0x4c, 0x8f, 0x05, 0xce, - 0xd8, 0xc5, 0x7b, 0x17, 0x2b, 0x15, 0x22, 0x8e, 0x1e, 0xcd, 0x20, 0x8b, 0x00, 0x87, 0xba, 0xab, - 0x7d, 0xa4, 0x9b, 0x04, 0x77, 0x85, 0x55, 0x42, 0x3d, 0x68, 0x01, 0xf2, 0xb4, 0x35, 0x72, 0x71, - 0x57, 0x70, 0x58, 0x7e, 0x1b, 0x6d, 0x41, 0x0e, 0x1f, 0x61, 0x93, 0xb8, 0xd5, 0x29, 0xb6, 0xf1, - 0x17, 0x62, 0x3c, 0x2c, 0x1d, 0x5f, 0xaf, 0xd2, 0xed, 0xfe, 0xd3, 0x97, 0x4b, 0x32, 0x87, 0x3f, - 0x6f, 0x0d, 0x0d, 0x82, 0x87, 0x36, 0x39, 0x51, 0x85, 0x82, 0xa8, 0x19, 0xf2, 0x63, 0x66, 0x40, - 0x17, 0x60, 0x8a, 0xdd, 0x46, 0xa3, 0xcb, 0x32, 0x84, 0x82, 0x9a, 0xa3, 0xcd, 0xad, 0x2e, 0x63, - 0x5a, 0x4b, 0x1e, 0x6d, 0x42, 0xad, 0xcd, 0xae, 0xcb, 0x89, 0x5a, 0x1e, 0xe2, 0xa1, 0x6d, 0x59, - 0x03, 0x8d, 0xfb, 0xb0, 0x1a, 0x54, 0xa2, 0x09, 0x04, 0xba, 0x02, 0x65, 0x07, 0x13, 0xdd, 0x30, - 0xb5, 0x48, 0x59, 0x51, 0xe2, 0x9d, 0xdc, 0x67, 0x6c, 0x67, 0xf2, 0x92, 0x9c, 0x12, 0x4c, 0xd7, - 0xbb, 0x30, 0x1f, 0x9b, 0x3f, 0xa0, 0x57, 0xa1, 0x10, 0xe4, 0x1e, 0x12, 0xb3, 0xc3, 0x69, 0x14, - 0x56, 0x00, 0x56, 0xf6, 0x61, 0x3e, 0x36, 0x81, 0x40, 0x6f, 0x42, 0xce, 0xc1, 0xee, 0x68, 0xc0, - 0x59, 0xaa, 0xca, 0xda, 0xd5, 0xb3, 0x33, 0x8f, 0xd1, 0x80, 0xa8, 0x42, 0x48, 0xb9, 0x05, 0x17, - 0x13, 0x33, 0x88, 0x80, 0x88, 0x92, 0x42, 0x44, 0x94, 0xf2, 0x0b, 0x09, 0x16, 0x92, 0xb3, 0x02, - 0xb4, 0x3e, 0x36, 0xa1, 0x1b, 0x8f, 0x98, 0x53, 0x84, 0x66, 0x45, 0x2b, 0x35, 0x07, 0xf7, 0x30, - 0xe9, 0xf4, 0x79, 0x7a, 0xc2, 0xbd, 0x45, 0x59, 0x2d, 0x8b, 0x5e, 0x26, 0xe3, 0x72, 0xd8, 0x07, - 0xb8, 0x43, 0x34, 0xbe, 0xa9, 0x2e, 0x2b, 0x7d, 0x0a, 0x14, 0x46, 0x7b, 0x5b, 0xbc, 0x53, 0xb9, - 0x09, 0x17, 0x12, 0xf2, 0x8c, 0xc9, 0xfa, 0x4c, 0x79, 0x40, 0xc1, 0xb1, 0xc9, 0x03, 0x7a, 0x1b, - 0x72, 0x2e, 0xd1, 0xc9, 0xc8, 0x15, 0x2b, 0xbb, 0x76, 0x66, 0xde, 0xd1, 0x62, 0x70, 0x55, 0x88, - 0x29, 0x18, 0xd0, 0x64, 0x16, 0x11, 0x53, 0x96, 0x4a, 0x71, 0x65, 0xe9, 0x75, 0x90, 0x45, 0x59, - 0x1a, 0x00, 0xf9, 0x15, 0xae, 0xb0, 0x8a, 0x34, 0xa8, 0x46, 0x0f, 0xe0, 0xa9, 0x53, 0x32, 0x0b, - 0x54, 0x1f, 0x5b, 0xc6, 0xcd, 0x47, 0x4a, 0x4c, 0xc6, 0x96, 0xf2, 0xab, 0x34, 0xcc, 0xc7, 0x26, - 0x18, 0xa1, 0x8b, 0x2e, 0x7d, 0xd3, 0x8b, 0xfe, 0x26, 0x00, 0x39, 0xd6, 0xf8, 0x99, 0xf0, 0x02, - 0x46, 0x5c, 0x55, 0x75, 0x8c, 0x3b, 0xcc, 0xe7, 0xd1, 0x23, 0x54, 0x20, 0xe2, 0x97, 0x8b, 0xda, - 0x61, 0xd2, 0x60, 0xc4, 0x82, 0x89, 0x2b, 0x8a, 0xe3, 0x47, 0x0e, 0x3b, 0x01, 0xbb, 0xc0, 0xbb, - 0x5d, 0xf4, 0x00, 0x2e, 0x8c, 0x05, 0x45, 0x5f, 0x77, 0xe6, 0x91, 0x63, 0xe3, 0x7c, 0x34, 0x36, - 0x7a, 0xba, 0xc3, 0x81, 0x2d, 0x1b, 0x09, 0x6c, 0x34, 0x16, 0xb3, 0xb2, 0x99, 0xe7, 0x24, 0x5d, - 0x3c, 0xd0, 0xbd, 0x57, 0xe0, 0x8b, 0x13, 0xc5, 0xf7, 0x6d, 0xf1, 0x50, 0xce, 0x6b, 0xef, 0x1f, - 0xd1, 0xda, 0xbb, 0x42, 0x85, 0xd9, 0x46, 0xdd, 0xa6, 0xa2, 0xca, 0x03, 0x80, 0x80, 0x59, 0xa0, - 0x17, 0xdd, 0xb1, 0x46, 0x66, 0x97, 0x9d, 0x88, 0xac, 0xca, 0x1b, 0xe8, 0x65, 0xc8, 0xd2, 0x23, - 0xe8, 0x59, 0x3e, 0xc6, 0x53, 0xd1, 0x13, 0x12, 0xa2, 0x26, 0x38, 0x5c, 0xf9, 0xc0, 0x3b, 0xe6, - 0x61, 0x5e, 0x38, 0xe1, 0x1b, 0x6f, 0x45, 0xbf, 0xa1, 0x24, 0x53, 0xcc, 0xf1, 0xdf, 0xfa, 0x7f, - 0xc8, 0xb2, 0xd3, 0x44, 0xe3, 0x15, 0x7b, 0x96, 0x10, 0xe9, 0x22, 0xfd, 0x8d, 0xfe, 0x17, 0x40, - 0x27, 0xc4, 0x31, 0x0e, 0x46, 0xc1, 0x17, 0x96, 0x13, 0x8e, 0x63, 0xcd, 0x03, 0xae, 0x5f, 0x12, - 0xe7, 0x72, 0x2e, 0x90, 0x0d, 0x9d, 0xcd, 0x90, 0x46, 0x65, 0x17, 0x2a, 0x51, 0xd9, 0xb3, 0x72, - 0xae, 0x82, 0x97, 0x1c, 0xf8, 0xa9, 0x45, 0x9a, 0x3f, 0xbe, 0xb0, 0x86, 0xf2, 0x9d, 0x14, 0x94, - 0xc2, 0x87, 0xf9, 0x9f, 0x30, 0x7c, 0x2b, 0xdf, 0x97, 0x20, 0xef, 0xaf, 0x3f, 0xfa, 0x04, 0x13, - 0x79, 0xbb, 0xe2, 0xe6, 0x4b, 0x85, 0xdf, 0x4d, 0xf8, 0x4b, 0x55, 0xda, 0x7f, 0xa9, 0xfa, 0x0f, - 0x3f, 0x12, 0x25, 0x32, 0x24, 0x61, 0x6b, 0x8b, 0x83, 0xe5, 0x45, 0xc6, 0x37, 0xa0, 0xe0, 0xbb, - 0x04, 0x5a, 0x78, 0x78, 0xcc, 0x93, 0x24, 0xee, 0xa5, 0x60, 0x9c, 0xe6, 0x20, 0x6b, 0x5b, 0x1f, - 0x89, 0x57, 0x99, 0xb4, 0xca, 0x1b, 0x8a, 0x0b, 0xd3, 0x63, 0xfe, 0x24, 0x00, 0xa6, 0x42, 0x40, - 0xa4, 0x40, 0xd9, 0x1e, 0x1d, 0x68, 0x0f, 0xf1, 0x89, 0x78, 0xa3, 0xe1, 0xd3, 0x2f, 0xda, 0xa3, - 0x83, 0x3b, 0xf8, 0x84, 0x3f, 0xd2, 0x2c, 0x43, 0xc9, 0xc3, 0xb0, 0x23, 0xce, 0xf7, 0x14, 0x38, - 0xa4, 0xcd, 0x1f, 0xd8, 0x24, 0x39, 0xa5, 0xfc, 0x50, 0x82, 0xbc, 0x77, 0x4b, 0xd0, 0xdb, 0x50, - 0xf0, 0x5d, 0x97, 0x48, 0xda, 0x9f, 0x3a, 0xc5, 0xe9, 0x89, 0xc5, 0x07, 0x32, 0x68, 0xdd, 0x7b, - 0x29, 0x36, 0xba, 0x5a, 0x6f, 0xa0, 0x1f, 0x8a, 0x07, 0xbf, 0xc5, 0x18, 0xef, 0xc6, 0xfc, 0xca, - 0xd6, 0xed, 0x8d, 0x81, 0x7e, 0xa8, 0x16, 0x99, 0xd0, 0x56, 0x97, 0x36, 0x44, 0x3a, 0xf4, 0xc7, - 0x14, 0xc8, 0xe3, 0xb7, 0xf8, 0x9b, 0xcf, 0x6f, 0x32, 0x6c, 0xa6, 0xe3, 0xc2, 0xe6, 0x2a, 0xcc, - 0xfa, 0x08, 0xcd, 0x35, 0x0e, 0x4d, 0x9d, 0x8c, 0x1c, 0x2c, 0x38, 0x4e, 0xe4, 0x0f, 0xb5, 0xbc, - 0x91, 0xc9, 0x75, 0x67, 0x1f, 0x7b, 0xdd, 0xc9, 0x14, 0x72, 0x2e, 0x89, 0x42, 0x46, 0x6f, 0xc0, - 0xc2, 0x78, 0x78, 0x0f, 0x4d, 0x97, 0x57, 0x16, 0x17, 0xa2, 0x81, 0xde, 0x9f, 0xb3, 0xb0, 0xf3, - 0xc7, 0x29, 0x28, 0x86, 0x28, 0x5e, 0xf4, 0xef, 0x21, 0x97, 0x58, 0x89, 0x0b, 0x79, 0x21, 0x70, - 0xf0, 0x5a, 0x1b, 0xdd, 0x99, 0xd4, 0x13, 0xec, 0x4c, 0x12, 0xff, 0xee, 0x71, 0xc6, 0x99, 0xc7, - 0xe6, 0x8c, 0x9f, 0x07, 0x44, 0x2c, 0xa2, 0x0f, 0xa8, 0x39, 0x0d, 0xf3, 0x50, 0xe3, 0x17, 0x89, - 0x7b, 0x30, 0x99, 0x8d, 0xec, 0xb3, 0x81, 0x26, 0xbb, 0x7c, 0xdf, 0x95, 0x20, 0xef, 0xf3, 0x69, - 0x8f, 0xfb, 0x8a, 0x7b, 0x1e, 0x72, 0x22, 0xe5, 0xe4, 0xcf, 0xb8, 0xa2, 0x15, 0x4b, 0x8e, 0x2f, - 0x40, 0x7e, 0x88, 0x89, 0xce, 0xdc, 0x31, 0x0f, 0xd7, 0x7e, 0xfb, 0xc6, 0x01, 0x14, 0x43, 0x0f, - 0xe1, 0xe8, 0x22, 0xcc, 0xd7, 0x37, 0x1b, 0xf5, 0x3b, 0x5a, 0xfb, 0x3d, 0xad, 0x7d, 0xbf, 0xd9, - 0xd0, 0xee, 0xed, 0xde, 0xd9, 0xdd, 0xfb, 0xcf, 0x5d, 0xf9, 0xdc, 0xe4, 0x90, 0xda, 0x60, 0x6d, - 0x59, 0x42, 0x17, 0x60, 0x36, 0x3a, 0xc4, 0x07, 0x52, 0x0b, 0x99, 0x1f, 0xfc, 0x6c, 0xf1, 0xdc, - 0x8d, 0x3f, 0x4b, 0x30, 0x1b, 0x93, 0xdc, 0xa3, 0xcb, 0xf0, 0xf4, 0xde, 0xc6, 0x46, 0x43, 0xd5, - 0x5a, 0xbb, 0xb5, 0x66, 0x6b, 0x73, 0xaf, 0xad, 0xa9, 0x8d, 0xd6, 0xbd, 0x9d, 0x76, 0xe8, 0xa3, - 0xcb, 0x70, 0x29, 0x1e, 0x52, 0xab, 0xd7, 0x1b, 0xcd, 0xb6, 0x2c, 0xa1, 0x25, 0x78, 0x2a, 0x01, - 0xb1, 0xbe, 0xa7, 0xb6, 0xe5, 0x54, 0xb2, 0x0a, 0xb5, 0xb1, 0xdd, 0xa8, 0xb7, 0xe5, 0x34, 0xba, - 0x06, 0x57, 0x4e, 0x43, 0x68, 0x1b, 0x7b, 0xea, 0xdd, 0x5a, 0x5b, 0xce, 0x9c, 0x09, 0x6c, 0x35, - 0x76, 0x6f, 0x37, 0x54, 0x39, 0x2b, 0xd6, 0xfd, 0xd3, 0x14, 0x54, 0x93, 0x6a, 0x08, 0xaa, 0xab, - 0xd6, 0x6c, 0xee, 0xdc, 0x0f, 0x74, 0xd5, 0x37, 0xef, 0xed, 0xde, 0x99, 0x34, 0xc1, 0xb3, 0xa0, - 0x9c, 0x06, 0xf4, 0x0d, 0x71, 0x15, 0x2e, 0x9f, 0x8a, 0x13, 0xe6, 0x38, 0x03, 0xa6, 0x36, 0xda, - 0xea, 0x7d, 0x39, 0x8d, 0x56, 0xe0, 0xc6, 0x99, 0x30, 0x7f, 0x4c, 0xce, 0xa0, 0x55, 0xb8, 0x79, - 0x3a, 0x9e, 0x1b, 0xc8, 0x13, 0xf0, 0x4c, 0xf4, 0x89, 0x04, 0xf3, 0xb1, 0xc5, 0x08, 0xba, 0x02, - 0x4b, 0x4d, 0x75, 0xaf, 0xde, 0x68, 0xb5, 0xb4, 0xa6, 0xba, 0xd7, 0xdc, 0x6b, 0xd5, 0x76, 0xb4, - 0x56, 0xbb, 0xd6, 0xbe, 0xd7, 0x0a, 0xd9, 0x46, 0x81, 0xc5, 0x24, 0x90, 0x6f, 0x97, 0x53, 0x30, - 0xe2, 0x04, 0x78, 0xe7, 0xf4, 0x27, 0x12, 0x5c, 0x4c, 0x2c, 0x29, 0xd0, 0x75, 0x78, 0x66, 0xbf, - 0xa1, 0x6e, 0x6d, 0xdc, 0xd7, 0xf6, 0xf7, 0xda, 0x0d, 0xad, 0xf1, 0x5e, 0xbb, 0xb1, 0xdb, 0xda, - 0xda, 0xdb, 0x9d, 0x9c, 0xd5, 0x35, 0xb8, 0x72, 0x2a, 0xd2, 0x9f, 0xda, 0x59, 0xc0, 0xb1, 0xf9, - 0x7d, 0x4f, 0x82, 0xe9, 0x31, 0x5f, 0x88, 0x2e, 0x41, 0xf5, 0xee, 0x56, 0x6b, 0xbd, 0xb1, 0x59, - 0xdb, 0xdf, 0xda, 0x53, 0xc7, 0xef, 0xec, 0x15, 0x58, 0x9a, 0x18, 0xbd, 0x7d, 0xaf, 0xb9, 0xb3, - 0x55, 0xaf, 0xb5, 0x1b, 0xec, 0xa3, 0xb2, 0x44, 0x17, 0x36, 0x01, 0xda, 0xd9, 0x7a, 0x67, 0xb3, - 0xad, 0xd5, 0x77, 0xb6, 0x1a, 0xbb, 0x6d, 0xad, 0xd6, 0x6e, 0xd7, 0x82, 0xeb, 0xbc, 0x7e, 0xe7, - 0xb3, 0xaf, 0x16, 0xa5, 0x2f, 0xbe, 0x5a, 0x94, 0xfe, 0xf0, 0xd5, 0xa2, 0xf4, 0xe9, 0xd7, 0x8b, - 0xe7, 0xbe, 0xf8, 0x7a, 0xf1, 0xdc, 0xef, 0xbe, 0x5e, 0x3c, 0xf7, 0xe0, 0xd6, 0xa1, 0x41, 0xfa, - 0xa3, 0x03, 0xea, 0x85, 0x57, 0x83, 0xff, 0xeb, 0xfa, 0x7f, 0xf4, 0xb5, 0x8d, 0xd5, 0xf1, 0x7f, - 0xfd, 0x1e, 0xe4, 0x98, 0x5b, 0x7d, 0xf1, 0x6f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x7e, 0x54, 0xeb, - 0x69, 0x10, 0x2c, 0x00, 0x00, + // 3367 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0x4b, 0x6c, 0x1c, 0xc7, + 0xb5, 0x55, 0xcf, 0x8f, 0x33, 0x77, 0x3e, 0x6c, 0x16, 0x49, 0x69, 0x44, 0xcb, 0x24, 0xd5, 0xb2, + 0x2c, 0x59, 0xb2, 0xc9, 0x27, 0xda, 0xcf, 0xdf, 0x67, 0x1b, 0xc3, 0xd1, 0xd0, 0x24, 0x45, 0x91, + 0xe3, 0x9e, 0x11, 0x9f, 0xa5, 0xf7, 0x69, 0x37, 0x67, 0x6a, 0x38, 0x6d, 0xcd, 0x74, 0xb7, 0xbb, + 0x6b, 0x68, 0xf2, 0xbd, 0x55, 0x82, 0x38, 0x08, 0xbc, 0xf2, 0x26, 0x40, 0x10, 0x20, 0x40, 0x80, + 0x20, 0xdb, 0x2c, 0xb2, 0xcf, 0x2e, 0x08, 0xbc, 0x8a, 0xbd, 0xcc, 0xca, 0x09, 0x6c, 0x64, 0x93, + 0x7d, 0x80, 0x00, 0xd9, 0x04, 0xf5, 0xe9, 0xdf, 0x4c, 0x37, 0x29, 0xc9, 0xce, 0x22, 0x48, 0x76, + 0x5d, 0x55, 0xf7, 0xde, 0xaa, 0xba, 0x75, 0xeb, 0x7e, 0x4e, 0x35, 0x5c, 0xea, 0x58, 0x43, 0x4c, + 0x0e, 0x7a, 0x64, 0x55, 0x3f, 0xe8, 0x18, 0xab, 0x47, 0x6b, 0xab, 0xe4, 0xc4, 0xc6, 0xee, 0x8a, + 0xed, 0x58, 0xc4, 0x42, 0xb2, 0x37, 0xba, 0x42, 0x47, 0x57, 0x8e, 0xd6, 0x16, 0x16, 0x7d, 0xfa, + 0x8e, 0x73, 0x62, 0x13, 0x6b, 0xf5, 0xe8, 0xd6, 0xaa, 0xed, 0x58, 0x56, 0x8f, 0x73, 0x84, 0xc6, + 0x99, 0x1c, 0x2a, 0xd0, 0xd6, 0x1d, 0x7d, 0x28, 0x24, 0x2e, 0x5c, 0x9e, 0x1c, 0x3f, 0xd2, 0x07, + 0x46, 0x57, 0x27, 0x96, 0x23, 0x48, 0xe6, 0x0e, 0xad, 0x43, 0x8b, 0x7d, 0xae, 0xd2, 0x2f, 0xd1, + 0xbb, 0x74, 0x68, 0x59, 0x87, 0x03, 0xbc, 0xca, 0x5a, 0x07, 0xa3, 0xde, 0x2a, 0x31, 0x86, 0xd8, + 0x25, 0xfa, 0xd0, 0xf6, 0x66, 0x1e, 0x27, 0xe8, 0x8e, 0x1c, 0x9d, 0x18, 0x96, 0xc9, 0xc7, 0x95, + 0xcf, 0x0b, 0x30, 0xa5, 0xe2, 0x0f, 0x47, 0xd8, 0x25, 0xe8, 0x45, 0xc8, 0xe0, 0x4e, 0xdf, 0xaa, + 0x4a, 0xcb, 0xd2, 0xf5, 0xe2, 0xda, 0xd3, 0x2b, 0xe3, 0xdb, 0x5c, 0x69, 0x74, 0xfa, 0x96, 0x20, + 0xde, 0x3c, 0xa7, 0x32, 0x62, 0xf4, 0x32, 0x64, 0x7b, 0x83, 0x91, 0xdb, 0xaf, 0xa6, 0x18, 0xd7, + 0xe2, 0x24, 0xd7, 0x06, 0x1d, 0x0e, 0xd8, 0x38, 0x39, 0x9d, 0xcc, 0x30, 0x7b, 0x56, 0x35, 0x9d, + 0x34, 0xd9, 0x96, 0xd9, 0x0b, 0x4f, 0x46, 0x89, 0x51, 0x1d, 0xc0, 0x30, 0x0d, 0xa2, 0x75, 0xfa, + 0xba, 0x61, 0x56, 0xb3, 0x8c, 0x55, 0x89, 0x63, 0x35, 0x48, 0x9d, 0x92, 0x04, 0xfc, 0x05, 0xc3, + 0xeb, 0xa3, 0x2b, 0xfe, 0x70, 0x84, 0x9d, 0x93, 0x6a, 0x2e, 0x69, 0xc5, 0xef, 0xd2, 0xe1, 0xd0, + 0x8a, 0x19, 0x39, 0x7a, 0x13, 0xf2, 0x9d, 0x3e, 0xee, 0x3c, 0xd4, 0xc8, 0x71, 0x35, 0xcf, 0x58, + 0x97, 0x27, 0x59, 0xeb, 0x94, 0xa2, 0x7d, 0x1c, 0x30, 0x4f, 0x75, 0x78, 0x0f, 0x7a, 0x0d, 0x72, + 0x1d, 0x6b, 0x38, 0x34, 0x48, 0xb5, 0xc8, 0x98, 0x97, 0x62, 0x98, 0xd9, 0x78, 0xc0, 0x2b, 0x18, + 0xd0, 0x1e, 0x54, 0x06, 0x86, 0x4b, 0x34, 0xd7, 0xd4, 0x6d, 0xb7, 0x6f, 0x11, 0xb7, 0x5a, 0x62, + 0x22, 0x9e, 0x9d, 0x14, 0xb1, 0x63, 0xb8, 0xa4, 0xe5, 0x91, 0x05, 0x92, 0xca, 0x83, 0x70, 0x3f, + 0x15, 0x68, 0xf5, 0x7a, 0xd8, 0xf1, 0x25, 0x56, 0xcb, 0x49, 0x02, 0xf7, 0x28, 0x9d, 0xc7, 0x19, + 0x12, 0x68, 0x85, 0xfb, 0xd1, 0x7f, 0xc3, 0xec, 0xc0, 0xd2, 0xbb, 0xbe, 0x3c, 0xad, 0xd3, 0x1f, + 0x99, 0x0f, 0xab, 0x15, 0x26, 0xf5, 0x46, 0xcc, 0x32, 0x2d, 0xbd, 0xeb, 0x31, 0xd7, 0x29, 0x69, + 0x20, 0x79, 0x66, 0x30, 0x3e, 0x86, 0x34, 0x98, 0xd3, 0x6d, 0x7b, 0x70, 0x32, 0x2e, 0x7e, 0x9a, + 0x89, 0xbf, 0x39, 0x29, 0xbe, 0x46, 0xa9, 0x13, 0xe4, 0x23, 0x7d, 0x62, 0x10, 0xdd, 0x03, 0xd9, + 0x76, 0xb0, 0xad, 0x3b, 0x58, 0xb3, 0x1d, 0xcb, 0xb6, 0x5c, 0x7d, 0x50, 0x95, 0x99, 0xf0, 0xeb, + 0x93, 0xc2, 0x9b, 0x9c, 0xb2, 0x29, 0x08, 0x03, 0xc9, 0xd3, 0x76, 0x74, 0x84, 0x8b, 0xb5, 0x3a, + 0xd8, 0x75, 0x03, 0xb1, 0x33, 0xc9, 0x62, 0x19, 0x65, 0xac, 0xd8, 0xc8, 0x08, 0xda, 0x80, 0x22, + 0x3e, 0x26, 0xd8, 0xec, 0x6a, 0x47, 0x16, 0xc1, 0x55, 0xc4, 0x24, 0x5e, 0x89, 0xb9, 0xae, 0x8c, + 0x68, 0xdf, 0x22, 0x38, 0x10, 0x06, 0xd8, 0xef, 0x44, 0x07, 0x30, 0x7f, 0x84, 0x1d, 0xa3, 0x77, + 0xc2, 0xe4, 0x68, 0x6c, 0xc4, 0x35, 0x2c, 0xb3, 0x3a, 0xcb, 0x24, 0x3e, 0x3f, 0x29, 0x71, 0x9f, + 0x91, 0x53, 0xe6, 0x86, 0x47, 0x1c, 0x88, 0x9e, 0x3d, 0x9a, 0x1c, 0xa5, 0x96, 0xd6, 0x33, 0x4c, + 0x7d, 0x60, 0xfc, 0x1f, 0xd6, 0x0e, 0x06, 0x56, 0xe7, 0x61, 0x75, 0x2e, 0xc9, 0xd2, 0x36, 0x04, + 0xdd, 0x3a, 0x25, 0x0b, 0x59, 0x5a, 0x2f, 0xdc, 0xbf, 0x3e, 0x05, 0xd9, 0x23, 0x7d, 0x30, 0xc2, + 0xdb, 0x99, 0x7c, 0x46, 0xce, 0x6e, 0x67, 0xf2, 0x53, 0x72, 0x7e, 0x3b, 0x93, 0x2f, 0xc8, 0xb0, + 0x9d, 0xc9, 0x83, 0x5c, 0x54, 0xae, 0x41, 0x31, 0xe4, 0xa7, 0x50, 0x15, 0xa6, 0x86, 0xd8, 0x75, + 0xf5, 0x43, 0xcc, 0xfc, 0x5a, 0x41, 0xf5, 0x9a, 0x4a, 0x05, 0x4a, 0x61, 0xd7, 0xa4, 0x7c, 0x2a, + 0x41, 0x31, 0xe4, 0x74, 0x28, 0xe7, 0x11, 0x76, 0x98, 0x42, 0x04, 0xa7, 0x68, 0xa2, 0x2b, 0x50, + 0x66, 0x7b, 0xd1, 0xbc, 0x71, 0xea, 0xfb, 0x32, 0x6a, 0x89, 0x75, 0xee, 0x0b, 0xa2, 0x25, 0x28, + 0xda, 0x6b, 0xb6, 0x4f, 0x92, 0x66, 0x24, 0x60, 0xaf, 0xd9, 0x1e, 0xc1, 0x65, 0x28, 0xd1, 0xad, + 0xfb, 0x14, 0x19, 0x36, 0x49, 0x91, 0xf6, 0x09, 0x12, 0xe5, 0xb7, 0x29, 0x90, 0xc7, 0x9d, 0x19, + 0x7a, 0x15, 0x32, 0xd4, 0xcb, 0x0b, 0x37, 0xbd, 0xb0, 0xc2, 0x3d, 0xfc, 0x8a, 0xe7, 0xe1, 0x57, + 0xda, 0x5e, 0x08, 0x58, 0xcf, 0x7f, 0xf6, 0xe5, 0xd2, 0xb9, 0x4f, 0x7f, 0xbf, 0x24, 0xa9, 0x8c, + 0x03, 0x5d, 0xa4, 0x1e, 0x4c, 0x37, 0x4c, 0xcd, 0xe8, 0xb2, 0x25, 0x17, 0xa8, 0x77, 0xd2, 0x0d, + 0x73, 0xab, 0x8b, 0xee, 0x82, 0xdc, 0xb1, 0x4c, 0x17, 0x9b, 0xee, 0xc8, 0xd5, 0x78, 0x6c, 0x12, + 0xae, 0x39, 0xe4, 0x5f, 0x79, 0x10, 0x64, 0x8e, 0x4a, 0x90, 0x36, 0x19, 0xa5, 0x3a, 0xdd, 0x89, + 0x76, 0xa0, 0x77, 0x00, 0xfc, 0x00, 0xe6, 0x56, 0x33, 0xcb, 0xe9, 0xeb, 0xc5, 0xb5, 0xcb, 0x31, + 0xf6, 0xe4, 0xd1, 0xdc, 0xb3, 0xbb, 0x3a, 0xc1, 0xeb, 0x19, 0xba, 0x60, 0x35, 0xc4, 0x8a, 0x9e, + 0x85, 0x69, 0xdd, 0xb6, 0x35, 0x97, 0xe8, 0x04, 0x6b, 0x07, 0x27, 0x04, 0xbb, 0xcc, 0xed, 0x97, + 0xd4, 0xb2, 0x6e, 0xdb, 0x2d, 0xda, 0xbb, 0x4e, 0x3b, 0xd1, 0x55, 0xa8, 0x50, 0x0f, 0x6f, 0xe8, + 0x03, 0xad, 0x8f, 0x8d, 0xc3, 0x3e, 0x61, 0xde, 0x3d, 0xad, 0x96, 0x45, 0xef, 0x26, 0xeb, 0x54, + 0xba, 0x50, 0x0a, 0x3b, 0x77, 0x84, 0x20, 0xd3, 0xd5, 0x89, 0xce, 0x74, 0x59, 0x52, 0xd9, 0x37, + 0xed, 0xb3, 0x75, 0xd2, 0x17, 0x1a, 0x62, 0xdf, 0xe8, 0x3c, 0xe4, 0x84, 0xd8, 0x34, 0x13, 0x2b, + 0x5a, 0x68, 0x0e, 0xb2, 0xb6, 0x63, 0x1d, 0x61, 0x76, 0x78, 0x79, 0x95, 0x37, 0x94, 0xfb, 0x50, + 0x89, 0xc6, 0x01, 0x54, 0x81, 0x14, 0x39, 0x16, 0xb3, 0xa4, 0xc8, 0x31, 0xba, 0x05, 0x19, 0xaa, + 0x4c, 0x26, 0xad, 0x12, 0x17, 0xfd, 0x04, 0x7f, 0xfb, 0xc4, 0xc6, 0x2a, 0x23, 0xdd, 0xce, 0xe4, + 0x53, 0x72, 0x5a, 0x99, 0x86, 0x72, 0x24, 0x4a, 0x28, 0xe7, 0x61, 0x2e, 0xce, 0xe7, 0x2b, 0x9f, + 0x48, 0x30, 0x17, 0xe7, 0xbb, 0xd1, 0xcb, 0x90, 0xf7, 0xbd, 0xbe, 0x67, 0x42, 0x13, 0xd3, 0xfb, + 0x4c, 0x3e, 0x2d, 0x35, 0x1e, 0x7a, 0x12, 0x7d, 0x5d, 0xc4, 0xfa, 0x92, 0x3a, 0xa5, 0xdb, 0xf6, + 0xa6, 0xee, 0xf6, 0xa9, 0xa9, 0xd3, 0xa1, 0x31, 0x53, 0xd7, 0x6d, 0xcf, 0xd4, 0x95, 0xf7, 0xa1, + 0x9a, 0xe4, 0xf1, 0x43, 0xaa, 0x95, 0x18, 0x9f, 0xa7, 0xda, 0xf3, 0x90, 0xeb, 0x59, 0xce, 0x50, + 0x27, 0x6c, 0xb6, 0xb2, 0x2a, 0x5a, 0x54, 0xe5, 0xdc, 0xfb, 0xa7, 0x59, 0x37, 0x6f, 0x28, 0x1a, + 0x5c, 0x4c, 0x74, 0xfa, 0x94, 0xc5, 0x30, 0xbb, 0x98, 0x1f, 0x40, 0x59, 0xe5, 0x8d, 0x40, 0x10, + 0xdf, 0x0d, 0x6f, 0xd0, 0x69, 0x5d, 0x6c, 0x76, 0xb1, 0xc3, 0xe4, 0x17, 0x54, 0xd1, 0x52, 0x7e, + 0x9c, 0x86, 0xf3, 0xf1, 0x9e, 0x1f, 0x2d, 0x43, 0x69, 0xa8, 0x1f, 0x6b, 0xe4, 0x58, 0x18, 0xa8, + 0xc4, 0x4c, 0x04, 0x86, 0xfa, 0x71, 0xfb, 0x98, 0x5b, 0xa7, 0x0c, 0x69, 0x72, 0xec, 0x56, 0x53, + 0xcb, 0xe9, 0xeb, 0x25, 0x95, 0x7e, 0xa2, 0x7d, 0x98, 0x19, 0x58, 0x1d, 0x7d, 0xa0, 0x0d, 0x74, + 0x97, 0x68, 0x22, 0x31, 0xe0, 0x17, 0xee, 0x99, 0x24, 0x4f, 0x8e, 0xbb, 0xfc, 0xe8, 0xa9, 0x93, + 0x12, 0x57, 0x65, 0x9a, 0x09, 0xd9, 0xd1, 0x5d, 0xc2, 0x87, 0x50, 0x03, 0x8a, 0x43, 0xc3, 0x3d, + 0xc0, 0x7d, 0xfd, 0xc8, 0xb0, 0x1c, 0x71, 0xf3, 0x62, 0xec, 0xeb, 0x6e, 0x40, 0x24, 0x44, 0x85, + 0xf9, 0x42, 0x87, 0x92, 0x8d, 0xd8, 0xbb, 0xe7, 0x7b, 0x72, 0x8f, 0xed, 0x7b, 0xfe, 0x0d, 0xe6, + 0x4c, 0x7c, 0x4c, 0xb4, 0xe0, 0x6e, 0x73, 0x53, 0x9a, 0x62, 0xca, 0x47, 0x74, 0xcc, 0xf7, 0x06, + 0x2e, 0xb3, 0xaa, 0xe7, 0x58, 0xf4, 0xb4, 0x2d, 0x17, 0x3b, 0x9a, 0xde, 0xed, 0x3a, 0xd8, 0x75, + 0x59, 0xde, 0x55, 0x62, 0x11, 0x91, 0xf5, 0xd7, 0x78, 0xb7, 0xf2, 0x09, 0x3b, 0x9c, 0xb8, 0xf8, + 0xe9, 0xa9, 0x5e, 0x0a, 0x54, 0xdf, 0x86, 0x39, 0xc1, 0xdf, 0x8d, 0x68, 0x9f, 0x27, 0xb0, 0x97, + 0x92, 0xd2, 0xb2, 0x90, 0xd6, 0x91, 0xc7, 0x9f, 0xac, 0xf8, 0xf4, 0x13, 0x2a, 0x1e, 0x41, 0x86, + 0xa9, 0x25, 0xc3, 0x1d, 0x12, 0xfd, 0xfe, 0x47, 0x3b, 0x8c, 0x8f, 0xd3, 0x30, 0x33, 0x91, 0x7a, + 0xf8, 0x1b, 0x93, 0x62, 0x37, 0x96, 0x8a, 0xdd, 0x58, 0xfa, 0xb1, 0x37, 0x26, 0x4e, 0x3b, 0x73, + 0xf6, 0x69, 0x67, 0xbf, 0xcd, 0xd3, 0xce, 0x3d, 0xe1, 0x69, 0xff, 0x5d, 0xcf, 0xe1, 0x73, 0x09, + 0x16, 0x92, 0x13, 0xb6, 0xd8, 0x03, 0xb9, 0x09, 0x33, 0xfe, 0x52, 0x7c, 0xf1, 0xdc, 0x3d, 0xca, + 0xfe, 0x80, 0x90, 0x9f, 0x18, 0x13, 0xaf, 0x42, 0x65, 0x2c, 0x9f, 0xe4, 0xc6, 0x5c, 0x3e, 0x8a, + 0x64, 0x86, 0xb7, 0x60, 0xde, 0xb4, 0x4c, 0xcd, 0xb1, 0xc7, 0xb3, 0xcf, 0xac, 0xd8, 0xbc, 0x65, + 0xaa, 0x76, 0x64, 0xe5, 0xca, 0x2f, 0xd3, 0x30, 0x17, 0x97, 0x25, 0xc6, 0x5c, 0x72, 0x15, 0x66, + 0xbb, 0xb8, 0x63, 0x74, 0x9f, 0xf8, 0x8e, 0xcf, 0x08, 0xf6, 0x7f, 0x5d, 0xf1, 0x49, 0xd3, 0x42, + 0x37, 0x60, 0xc6, 0x3d, 0x31, 0x3b, 0x86, 0x79, 0xa8, 0x11, 0xcb, 0x4b, 0xb8, 0x0a, 0x6c, 0xe5, + 0xd3, 0x62, 0xa0, 0x6d, 0x89, 0x94, 0xeb, 0xe7, 0x00, 0x79, 0x15, 0xbb, 0x36, 0xcd, 0x10, 0x51, + 0x1d, 0x0a, 0xf8, 0xb8, 0x83, 0x6d, 0xe2, 0x65, 0xd5, 0x09, 0x85, 0x8b, 0x20, 0xf1, 0xf8, 0x68, + 0x01, 0xef, 0xf3, 0xa1, 0x97, 0x04, 0x4e, 0x91, 0x88, 0x38, 0xf0, 0xfc, 0xdf, 0x67, 0xe5, 0x40, + 0xc5, 0x2b, 0x1e, 0x50, 0x91, 0x4e, 0x2a, 0xbf, 0x45, 0x35, 0xe0, 0xf3, 0x09, 0xa4, 0xe2, 0x25, + 0x81, 0x54, 0x64, 0x92, 0xa6, 0xe3, 0x45, 0x43, 0x30, 0x1d, 0x83, 0x2a, 0x6e, 0x47, 0xa0, 0x8a, + 0x5c, 0xd2, 0x56, 0x43, 0xd9, 0x7d, 0xb0, 0xd5, 0x00, 0xab, 0x78, 0xc5, 0xc3, 0x2a, 0xa6, 0x92, + 0x16, 0x2d, 0xd2, 0xd9, 0x60, 0xd1, 0x1c, 0xac, 0x78, 0x2b, 0x04, 0x56, 0x14, 0x18, 0xef, 0xe5, + 0x53, 0xc0, 0x0a, 0x9f, 0xdb, 0x47, 0x2b, 0x5e, 0xf7, 0xd1, 0x8a, 0x52, 0x22, 0xd4, 0x21, 0xf2, + 0x50, 0x9f, 0xd9, 0x83, 0x2b, 0x9a, 0x13, 0x70, 0x05, 0x47, 0x17, 0xae, 0x9d, 0x09, 0x57, 0xf8, + 0xa2, 0xc6, 0xf0, 0x8a, 0xe6, 0x04, 0x5e, 0x51, 0x49, 0x92, 0x38, 0x96, 0xf3, 0x06, 0x12, 0xa3, + 0x80, 0xc5, 0xff, 0xc4, 0x03, 0x16, 0x89, 0x88, 0x42, 0x4c, 0xfa, 0xea, 0x8b, 0x8e, 0x41, 0x2c, + 0xde, 0x4f, 0x40, 0x2c, 0xe4, 0xa4, 0xca, 0x3a, 0x2e, 0x79, 0xf5, 0x27, 0x88, 0x83, 0x2c, 0xf6, + 0x63, 0x20, 0x0b, 0x8e, 0x2d, 0x3c, 0xf7, 0x08, 0x90, 0x85, 0x2f, 0x7a, 0x02, 0xb3, 0xd8, 0x8f, + 0xc1, 0x2c, 0x50, 0xb2, 0xdc, 0xb1, 0x9c, 0x2b, 0x2c, 0x37, 0x0a, 0x5a, 0xbc, 0x13, 0x05, 0x2d, + 0x66, 0x4f, 0x4f, 0x75, 0x79, 0xe6, 0xe0, 0x4b, 0x0b, 0xa3, 0x16, 0x9d, 0x24, 0xd4, 0x82, 0x03, + 0x0b, 0x2f, 0x3c, 0x22, 0x6a, 0xe1, 0xcb, 0x8e, 0x85, 0x2d, 0x9a, 0x13, 0xb0, 0xc5, 0x7c, 0x92, + 0xc1, 0x8d, 0x05, 0xa4, 0xc0, 0xe0, 0x12, 0x71, 0x8b, 0xac, 0x9c, 0xdb, 0xce, 0xe4, 0xf3, 0x72, + 0x81, 0x23, 0x16, 0xdb, 0x99, 0x7c, 0x51, 0x2e, 0x29, 0xcf, 0xd1, 0xac, 0x69, 0xcc, 0xef, 0xd1, + 0x1a, 0x05, 0x3b, 0x8e, 0xe5, 0x08, 0x04, 0x82, 0x37, 0x94, 0xeb, 0x50, 0x0a, 0xbb, 0xb8, 0x53, + 0x30, 0x8e, 0x69, 0x28, 0x47, 0xbc, 0x9a, 0xf2, 0xd7, 0x14, 0x94, 0xc2, 0xfe, 0x2a, 0x52, 0x01, + 0x17, 0x44, 0x05, 0x1c, 0x42, 0x3e, 0x52, 0x51, 0xe4, 0xe3, 0xac, 0x4a, 0x8f, 0x46, 0x06, 0x16, + 0x6f, 0x39, 0x3e, 0x22, 0x22, 0x43, 0x86, 0x47, 0x06, 0x3a, 0xc0, 0x94, 0xc1, 0x23, 0x03, 0x7a, + 0x01, 0x66, 0x43, 0xb4, 0x7e, 0x71, 0xc9, 0xe3, 0xbf, 0xec, 0x53, 0xd7, 0x44, 0x95, 0xf9, 0x5f, + 0x30, 0x3d, 0xd0, 0x4d, 0x6a, 0xee, 0x86, 0xe5, 0x18, 0xc4, 0xc0, 0xae, 0xc8, 0xbb, 0xd6, 0x4e, + 0x77, 0xc9, 0x2b, 0x3b, 0xba, 0x89, 0x9b, 0x3e, 0x53, 0xc3, 0x24, 0xce, 0x89, 0x5a, 0x19, 0x44, + 0x3a, 0xd1, 0x65, 0x28, 0x75, 0x71, 0x4f, 0x1f, 0x0d, 0x88, 0x46, 0x47, 0x98, 0xbf, 0x2d, 0xa8, + 0x45, 0xd1, 0x47, 0x25, 0x2c, 0xd4, 0x60, 0x36, 0x46, 0x12, 0xcd, 0x3d, 0x1e, 0xe2, 0x13, 0xa1, + 0x3f, 0xfa, 0x49, 0x0f, 0x8d, 0x1d, 0xb5, 0x28, 0x5c, 0x79, 0xe3, 0xf5, 0xd4, 0xab, 0x92, 0xf2, + 0x1b, 0x09, 0x66, 0x26, 0x3c, 0x7e, 0x2c, 0xf6, 0x22, 0x7d, 0x5b, 0xd8, 0x4b, 0xea, 0xc9, 0xb1, + 0x97, 0x70, 0xc5, 0x9f, 0x8e, 0x54, 0xfc, 0xca, 0x5f, 0x24, 0x28, 0x47, 0x22, 0x0f, 0xb5, 0xa3, + 0x8e, 0xd5, 0xc5, 0xa2, 0xc4, 0x66, 0xdf, 0x54, 0x35, 0x03, 0xeb, 0x50, 0x14, 0xd2, 0xf4, 0x93, + 0x52, 0xf9, 0xb1, 0xb4, 0x20, 0x22, 0xa5, 0x5f, 0x9d, 0xf3, 0xd4, 0x47, 0x54, 0xe7, 0x42, 0xad, + 0x39, 0x36, 0x6f, 0x54, 0xad, 0x3c, 0x85, 0xe1, 0x0d, 0xf4, 0x1a, 0x14, 0xd8, 0x4b, 0x8b, 0x66, + 0xd9, 0xae, 0x80, 0xe5, 0x43, 0xe9, 0x1d, 0x7f, 0x8e, 0x59, 0x39, 0xba, 0x45, 0x5d, 0x95, 0xd5, + 0xdb, 0xb3, 0x5d, 0x35, 0x6f, 0x8b, 0xaf, 0x50, 0xd2, 0x55, 0x88, 0x24, 0x5d, 0x97, 0xa0, 0x40, + 0x97, 0xef, 0xda, 0x7a, 0x07, 0x57, 0x81, 0xad, 0x34, 0xe8, 0x50, 0x7e, 0x9d, 0x82, 0xe9, 0xb1, + 0xc0, 0x19, 0xbb, 0x79, 0xef, 0x62, 0xa5, 0x42, 0xd0, 0xd2, 0xa3, 0x29, 0x64, 0x11, 0xe0, 0x50, + 0x77, 0xb5, 0x8f, 0x74, 0x93, 0xe0, 0xae, 0xd0, 0x4a, 0xa8, 0x07, 0x2d, 0x40, 0x9e, 0xb6, 0x46, + 0x2e, 0xee, 0x0a, 0x94, 0xcb, 0x6f, 0xa3, 0x2d, 0xc8, 0xe1, 0x23, 0x6c, 0x12, 0xb7, 0x3a, 0xc5, + 0x0e, 0xfe, 0x42, 0x8c, 0x87, 0xa5, 0xe3, 0xeb, 0x55, 0x7a, 0xdc, 0x7f, 0xfa, 0x72, 0x49, 0xe6, + 0xe4, 0xcf, 0x5b, 0x43, 0x83, 0xe0, 0xa1, 0x4d, 0x4e, 0x54, 0x21, 0x20, 0xaa, 0x86, 0xfc, 0x98, + 0x1a, 0xd0, 0x05, 0x98, 0x62, 0xb7, 0xd1, 0xe8, 0xb2, 0x0c, 0xa1, 0xa0, 0xe6, 0x68, 0x73, 0xab, + 0xcb, 0xb0, 0xd8, 0x92, 0x07, 0x9b, 0x50, 0x6d, 0xb3, 0xeb, 0x72, 0xa2, 0x96, 0x87, 0x78, 0x68, + 0x5b, 0xd6, 0x40, 0xe3, 0x3e, 0xac, 0x06, 0x95, 0x68, 0x02, 0x81, 0xae, 0x40, 0xd9, 0xc1, 0x44, + 0x37, 0x4c, 0x2d, 0x52, 0x56, 0x94, 0x78, 0x27, 0xf7, 0x19, 0xdb, 0x99, 0xbc, 0x24, 0xa7, 0x04, + 0x16, 0xf6, 0x2e, 0xcc, 0xc7, 0xe6, 0x0f, 0xe8, 0x55, 0x28, 0x04, 0xb9, 0x87, 0xc4, 0xf4, 0x70, + 0x1a, 0xc6, 0x15, 0x10, 0x2b, 0xfb, 0x30, 0x1f, 0x9b, 0x40, 0xa0, 0x37, 0x21, 0xe7, 0x60, 0x77, + 0x34, 0xe0, 0x28, 0x55, 0x65, 0xed, 0xea, 0xd9, 0x99, 0xc7, 0x68, 0x40, 0x54, 0xc1, 0xa4, 0xdc, + 0x82, 0x8b, 0x89, 0x19, 0x44, 0x00, 0x44, 0x49, 0x21, 0x20, 0x4a, 0xf9, 0x85, 0x04, 0x0b, 0xc9, + 0x59, 0x01, 0x5a, 0x1f, 0x5b, 0xd0, 0x8d, 0x47, 0xcc, 0x29, 0x42, 0xab, 0xa2, 0x95, 0x9a, 0x83, + 0x7b, 0x98, 0x74, 0xfa, 0x3c, 0x3d, 0xe1, 0xde, 0xa2, 0xac, 0x96, 0x45, 0x2f, 0xe3, 0x71, 0x39, + 0xd9, 0x07, 0xb8, 0x43, 0x34, 0x7e, 0xa8, 0x2e, 0x2b, 0x7d, 0x0a, 0x94, 0x8c, 0xf6, 0xb6, 0x78, + 0xa7, 0x72, 0x13, 0x2e, 0x24, 0xe4, 0x19, 0x93, 0xf5, 0x99, 0xf2, 0x80, 0x12, 0xc7, 0x26, 0x0f, + 0xe8, 0x6d, 0xc8, 0xb9, 0x44, 0x27, 0x23, 0x57, 0xec, 0xec, 0xda, 0x99, 0x79, 0x47, 0x8b, 0x91, + 0xab, 0x82, 0x4d, 0xc1, 0x80, 0x26, 0xb3, 0x88, 0x98, 0xb2, 0x54, 0x8a, 0x2b, 0x4b, 0xaf, 0x83, + 0x2c, 0xca, 0xd2, 0x80, 0x90, 0x5f, 0xe1, 0x0a, 0xab, 0x48, 0x83, 0x6a, 0xf4, 0x00, 0x9e, 0x3a, + 0x25, 0xb3, 0x40, 0xf5, 0xb1, 0x6d, 0xdc, 0x7c, 0xa4, 0xc4, 0x64, 0x6c, 0x2b, 0xbf, 0x4a, 0xc3, + 0x7c, 0x6c, 0x82, 0x11, 0xba, 0xe8, 0xd2, 0x37, 0xbd, 0xe8, 0x6f, 0x02, 0x90, 0x63, 0x8d, 0xdb, + 0x84, 0x17, 0x30, 0xe2, 0xaa, 0xaa, 0x63, 0xdc, 0x61, 0x3e, 0x8f, 0x9a, 0x50, 0x81, 0x88, 0x2f, + 0x17, 0xb5, 0xc3, 0xa0, 0xc1, 0x88, 0x05, 0x13, 0x57, 0x14, 0xc7, 0x8f, 0x1c, 0x76, 0x02, 0x74, + 0x81, 0x77, 0xbb, 0xe8, 0x01, 0x5c, 0x18, 0x0b, 0x8a, 0xbe, 0xec, 0xcc, 0x23, 0xc7, 0xc6, 0xf9, + 0x68, 0x6c, 0xf4, 0x64, 0x87, 0x03, 0x5b, 0x36, 0x0a, 0x65, 0xdf, 0x05, 0x99, 0x95, 0xcd, 0x3c, + 0x27, 0xe9, 0xe2, 0x81, 0xee, 0xbd, 0x13, 0x5f, 0x9c, 0x28, 0xbe, 0x6f, 0x8b, 0xa7, 0x74, 0x5e, + 0x7b, 0xff, 0x88, 0xd6, 0xde, 0x15, 0xca, 0xcc, 0x0e, 0xea, 0x36, 0x65, 0x55, 0x1e, 0x00, 0x04, + 0xc8, 0x02, 0xbd, 0xe8, 0x8e, 0x35, 0x32, 0xbb, 0xcc, 0x22, 0xb2, 0x2a, 0x6f, 0xa0, 0x97, 0x21, + 0x4b, 0x4d, 0xd0, 0xd3, 0x7c, 0x8c, 0xa7, 0xa2, 0x16, 0x12, 0x82, 0x26, 0x38, 0xb9, 0xf2, 0x81, + 0x67, 0xe6, 0x61, 0x5c, 0x38, 0x61, 0x8e, 0xb7, 0xa2, 0x73, 0x28, 0xc9, 0x10, 0x73, 0xfc, 0x5c, + 0xff, 0x0f, 0x59, 0x66, 0x4d, 0x34, 0x5e, 0xb1, 0x87, 0x0b, 0x91, 0x2e, 0xd2, 0x6f, 0xf4, 0xbf, + 0x00, 0x3a, 0x21, 0x8e, 0x71, 0x30, 0x0a, 0x66, 0x58, 0x4e, 0x30, 0xc7, 0x9a, 0x47, 0xb8, 0x7e, + 0x49, 0xd8, 0xe5, 0x5c, 0xc0, 0x1b, 0xb2, 0xcd, 0x90, 0x44, 0x65, 0x17, 0x2a, 0x51, 0xde, 0xb3, + 0x72, 0xae, 0x82, 0x97, 0x1c, 0xf8, 0xa9, 0x45, 0x9a, 0x3f, 0xcf, 0xb0, 0x86, 0xf2, 0x9d, 0x14, + 0x94, 0xc2, 0xc6, 0xfc, 0x4f, 0x18, 0xbe, 0x95, 0xef, 0x4b, 0x90, 0xf7, 0xf7, 0x1f, 0x7d, 0x82, + 0x89, 0xbc, 0x6e, 0x71, 0xf5, 0xa5, 0xc2, 0xef, 0x26, 0xfc, 0x2d, 0x2b, 0xed, 0xbf, 0x65, 0xfd, + 0x87, 0x1f, 0x89, 0x12, 0x11, 0x92, 0xb0, 0xb6, 0x85, 0x61, 0x79, 0x91, 0xf1, 0x0d, 0x28, 0xf8, + 0x2e, 0x81, 0x16, 0x1e, 0x1e, 0xf2, 0x24, 0x89, 0x7b, 0x29, 0x10, 0xa7, 0x39, 0xc8, 0xda, 0xd6, + 0x47, 0xe2, 0x55, 0x26, 0xad, 0xf2, 0x86, 0xe2, 0xc2, 0xf4, 0x98, 0x3f, 0x09, 0x08, 0x53, 0x21, + 0x42, 0xa4, 0x40, 0xd9, 0x1e, 0x1d, 0x68, 0x0f, 0xf1, 0x89, 0x78, 0xa3, 0xe1, 0xcb, 0x2f, 0xda, + 0xa3, 0x83, 0x3b, 0xf8, 0x84, 0x3f, 0xd2, 0x2c, 0x43, 0xc9, 0xa3, 0x61, 0x26, 0xce, 0xcf, 0x14, + 0x38, 0x49, 0x9b, 0x3f, 0xc1, 0x49, 0x72, 0x4a, 0xf9, 0xa1, 0x04, 0x79, 0xef, 0x96, 0xa0, 0xb7, + 0xa1, 0xe0, 0xbb, 0x2e, 0x91, 0xb4, 0x3f, 0x75, 0x8a, 0xd3, 0x13, 0x9b, 0x0f, 0x78, 0xd0, 0xba, + 0xf7, 0x96, 0x6c, 0x74, 0xb5, 0xde, 0x40, 0x3f, 0x14, 0x4f, 0x82, 0x8b, 0x31, 0xde, 0x8d, 0xf9, + 0x95, 0xad, 0xdb, 0x1b, 0x03, 0xfd, 0x50, 0x2d, 0x32, 0xa6, 0xad, 0x2e, 0x6d, 0x88, 0x74, 0xe8, + 0x8f, 0x29, 0x90, 0xc7, 0x6f, 0xf1, 0x37, 0x5f, 0xdf, 0x64, 0xd8, 0x4c, 0xc7, 0x85, 0xcd, 0x55, + 0x98, 0xf5, 0x29, 0x34, 0xd7, 0x38, 0x34, 0x75, 0x32, 0x72, 0xb0, 0xc0, 0x38, 0x91, 0x3f, 0xd4, + 0xf2, 0x46, 0x26, 0xf7, 0x9d, 0x7d, 0xec, 0x7d, 0x27, 0x43, 0xc8, 0xb9, 0x24, 0x08, 0x19, 0xbd, + 0x01, 0x0b, 0xe3, 0xe1, 0x3d, 0xb4, 0x5c, 0x5e, 0x59, 0x5c, 0x88, 0x06, 0x7a, 0x7f, 0xcd, 0x42, + 0xcf, 0x1f, 0xa7, 0xa0, 0x18, 0x82, 0x78, 0xd1, 0xbf, 0x87, 0x5c, 0x62, 0x25, 0x2e, 0xe4, 0x85, + 0x88, 0x83, 0xf7, 0xdc, 0xe8, 0xc9, 0xa4, 0x9e, 0xe0, 0x64, 0x92, 0xf0, 0x77, 0x0f, 0x33, 0xce, + 0x3c, 0x36, 0x66, 0xfc, 0x3c, 0x20, 0x62, 0x11, 0x7d, 0x40, 0xd5, 0x69, 0x98, 0x87, 0x1a, 0xbf, + 0x48, 0xdc, 0x83, 0xc9, 0x6c, 0x64, 0x9f, 0x0d, 0x34, 0xd9, 0xe5, 0xfb, 0xae, 0x04, 0x79, 0x1f, + 0x4f, 0x7b, 0xdc, 0x57, 0xdc, 0xf3, 0x90, 0x13, 0x29, 0x27, 0x7f, 0xc6, 0x15, 0xad, 0x58, 0x70, + 0x7c, 0x01, 0xf2, 0x43, 0x4c, 0x74, 0xe6, 0x8e, 0x79, 0xb8, 0xf6, 0xdb, 0x37, 0x0e, 0xa0, 0x18, + 0x7a, 0x2a, 0x47, 0x17, 0x61, 0xbe, 0xbe, 0xd9, 0xa8, 0xdf, 0xd1, 0xda, 0xef, 0x69, 0xed, 0xfb, + 0xcd, 0x86, 0x76, 0x6f, 0xf7, 0xce, 0xee, 0xde, 0x7f, 0xee, 0xca, 0xe7, 0x26, 0x87, 0xd4, 0x06, + 0x6b, 0xcb, 0x12, 0xba, 0x00, 0xb3, 0xd1, 0x21, 0x3e, 0x90, 0x5a, 0xc8, 0xfc, 0xe0, 0x67, 0x8b, + 0xe7, 0x6e, 0xfc, 0x59, 0x82, 0xd9, 0x98, 0xe4, 0x1e, 0x5d, 0x86, 0xa7, 0xf7, 0x36, 0x36, 0x1a, + 0xaa, 0xd6, 0xda, 0xad, 0x35, 0x5b, 0x9b, 0x7b, 0x6d, 0x4d, 0x6d, 0xb4, 0xee, 0xed, 0xb4, 0x43, + 0x93, 0x2e, 0xc3, 0xa5, 0x78, 0x92, 0x5a, 0xbd, 0xde, 0x68, 0xb6, 0x65, 0x09, 0x2d, 0xc1, 0x53, + 0x09, 0x14, 0xeb, 0x7b, 0x6a, 0x5b, 0x4e, 0x25, 0x8b, 0x50, 0x1b, 0xdb, 0x8d, 0x7a, 0x5b, 0x4e, + 0xa3, 0x6b, 0x70, 0xe5, 0x34, 0x0a, 0x6d, 0x63, 0x4f, 0xbd, 0x5b, 0x6b, 0xcb, 0x99, 0x33, 0x09, + 0x5b, 0x8d, 0xdd, 0xdb, 0x0d, 0x55, 0xce, 0x8a, 0x7d, 0xff, 0x34, 0x05, 0xd5, 0xa4, 0x1a, 0x82, + 0xca, 0xaa, 0x35, 0x9b, 0x3b, 0xf7, 0x03, 0x59, 0xf5, 0xcd, 0x7b, 0xbb, 0x77, 0x26, 0x55, 0xf0, + 0x2c, 0x28, 0xa7, 0x11, 0xfa, 0x8a, 0xb8, 0x0a, 0x97, 0x4f, 0xa5, 0x13, 0xea, 0x38, 0x83, 0x4c, + 0x6d, 0xb4, 0xd5, 0xfb, 0x72, 0x1a, 0xad, 0xc0, 0x8d, 0x33, 0xc9, 0xfc, 0x31, 0x39, 0x83, 0x56, + 0xe1, 0xe6, 0xe9, 0xf4, 0x5c, 0x41, 0x1e, 0x83, 0xa7, 0xa2, 0x4f, 0x24, 0x98, 0x8f, 0x2d, 0x46, + 0xd0, 0x15, 0x58, 0x6a, 0xaa, 0x7b, 0xf5, 0x46, 0xab, 0xa5, 0x35, 0xd5, 0xbd, 0xe6, 0x5e, 0xab, + 0xb6, 0xa3, 0xb5, 0xda, 0xb5, 0xf6, 0xbd, 0x56, 0x48, 0x37, 0x0a, 0x2c, 0x26, 0x11, 0xf9, 0x7a, + 0x39, 0x85, 0x46, 0x58, 0x80, 0x67, 0xa7, 0x3f, 0x91, 0xe0, 0x62, 0x62, 0x49, 0x81, 0xae, 0xc3, + 0x33, 0xfb, 0x0d, 0x75, 0x6b, 0xe3, 0xbe, 0xb6, 0xbf, 0xd7, 0x6e, 0x68, 0x8d, 0xf7, 0xda, 0x8d, + 0xdd, 0xd6, 0xd6, 0xde, 0xee, 0xe4, 0xaa, 0xae, 0xc1, 0x95, 0x53, 0x29, 0xfd, 0xa5, 0x9d, 0x45, + 0x38, 0xb6, 0xbe, 0xef, 0x49, 0x30, 0x3d, 0xe6, 0x0b, 0xd1, 0x25, 0xa8, 0xde, 0xdd, 0x6a, 0xad, + 0x37, 0x36, 0x6b, 0xfb, 0x5b, 0x7b, 0xea, 0xf8, 0x9d, 0xbd, 0x02, 0x4b, 0x13, 0xa3, 0xb7, 0xef, + 0x35, 0x77, 0xb6, 0xea, 0xb5, 0x76, 0x83, 0x4d, 0x2a, 0x4b, 0x74, 0x63, 0x13, 0x44, 0x3b, 0x5b, + 0xef, 0x6c, 0xb6, 0xb5, 0xfa, 0xce, 0x56, 0x63, 0xb7, 0xad, 0xd5, 0xda, 0xed, 0x5a, 0x70, 0x9d, + 0xd7, 0xef, 0x7c, 0xf6, 0xd5, 0xa2, 0xf4, 0xc5, 0x57, 0x8b, 0xd2, 0x1f, 0xbe, 0x5a, 0x94, 0x3e, + 0xfd, 0x7a, 0xf1, 0xdc, 0x17, 0x5f, 0x2f, 0x9e, 0xfb, 0xdd, 0xd7, 0x8b, 0xe7, 0x1e, 0xdc, 0x3a, + 0x34, 0x48, 0x7f, 0x74, 0x40, 0xbd, 0xf0, 0x6a, 0xf0, 0x47, 0xaf, 0xff, 0x2b, 0xb0, 0x6d, 0xac, + 0x8e, 0xff, 0x17, 0x7c, 0x90, 0x63, 0x6e, 0xf5, 0xc5, 0xbf, 0x05, 0x00, 0x00, 0xff, 0xff, 0x75, + 0x19, 0x64, 0x7d, 0x32, 0x2c, 0x00, 0x00, } func (m *Request) Marshal() (dAtA []byte, err error) { @@ -4761,6 +4769,11 @@ func (m *OfferSnapshotRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.AppVersion != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.AppVersion)) + i-- + dAtA[i] = 0x18 + } if len(m.AppHash) > 0 { i -= len(m.AppHash) copy(dAtA[i:], m.AppHash) @@ -7424,6 +7437,9 @@ func (m *OfferSnapshotRequest) Size() (n int) { if l > 0 { n += 1 + l + sovTypes(uint64(l)) } + if m.AppVersion != 0 { + n += 1 + sovTypes(uint64(m.AppVersion)) + } return n } @@ -10083,6 +10099,25 @@ func (m *OfferSnapshotRequest) Unmarshal(dAtA []byte) error { m.AppHash = []byte{} } iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppVersion", wireType) + } + m.AppVersion = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AppVersion |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) diff --git a/api/cometbft/mempool/v2/types.pb.go b/api/cometbft/mempool/v2/types.pb.go index d946a2e7bbd..cfee5d427bd 100644 --- a/api/cometbft/mempool/v2/types.pb.go +++ b/api/cometbft/mempool/v2/types.pb.go @@ -113,6 +113,50 @@ func (m *HaveTx) GetTxKey() []byte { return nil } +type WantTx struct { + TxKey []byte `protobuf:"bytes,1,opt,name=tx_key,json=txKey,proto3" json:"tx_key,omitempty"` +} + +func (m *WantTx) Reset() { *m = WantTx{} } +func (m *WantTx) String() string { return proto.CompactTextString(m) } +func (*WantTx) ProtoMessage() {} +func (*WantTx) Descriptor() ([]byte, []int) { + return fileDescriptor_f354aa43d1c2a8af, []int{2} +} +func (m *WantTx) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WantTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WantTx.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 *WantTx) XXX_Merge(src proto.Message) { + xxx_messageInfo_WantTx.Merge(m, src) +} +func (m *WantTx) XXX_Size() int { + return m.Size() +} +func (m *WantTx) XXX_DiscardUnknown() { + xxx_messageInfo_WantTx.DiscardUnknown(m) +} + +var xxx_messageInfo_WantTx proto.InternalMessageInfo + +func (m *WantTx) GetTxKey() []byte { + if m != nil { + return m.TxKey + } + return nil +} + // ResetRoute is sent by the DOG protocol to signal a peer to reset a (random) // route to the sender. type ResetRoute struct { @@ -122,7 +166,7 @@ func (m *ResetRoute) Reset() { *m = ResetRoute{} } func (m *ResetRoute) String() string { return proto.CompactTextString(m) } func (*ResetRoute) ProtoMessage() {} func (*ResetRoute) Descriptor() ([]byte, []int) { - return fileDescriptor_f354aa43d1c2a8af, []int{2} + return fileDescriptor_f354aa43d1c2a8af, []int{3} } func (m *ResetRoute) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -160,6 +204,7 @@ type Message struct { // *Message_Txs // *Message_HaveTx // *Message_ResetRoute + // *Message_WantTx Sum isMessage_Sum `protobuf_oneof:"sum"` } @@ -167,7 +212,7 @@ func (m *Message) Reset() { *m = Message{} } func (m *Message) String() string { return proto.CompactTextString(m) } func (*Message) ProtoMessage() {} func (*Message) Descriptor() ([]byte, []int) { - return fileDescriptor_f354aa43d1c2a8af, []int{3} + return fileDescriptor_f354aa43d1c2a8af, []int{4} } func (m *Message) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -211,10 +256,14 @@ type Message_HaveTx struct { type Message_ResetRoute struct { ResetRoute *ResetRoute `protobuf:"bytes,3,opt,name=reset_route,json=resetRoute,proto3,oneof" json:"reset_route,omitempty"` } +type Message_WantTx struct { + WantTx *WantTx `protobuf:"bytes,4,opt,name=want_tx,json=wantTx,proto3,oneof" json:"want_tx,omitempty"` +} func (*Message_Txs) isMessage_Sum() {} func (*Message_HaveTx) isMessage_Sum() {} func (*Message_ResetRoute) isMessage_Sum() {} +func (*Message_WantTx) isMessage_Sum() {} func (m *Message) GetSum() isMessage_Sum { if m != nil { @@ -244,18 +293,27 @@ func (m *Message) GetResetRoute() *ResetRoute { return nil } +func (m *Message) GetWantTx() *WantTx { + if x, ok := m.GetSum().(*Message_WantTx); ok { + return x.WantTx + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*Message) XXX_OneofWrappers() []interface{} { return []interface{}{ (*Message_Txs)(nil), (*Message_HaveTx)(nil), (*Message_ResetRoute)(nil), + (*Message_WantTx)(nil), } } func init() { proto.RegisterType((*Txs)(nil), "cometbft.mempool.v2.Txs") proto.RegisterType((*HaveTx)(nil), "cometbft.mempool.v2.HaveTx") + proto.RegisterType((*WantTx)(nil), "cometbft.mempool.v2.WantTx") proto.RegisterType((*ResetRoute)(nil), "cometbft.mempool.v2.ResetRoute") proto.RegisterType((*Message)(nil), "cometbft.mempool.v2.Message") } @@ -263,25 +321,27 @@ func init() { func init() { proto.RegisterFile("cometbft/mempool/v2/types.proto", fileDescriptor_f354aa43d1c2a8af) } var fileDescriptor_f354aa43d1c2a8af = []byte{ - // 282 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xc1, 0x4a, 0x84, 0x50, - 0x14, 0x86, 0xef, 0x4d, 0xc6, 0x81, 0x33, 0xb3, 0x08, 0x23, 0x12, 0x82, 0x3b, 0x83, 0x2b, 0x17, - 0xa1, 0x60, 0xd1, 0x03, 0xb8, 0x12, 0xa2, 0x16, 0x17, 0x57, 0x6d, 0x44, 0xe3, 0x34, 0x0e, 0x25, - 0x57, 0xbc, 0x57, 0xb9, 0xbe, 0x45, 0xcf, 0xd3, 0x13, 0xb4, 0x9c, 0x65, 0xcb, 0xd0, 0x17, 0x09, - 0x9d, 0xc6, 0x36, 0xee, 0xce, 0x81, 0xf3, 0x9d, 0xff, 0xe3, 0x87, 0xcd, 0x8b, 0x28, 0x50, 0x65, - 0xaf, 0xca, 0x2f, 0xb0, 0x28, 0x85, 0x78, 0xf7, 0x9b, 0xc0, 0x57, 0x6d, 0x89, 0xd2, 0x2b, 0x2b, - 0xa1, 0x84, 0x75, 0x71, 0x3a, 0xf0, 0xfe, 0x0e, 0xbc, 0x26, 0x70, 0xae, 0xc0, 0x88, 0xb5, 0xb4, - 0xce, 0xc1, 0x50, 0x5a, 0xda, 0x74, 0x6b, 0xb8, 0x6b, 0x3e, 0x8c, 0xce, 0x06, 0xcc, 0x28, 0x6d, - 0x30, 0xd6, 0xd6, 0x25, 0x98, 0x4a, 0x27, 0x6f, 0xd8, 0xda, 0x74, 0x4b, 0xdd, 0x35, 0x5f, 0x28, - 0xfd, 0x80, 0xad, 0xb3, 0x06, 0xe0, 0x28, 0x51, 0x71, 0x51, 0x2b, 0x74, 0x3e, 0x29, 0x2c, 0x1f, - 0x51, 0xca, 0x74, 0x87, 0xd6, 0xcd, 0xe9, 0x19, 0x75, 0x57, 0x81, 0xed, 0xcd, 0xc4, 0x7a, 0xb1, - 0x96, 0x11, 0x19, 0x83, 0xac, 0x7b, 0x58, 0xe6, 0x69, 0x83, 0x89, 0xd2, 0xf6, 0xd9, 0x48, 0x5c, - 0xcf, 0x12, 0x47, 0x99, 0x88, 0x70, 0x33, 0x3f, 0x6a, 0x85, 0xb0, 0xaa, 0x86, 0xfc, 0xa4, 0x1a, - 0x04, 0x6c, 0x63, 0x64, 0x37, 0xb3, 0xec, 0xbf, 0x67, 0x44, 0x38, 0x54, 0xd3, 0x16, 0x2e, 0xc0, - 0x90, 0x75, 0x11, 0x3e, 0x7d, 0x75, 0x8c, 0x1e, 0x3a, 0x46, 0x7f, 0x3a, 0x46, 0x3f, 0x7a, 0x46, - 0x0e, 0x3d, 0x23, 0xdf, 0x3d, 0x23, 0xcf, 0x77, 0xbb, 0xbd, 0xca, 0xeb, 0x6c, 0xf8, 0xea, 0x4f, - 0xfd, 0x4e, 0x43, 0x5a, 0xee, 0xfd, 0x99, 0xd6, 0x33, 0x73, 0x2c, 0xfc, 0xf6, 0x37, 0x00, 0x00, - 0xff, 0xff, 0xaa, 0x61, 0x3b, 0xc6, 0x93, 0x01, 0x00, 0x00, + // 308 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0x41, 0x4a, 0xc3, 0x40, + 0x14, 0x86, 0x67, 0x8c, 0x4d, 0xe1, 0xb5, 0x0b, 0x89, 0x88, 0x01, 0x61, 0x5a, 0xba, 0xea, 0x42, + 0x12, 0xa8, 0xe2, 0x01, 0xba, 0x0a, 0x88, 0x2e, 0x86, 0x82, 0xe0, 0xa6, 0x4c, 0xe5, 0xd9, 0x16, + 0x4d, 0x27, 0x64, 0x5e, 0xd3, 0xe9, 0x2d, 0x3c, 0x96, 0xcb, 0x2e, 0x5d, 0x4a, 0x7b, 0x03, 0x4f, + 0x20, 0x93, 0xda, 0xb8, 0x89, 0xee, 0x5e, 0xe0, 0xff, 0xf3, 0x7d, 0xcc, 0x0f, 0x9d, 0x27, 0x9d, + 0x22, 0x4d, 0x9e, 0x29, 0x4e, 0x31, 0xcd, 0xb4, 0x7e, 0x8d, 0x8b, 0x41, 0x4c, 0xeb, 0x0c, 0x4d, + 0x94, 0xe5, 0x9a, 0x74, 0x70, 0x7a, 0x08, 0x44, 0x3f, 0x81, 0xa8, 0x18, 0xf4, 0xce, 0xc1, 0x1b, + 0x59, 0x13, 0x9c, 0x80, 0x47, 0xd6, 0x84, 0xbc, 0xeb, 0xf5, 0xdb, 0xd2, 0x9d, 0xbd, 0x0e, 0xf8, + 0x89, 0x2a, 0x70, 0x64, 0x83, 0x33, 0xf0, 0xc9, 0x8e, 0x5f, 0x70, 0x1d, 0xf2, 0x2e, 0xef, 0xb7, + 0x65, 0x83, 0xec, 0x2d, 0xae, 0x5d, 0xe0, 0x41, 0x2d, 0xe8, 0xef, 0x40, 0x1b, 0x40, 0xa2, 0x41, + 0x92, 0x7a, 0x49, 0xd8, 0xfb, 0xe2, 0xd0, 0xbc, 0x43, 0x63, 0xd4, 0x14, 0x83, 0xcb, 0x03, 0x8d, + 0xf7, 0x5b, 0x83, 0x30, 0xaa, 0xf1, 0x8a, 0x46, 0xd6, 0x24, 0xac, 0x34, 0x09, 0x6e, 0xa0, 0x39, + 0x53, 0x05, 0x8e, 0xc9, 0x86, 0x47, 0x65, 0xe3, 0xa2, 0xb6, 0xb1, 0xb7, 0x4d, 0x98, 0xf4, 0x67, + 0x7b, 0xef, 0x21, 0xb4, 0x72, 0xc7, 0x1f, 0xe7, 0x4e, 0x20, 0xf4, 0xca, 0x6e, 0xa7, 0xb6, 0xfb, + 0xeb, 0x99, 0x30, 0x09, 0x79, 0xf5, 0xe5, 0xd8, 0x2b, 0xb5, 0x20, 0xc7, 0x3e, 0xfe, 0x87, 0xbd, + 0x7f, 0x08, 0xc7, 0x5e, 0x95, 0xd7, 0xb0, 0x01, 0x9e, 0x59, 0xa6, 0xc3, 0xfb, 0xf7, 0xad, 0xe0, + 0x9b, 0xad, 0xe0, 0x9f, 0x5b, 0xc1, 0xdf, 0x76, 0x82, 0x6d, 0x76, 0x82, 0x7d, 0xec, 0x04, 0x7b, + 0xbc, 0x9e, 0xce, 0x69, 0xb6, 0x9c, 0xb8, 0xbf, 0xc5, 0xd5, 0x70, 0xd5, 0xa1, 0xb2, 0x79, 0x5c, + 0x33, 0xe7, 0xc4, 0x2f, 0x97, 0xbc, 0xfa, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x6d, 0xbb, 0xa5, 0x84, + 0xec, 0x01, 0x00, 0x00, } func (m *Txs) Marshal() (dAtA []byte, err error) { @@ -346,6 +406,36 @@ func (m *HaveTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *WantTx) 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 *WantTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WantTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.TxKey) > 0 { + i -= len(m.TxKey) + copy(dAtA[i:], m.TxKey) + i = encodeVarintTypes(dAtA, i, uint64(len(m.TxKey))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *ResetRoute) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -464,6 +554,27 @@ func (m *Message_ResetRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } +func (m *Message_WantTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Message_WantTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.WantTx != nil { + { + size, err := m.WantTx.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { offset -= sovTypes(v) base := offset @@ -503,6 +614,19 @@ func (m *HaveTx) Size() (n int) { return n } +func (m *WantTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.TxKey) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + func (m *ResetRoute) Size() (n int) { if m == nil { return 0 @@ -560,6 +684,18 @@ func (m *Message_ResetRoute) Size() (n int) { } return n } +func (m *Message_WantTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.WantTx != nil { + l = m.WantTx.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} func sovTypes(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 @@ -733,6 +869,90 @@ func (m *HaveTx) Unmarshal(dAtA []byte) error { } return nil } +func (m *WantTx) 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: WantTx: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WantTx: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TxKey", 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.TxKey = append(m.TxKey[:0], dAtA[iNdEx:postIndex]...) + if m.TxKey == nil { + m.TxKey = []byte{} + } + 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 *ResetRoute) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -917,6 +1137,41 @@ func (m *Message) Unmarshal(dAtA []byte) error { } m.Sum = &Message_ResetRoute{v} iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WantTx", 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 := &WantTx{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Sum = &Message_WantTx{v} + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) diff --git a/api/cometbft/rpc/grpc/v1beta3/types.pb.go b/api/cometbft/rpc/grpc/v1beta3/types.pb.go index 353d371b1fd..b0aa3da4273 100644 --- a/api/cometbft/rpc/grpc/v1beta3/types.pb.go +++ b/api/cometbft/rpc/grpc/v1beta3/types.pb.go @@ -7,21 +7,29 @@ import ( context "context" fmt "fmt" v1beta3 "github.com/cometbft/cometbft/api/cometbft/abci/v1beta3" + v11 "github.com/cometbft/cometbft/api/cometbft/crypto/v1" + v1 "github.com/cometbft/cometbft/api/cometbft/p2p/v1" v1beta1 "github.com/cometbft/cometbft/api/cometbft/rpc/grpc/v1beta1" + v2 "github.com/cometbft/cometbft/api/cometbft/types/v2" + _ "github.com/cosmos/gogoproto/gogoproto" grpc1 "github.com/cosmos/gogoproto/grpc" proto "github.com/cosmos/gogoproto/proto" + _ "github.com/cosmos/gogoproto/types" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" + time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf +var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. @@ -82,241 +90,4000 @@ func (m *ResponseBroadcastTx) GetTxResult() *v1beta3.ExecTxResult { return nil } -func init() { - proto.RegisterType((*ResponseBroadcastTx)(nil), "cometbft.rpc.grpc.v1beta3.ResponseBroadcastTx") +// BlockByHashRequest is a request to get a block by its hash. +type BlockByHashRequest struct { + Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` + Prove bool `protobuf:"varint,2,opt,name=prove,proto3" json:"prove,omitempty"` } -func init() { - proto.RegisterFile("cometbft/rpc/grpc/v1beta3/types.proto", fileDescriptor_e521bcdb5edbf680) +func (m *BlockByHashRequest) Reset() { *m = BlockByHashRequest{} } +func (m *BlockByHashRequest) String() string { return proto.CompactTextString(m) } +func (*BlockByHashRequest) ProtoMessage() {} +func (*BlockByHashRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{1} } - -var fileDescriptor_e521bcdb5edbf680 = []byte{ - // 308 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4d, 0xce, 0xcf, 0x4d, - 0x2d, 0x49, 0x4a, 0x2b, 0xd1, 0x2f, 0x2a, 0x48, 0xd6, 0x4f, 0x07, 0x11, 0x65, 0x86, 0x49, 0xa9, - 0x25, 0x89, 0xc6, 0xfa, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, - 0x92, 0x30, 0x65, 0x7a, 0x45, 0x05, 0xc9, 0x7a, 0x20, 0x65, 0x7a, 0x50, 0x65, 0x52, 0x38, 0x4d, - 0x30, 0x44, 0x36, 0x41, 0x4a, 0x11, 0xae, 0x2c, 0x31, 0x29, 0x39, 0x13, 0x9b, 0x25, 0x4a, 0xb3, - 0x18, 0xb9, 0x84, 0x83, 0x52, 0x8b, 0x0b, 0xf2, 0xf3, 0x8a, 0x53, 0x9d, 0x8a, 0xf2, 0x13, 0x53, - 0x92, 0x13, 0x8b, 0x4b, 0x42, 0x2a, 0x84, 0x1c, 0xb9, 0x38, 0x92, 0x33, 0x52, 0x93, 0xb3, 0xe3, - 0x4b, 0x2a, 0x24, 0x18, 0x15, 0x18, 0x35, 0xb8, 0x8d, 0xd4, 0xf4, 0xe0, 0xee, 0x01, 0x99, 0x06, - 0x73, 0x8b, 0x1e, 0x4c, 0xb7, 0x33, 0x48, 0x79, 0x48, 0x45, 0x10, 0x7b, 0x32, 0x84, 0x21, 0xe4, - 0xc0, 0xc5, 0x59, 0x52, 0x11, 0x5f, 0x94, 0x5a, 0x5c, 0x9a, 0x53, 0x22, 0xc1, 0x04, 0x36, 0x43, - 0x19, 0x87, 0x19, 0xae, 0x15, 0xa9, 0xc9, 0x21, 0x15, 0x41, 0x60, 0xa5, 0x41, 0x1c, 0x25, 0x50, - 0x96, 0xd1, 0x55, 0x46, 0x2e, 0x1e, 0xb8, 0xa3, 0x1c, 0x03, 0x3c, 0x85, 0xc2, 0xb9, 0x58, 0x02, - 0x32, 0xf3, 0xd2, 0x85, 0x90, 0xdc, 0x82, 0x16, 0x36, 0x86, 0x7a, 0x41, 0xa9, 0x85, 0xa5, 0xa9, - 0xc5, 0x25, 0x20, 0x75, 0x52, 0xea, 0x78, 0xd5, 0x41, 0xdc, 0x0d, 0x36, 0x30, 0x87, 0x8b, 0x1b, - 0xd9, 0xf7, 0xba, 0x84, 0xcd, 0x47, 0x52, 0x2e, 0xa5, 0x87, 0x53, 0x39, 0x22, 0x78, 0x90, 0xd4, - 0x3b, 0x85, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, - 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x55, 0x7a, 0x66, - 0x49, 0x46, 0x69, 0x12, 0xc8, 0x3c, 0x7d, 0x78, 0xe4, 0x21, 0x62, 0xb1, 0x20, 0x53, 0x1f, 0x67, - 0xda, 0x49, 0x62, 0x03, 0xc7, 0xa8, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xc2, 0xcf, 0xef, 0x1f, - 0x5f, 0x02, 0x00, 0x00, +func (m *BlockByHashRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BlockByHashRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BlockByHashRequest.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 *BlockByHashRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_BlockByHashRequest.Merge(m, src) +} +func (m *BlockByHashRequest) XXX_Size() int { + return m.Size() +} +func (m *BlockByHashRequest) XXX_DiscardUnknown() { + xxx_messageInfo_BlockByHashRequest.DiscardUnknown(m) } -// Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the grpc package it is being compiled against. -const _ = grpc.SupportPackageIsVersion4 +var xxx_messageInfo_BlockByHashRequest proto.InternalMessageInfo -// BroadcastAPIClient is the client API for BroadcastAPI service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type BroadcastAPIClient interface { - // Ping the connection. - Ping(ctx context.Context, in *v1beta1.RequestPing, opts ...grpc.CallOption) (*v1beta1.ResponsePing, error) - // BroadcastTx broadcasts a transaction. - BroadcastTx(ctx context.Context, in *v1beta1.RequestBroadcastTx, opts ...grpc.CallOption) (*ResponseBroadcastTx, error) +func (m *BlockByHashRequest) GetHash() []byte { + if m != nil { + return m.Hash + } + return nil } -type broadcastAPIClient struct { - cc grpc1.ClientConn +func (m *BlockByHashRequest) GetProve() bool { + if m != nil { + return m.Prove + } + return false } -func NewBroadcastAPIClient(cc grpc1.ClientConn) BroadcastAPIClient { - return &broadcastAPIClient{cc} +// BlockByHeightRequest is a request to get a block by its height. +type BlockByHeightRequest struct { + // Height the requested block height. + // If height is equal to 0, the latest height stored in the block store + // will be used. + Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` + // Prove set to true to return the parts proofs. + Prove bool `protobuf:"varint,2,opt,name=prove,proto3" json:"prove,omitempty"` } -func (c *broadcastAPIClient) Ping(ctx context.Context, in *v1beta1.RequestPing, opts ...grpc.CallOption) (*v1beta1.ResponsePing, error) { - out := new(v1beta1.ResponsePing) - err := c.cc.Invoke(ctx, "/cometbft.rpc.grpc.v1beta3.BroadcastAPI/Ping", in, out, opts...) - if err != nil { - return nil, err +func (m *BlockByHeightRequest) Reset() { *m = BlockByHeightRequest{} } +func (m *BlockByHeightRequest) String() string { return proto.CompactTextString(m) } +func (*BlockByHeightRequest) ProtoMessage() {} +func (*BlockByHeightRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{2} +} +func (m *BlockByHeightRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BlockByHeightRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BlockByHeightRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *BlockByHeightRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_BlockByHeightRequest.Merge(m, src) +} +func (m *BlockByHeightRequest) XXX_Size() int { + return m.Size() +} +func (m *BlockByHeightRequest) XXX_DiscardUnknown() { + xxx_messageInfo_BlockByHeightRequest.DiscardUnknown(m) } -func (c *broadcastAPIClient) BroadcastTx(ctx context.Context, in *v1beta1.RequestBroadcastTx, opts ...grpc.CallOption) (*ResponseBroadcastTx, error) { - out := new(ResponseBroadcastTx) - err := c.cc.Invoke(ctx, "/cometbft.rpc.grpc.v1beta3.BroadcastAPI/BroadcastTx", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_BlockByHeightRequest proto.InternalMessageInfo + +func (m *BlockByHeightRequest) GetHeight() int64 { + if m != nil { + return m.Height } - return out, nil + return 0 } -// BroadcastAPIServer is the server API for BroadcastAPI service. -type BroadcastAPIServer interface { - // Ping the connection. - Ping(context.Context, *v1beta1.RequestPing) (*v1beta1.ResponsePing, error) - // BroadcastTx broadcasts a transaction. - BroadcastTx(context.Context, *v1beta1.RequestBroadcastTx) (*ResponseBroadcastTx, error) +func (m *BlockByHeightRequest) GetProve() bool { + if m != nil { + return m.Prove + } + return false } -// UnimplementedBroadcastAPIServer can be embedded to have forward compatible implementations. -type UnimplementedBroadcastAPIServer struct { +// CommitRequest is a request to get the commit of a block. +type CommitRequest struct { + // Height the requested block commit height. + // If height is equal to 0, the latest height stored in the block store + // will be used. + Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` } -func (*UnimplementedBroadcastAPIServer) Ping(ctx context.Context, req *v1beta1.RequestPing) (*v1beta1.ResponsePing, error) { - return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented") +func (m *CommitRequest) Reset() { *m = CommitRequest{} } +func (m *CommitRequest) String() string { return proto.CompactTextString(m) } +func (*CommitRequest) ProtoMessage() {} +func (*CommitRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{3} } -func (*UnimplementedBroadcastAPIServer) BroadcastTx(ctx context.Context, req *v1beta1.RequestBroadcastTx) (*ResponseBroadcastTx, error) { - return nil, status.Errorf(codes.Unimplemented, "method BroadcastTx not implemented") +func (m *CommitRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func RegisterBroadcastAPIServer(s grpc1.Server, srv BroadcastAPIServer) { - s.RegisterService(&_BroadcastAPI_serviceDesc, srv) +func (m *CommitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommitRequest.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 *CommitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitRequest.Merge(m, src) +} +func (m *CommitRequest) XXX_Size() int { + return m.Size() +} +func (m *CommitRequest) XXX_DiscardUnknown() { + xxx_messageInfo_CommitRequest.DiscardUnknown(m) } -func _BroadcastAPI_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(v1beta1.RequestPing) - if err := dec(in); err != nil { - return nil, err +var xxx_messageInfo_CommitRequest proto.InternalMessageInfo + +func (m *CommitRequest) GetHeight() int64 { + if m != nil { + return m.Height } - if interceptor == nil { - return srv.(BroadcastAPIServer).Ping(ctx, in) + return 0 +} + +// ValidatorSetRequest is a request to get the validator set of a block. +type ValidatorSetRequest struct { + // Height the requested validator set height. + // If height is equal to 0, the latest height stored in the block store + // will be used. + Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` +} + +func (m *ValidatorSetRequest) Reset() { *m = ValidatorSetRequest{} } +func (m *ValidatorSetRequest) String() string { return proto.CompactTextString(m) } +func (*ValidatorSetRequest) ProtoMessage() {} +func (*ValidatorSetRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{4} +} +func (m *ValidatorSetRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorSetRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cometbft.rpc.grpc.v1beta3.BroadcastAPI/Ping", +} +func (m *ValidatorSetRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorSetRequest.Merge(m, src) +} +func (m *ValidatorSetRequest) XXX_Size() int { + return m.Size() +} +func (m *ValidatorSetRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorSetRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorSetRequest proto.InternalMessageInfo + +func (m *ValidatorSetRequest) GetHeight() int64 { + if m != nil { + return m.Height } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(BroadcastAPIServer).Ping(ctx, req.(*v1beta1.RequestPing)) + return 0 +} + +// SubscribeNewHeightsRequest is a request to subscribe to new heights. +type SubscribeNewHeightsRequest struct { +} + +func (m *SubscribeNewHeightsRequest) Reset() { *m = SubscribeNewHeightsRequest{} } +func (m *SubscribeNewHeightsRequest) String() string { return proto.CompactTextString(m) } +func (*SubscribeNewHeightsRequest) ProtoMessage() {} +func (*SubscribeNewHeightsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{5} +} +func (m *SubscribeNewHeightsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SubscribeNewHeightsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SubscribeNewHeightsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return interceptor(ctx, in, info, handler) +} +func (m *SubscribeNewHeightsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SubscribeNewHeightsRequest.Merge(m, src) +} +func (m *SubscribeNewHeightsRequest) XXX_Size() int { + return m.Size() +} +func (m *SubscribeNewHeightsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SubscribeNewHeightsRequest.DiscardUnknown(m) } -func _BroadcastAPI_BroadcastTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(v1beta1.RequestBroadcastTx) - if err := dec(in); err != nil { - return nil, err +var xxx_messageInfo_SubscribeNewHeightsRequest proto.InternalMessageInfo + +// StatusRequest is a request to get the status of the node. +type StatusRequest struct { +} + +func (m *StatusRequest) Reset() { *m = StatusRequest{} } +func (m *StatusRequest) String() string { return proto.CompactTextString(m) } +func (*StatusRequest) ProtoMessage() {} +func (*StatusRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{6} +} +func (m *StatusRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StatusRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - if interceptor == nil { - return srv.(BroadcastAPIServer).BroadcastTx(ctx, in) +} +func (m *StatusRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StatusRequest.Merge(m, src) +} +func (m *StatusRequest) XXX_Size() int { + return m.Size() +} +func (m *StatusRequest) XXX_DiscardUnknown() { + xxx_messageInfo_StatusRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_StatusRequest proto.InternalMessageInfo + +// StreamedBlockByHashResponse is a response to a BlockByHashRequest. +type StreamedBlockByHashResponse struct { + BlockPart *v2.Part `protobuf:"bytes,1,opt,name=block_part,json=blockPart,proto3" json:"block_part,omitempty"` + // Commit is only set in the first part, and + // it stays nil in the remaining ones. + Commit *v2.Commit `protobuf:"bytes,2,opt,name=commit,proto3" json:"commit,omitempty"` + // ValidatorSet is only set in the first part, and + // it stays nil in the remaining ones. + ValidatorSet *v2.ValidatorSet `protobuf:"bytes,3,opt,name=validator_set,json=validatorSet,proto3" json:"validator_set,omitempty"` + IsLast bool `protobuf:"varint,4,opt,name=is_last,json=isLast,proto3" json:"is_last,omitempty"` +} + +func (m *StreamedBlockByHashResponse) Reset() { *m = StreamedBlockByHashResponse{} } +func (m *StreamedBlockByHashResponse) String() string { return proto.CompactTextString(m) } +func (*StreamedBlockByHashResponse) ProtoMessage() {} +func (*StreamedBlockByHashResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{7} +} +func (m *StreamedBlockByHashResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StreamedBlockByHashResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StreamedBlockByHashResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/cometbft.rpc.grpc.v1beta3.BroadcastAPI/BroadcastTx", +} +func (m *StreamedBlockByHashResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StreamedBlockByHashResponse.Merge(m, src) +} +func (m *StreamedBlockByHashResponse) XXX_Size() int { + return m.Size() +} +func (m *StreamedBlockByHashResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StreamedBlockByHashResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StreamedBlockByHashResponse proto.InternalMessageInfo + +func (m *StreamedBlockByHashResponse) GetBlockPart() *v2.Part { + if m != nil { + return m.BlockPart } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(BroadcastAPIServer).BroadcastTx(ctx, req.(*v1beta1.RequestBroadcastTx)) + return nil +} + +func (m *StreamedBlockByHashResponse) GetCommit() *v2.Commit { + if m != nil { + return m.Commit } - return interceptor(ctx, in, info, handler) + return nil } -var BroadcastAPI_serviceDesc = _BroadcastAPI_serviceDesc -var _BroadcastAPI_serviceDesc = grpc.ServiceDesc{ - ServiceName: "cometbft.rpc.grpc.v1beta3.BroadcastAPI", - HandlerType: (*BroadcastAPIServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "Ping", - Handler: _BroadcastAPI_Ping_Handler, - }, - { - MethodName: "BroadcastTx", - Handler: _BroadcastAPI_BroadcastTx_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "cometbft/rpc/grpc/v1beta3/types.proto", +func (m *StreamedBlockByHashResponse) GetValidatorSet() *v2.ValidatorSet { + if m != nil { + return m.ValidatorSet + } + return nil } -func (m *ResponseBroadcastTx) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *StreamedBlockByHashResponse) GetIsLast() bool { + if m != nil { + return m.IsLast } - return dAtA[:n], nil + return false } -func (m *ResponseBroadcastTx) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +// StreamedBlockByHeightResponse is a response to a BlockByHeightRequest. +type StreamedBlockByHeightResponse struct { + BlockPart *v2.Part `protobuf:"bytes,1,opt,name=block_part,json=blockPart,proto3" json:"block_part,omitempty"` + // Commit is only set in the first part, and + // it stays nil in the remaining ones. + Commit *v2.Commit `protobuf:"bytes,2,opt,name=commit,proto3" json:"commit,omitempty"` + // ValidatorSet is only set in the first part, and + // it stays nil in the remaining ones. + ValidatorSet *v2.ValidatorSet `protobuf:"bytes,3,opt,name=validator_set,json=validatorSet,proto3" json:"validator_set,omitempty"` + IsLast bool `protobuf:"varint,4,opt,name=is_last,json=isLast,proto3" json:"is_last,omitempty"` } -func (m *ResponseBroadcastTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.TxResult != nil { +func (m *StreamedBlockByHeightResponse) Reset() { *m = StreamedBlockByHeightResponse{} } +func (m *StreamedBlockByHeightResponse) String() string { return proto.CompactTextString(m) } +func (*StreamedBlockByHeightResponse) ProtoMessage() {} +func (*StreamedBlockByHeightResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{8} +} +func (m *StreamedBlockByHeightResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StreamedBlockByHeightResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StreamedBlockByHeightResponse.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 *StreamedBlockByHeightResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StreamedBlockByHeightResponse.Merge(m, src) +} +func (m *StreamedBlockByHeightResponse) XXX_Size() int { + return m.Size() +} +func (m *StreamedBlockByHeightResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StreamedBlockByHeightResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StreamedBlockByHeightResponse proto.InternalMessageInfo + +func (m *StreamedBlockByHeightResponse) GetBlockPart() *v2.Part { + if m != nil { + return m.BlockPart + } + return nil +} + +func (m *StreamedBlockByHeightResponse) GetCommit() *v2.Commit { + if m != nil { + return m.Commit + } + return nil +} + +func (m *StreamedBlockByHeightResponse) GetValidatorSet() *v2.ValidatorSet { + if m != nil { + return m.ValidatorSet + } + return nil +} + +func (m *StreamedBlockByHeightResponse) GetIsLast() bool { + if m != nil { + return m.IsLast + } + return false +} + +// CommitResponse is a response to a CommitRequest. +type CommitResponse struct { + Commit *v2.Commit `protobuf:"bytes,1,opt,name=commit,proto3" json:"commit,omitempty"` +} + +func (m *CommitResponse) Reset() { *m = CommitResponse{} } +func (m *CommitResponse) String() string { return proto.CompactTextString(m) } +func (*CommitResponse) ProtoMessage() {} +func (*CommitResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{9} +} +func (m *CommitResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommitResponse.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 *CommitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitResponse.Merge(m, src) +} +func (m *CommitResponse) XXX_Size() int { + return m.Size() +} +func (m *CommitResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CommitResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_CommitResponse proto.InternalMessageInfo + +func (m *CommitResponse) GetCommit() *v2.Commit { + if m != nil { + return m.Commit + } + return nil +} + +// ValidatorSetResponse is a response to a ValidatorSetRequest. +type ValidatorSetResponse struct { + // ValidatorSet the requested validator set. + ValidatorSet *v2.ValidatorSet `protobuf:"bytes,1,opt,name=validator_set,json=validatorSet,proto3" json:"validator_set,omitempty"` + // Height the height corresponding to the returned + // validator set. + Height int64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` +} + +func (m *ValidatorSetResponse) Reset() { *m = ValidatorSetResponse{} } +func (m *ValidatorSetResponse) String() string { return proto.CompactTextString(m) } +func (*ValidatorSetResponse) ProtoMessage() {} +func (*ValidatorSetResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{10} +} +func (m *ValidatorSetResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorSetResponse.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 *ValidatorSetResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorSetResponse.Merge(m, src) +} +func (m *ValidatorSetResponse) XXX_Size() int { + return m.Size() +} +func (m *ValidatorSetResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorSetResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorSetResponse proto.InternalMessageInfo + +func (m *ValidatorSetResponse) GetValidatorSet() *v2.ValidatorSet { + if m != nil { + return m.ValidatorSet + } + return nil +} + +func (m *ValidatorSetResponse) GetHeight() int64 { + if m != nil { + return m.Height + } + return 0 +} + +// NewHeightEvent is an event that indicates a new height. +type NewHeightEvent struct { + Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` + Hash []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"` +} + +func (m *NewHeightEvent) Reset() { *m = NewHeightEvent{} } +func (m *NewHeightEvent) String() string { return proto.CompactTextString(m) } +func (*NewHeightEvent) ProtoMessage() {} +func (*NewHeightEvent) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{11} +} +func (m *NewHeightEvent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NewHeightEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_NewHeightEvent.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 *NewHeightEvent) XXX_Merge(src proto.Message) { + xxx_messageInfo_NewHeightEvent.Merge(m, src) +} +func (m *NewHeightEvent) XXX_Size() int { + return m.Size() +} +func (m *NewHeightEvent) XXX_DiscardUnknown() { + xxx_messageInfo_NewHeightEvent.DiscardUnknown(m) +} + +var xxx_messageInfo_NewHeightEvent proto.InternalMessageInfo + +func (m *NewHeightEvent) GetHeight() int64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *NewHeightEvent) GetHash() []byte { + if m != nil { + return m.Hash + } + return nil +} + +// StatusResponse is a response to a StatusRequest. +type StatusResponse struct { + NodeInfo *v1.DefaultNodeInfo `protobuf:"bytes,1,opt,name=node_info,json=nodeInfo,proto3" json:"node_info,omitempty"` + SyncInfo *SyncInfo `protobuf:"bytes,2,opt,name=sync_info,json=syncInfo,proto3" json:"sync_info,omitempty"` + ValidatorInfo *ValidatorInfo `protobuf:"bytes,3,opt,name=validator_info,json=validatorInfo,proto3" json:"validator_info,omitempty"` +} + +func (m *StatusResponse) Reset() { *m = StatusResponse{} } +func (m *StatusResponse) String() string { return proto.CompactTextString(m) } +func (*StatusResponse) ProtoMessage() {} +func (*StatusResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{12} +} +func (m *StatusResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StatusResponse.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 *StatusResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StatusResponse.Merge(m, src) +} +func (m *StatusResponse) XXX_Size() int { + return m.Size() +} +func (m *StatusResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StatusResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StatusResponse proto.InternalMessageInfo + +func (m *StatusResponse) GetNodeInfo() *v1.DefaultNodeInfo { + if m != nil { + return m.NodeInfo + } + return nil +} + +func (m *StatusResponse) GetSyncInfo() *SyncInfo { + if m != nil { + return m.SyncInfo + } + return nil +} + +func (m *StatusResponse) GetValidatorInfo() *ValidatorInfo { + if m != nil { + return m.ValidatorInfo + } + return nil +} + +// SyncInfo is information about the node's sync status. +type SyncInfo struct { + LatestBlockHash []byte `protobuf:"bytes,1,opt,name=latest_block_hash,json=latestBlockHash,proto3" json:"latest_block_hash,omitempty"` + LatestAppHash []byte `protobuf:"bytes,2,opt,name=latest_app_hash,json=latestAppHash,proto3" json:"latest_app_hash,omitempty"` + LatestBlockHeight int64 `protobuf:"varint,3,opt,name=latest_block_height,json=latestBlockHeight,proto3" json:"latest_block_height,omitempty"` + LatestBlockTime time.Time `protobuf:"bytes,4,opt,name=latest_block_time,json=latestBlockTime,proto3,stdtime" json:"latest_block_time"` + EarliestBlockHash []byte `protobuf:"bytes,5,opt,name=earliest_block_hash,json=earliestBlockHash,proto3" json:"earliest_block_hash,omitempty"` + EarliestAppHash []byte `protobuf:"bytes,6,opt,name=earliest_app_hash,json=earliestAppHash,proto3" json:"earliest_app_hash,omitempty"` + EarliestBlockHeight int64 `protobuf:"varint,7,opt,name=earliest_block_height,json=earliestBlockHeight,proto3" json:"earliest_block_height,omitempty"` + EarliestBlockTime time.Time `protobuf:"bytes,8,opt,name=earliest_block_time,json=earliestBlockTime,proto3,stdtime" json:"earliest_block_time"` + CatchingUp bool `protobuf:"varint,9,opt,name=catching_up,json=catchingUp,proto3" json:"catching_up,omitempty"` +} + +func (m *SyncInfo) Reset() { *m = SyncInfo{} } +func (m *SyncInfo) String() string { return proto.CompactTextString(m) } +func (*SyncInfo) ProtoMessage() {} +func (*SyncInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{13} +} +func (m *SyncInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SyncInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SyncInfo.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 *SyncInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_SyncInfo.Merge(m, src) +} +func (m *SyncInfo) XXX_Size() int { + return m.Size() +} +func (m *SyncInfo) XXX_DiscardUnknown() { + xxx_messageInfo_SyncInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_SyncInfo proto.InternalMessageInfo + +func (m *SyncInfo) GetLatestBlockHash() []byte { + if m != nil { + return m.LatestBlockHash + } + return nil +} + +func (m *SyncInfo) GetLatestAppHash() []byte { + if m != nil { + return m.LatestAppHash + } + return nil +} + +func (m *SyncInfo) GetLatestBlockHeight() int64 { + if m != nil { + return m.LatestBlockHeight + } + return 0 +} + +func (m *SyncInfo) GetLatestBlockTime() time.Time { + if m != nil { + return m.LatestBlockTime + } + return time.Time{} +} + +func (m *SyncInfo) GetEarliestBlockHash() []byte { + if m != nil { + return m.EarliestBlockHash + } + return nil +} + +func (m *SyncInfo) GetEarliestAppHash() []byte { + if m != nil { + return m.EarliestAppHash + } + return nil +} + +func (m *SyncInfo) GetEarliestBlockHeight() int64 { + if m != nil { + return m.EarliestBlockHeight + } + return 0 +} + +func (m *SyncInfo) GetEarliestBlockTime() time.Time { + if m != nil { + return m.EarliestBlockTime + } + return time.Time{} +} + +func (m *SyncInfo) GetCatchingUp() bool { + if m != nil { + return m.CatchingUp + } + return false +} + +// ValidatorInfo is information about a validator. +type ValidatorInfo struct { + Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + PubKey *v11.PublicKey `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` + VotingPower int64 `protobuf:"varint,3,opt,name=voting_power,json=votingPower,proto3" json:"voting_power,omitempty"` +} + +func (m *ValidatorInfo) Reset() { *m = ValidatorInfo{} } +func (m *ValidatorInfo) String() string { return proto.CompactTextString(m) } +func (*ValidatorInfo) ProtoMessage() {} +func (*ValidatorInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_e521bcdb5edbf680, []int{14} +} +func (m *ValidatorInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorInfo.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 *ValidatorInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorInfo.Merge(m, src) +} +func (m *ValidatorInfo) XXX_Size() int { + return m.Size() +} +func (m *ValidatorInfo) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorInfo proto.InternalMessageInfo + +func (m *ValidatorInfo) GetAddress() []byte { + if m != nil { + return m.Address + } + return nil +} + +func (m *ValidatorInfo) GetPubKey() *v11.PublicKey { + if m != nil { + return m.PubKey + } + return nil +} + +func (m *ValidatorInfo) GetVotingPower() int64 { + if m != nil { + return m.VotingPower + } + return 0 +} + +func init() { + proto.RegisterType((*ResponseBroadcastTx)(nil), "cometbft.rpc.grpc.v1beta3.ResponseBroadcastTx") + proto.RegisterType((*BlockByHashRequest)(nil), "cometbft.rpc.grpc.v1beta3.BlockByHashRequest") + proto.RegisterType((*BlockByHeightRequest)(nil), "cometbft.rpc.grpc.v1beta3.BlockByHeightRequest") + proto.RegisterType((*CommitRequest)(nil), "cometbft.rpc.grpc.v1beta3.CommitRequest") + proto.RegisterType((*ValidatorSetRequest)(nil), "cometbft.rpc.grpc.v1beta3.ValidatorSetRequest") + proto.RegisterType((*SubscribeNewHeightsRequest)(nil), "cometbft.rpc.grpc.v1beta3.SubscribeNewHeightsRequest") + proto.RegisterType((*StatusRequest)(nil), "cometbft.rpc.grpc.v1beta3.StatusRequest") + proto.RegisterType((*StreamedBlockByHashResponse)(nil), "cometbft.rpc.grpc.v1beta3.StreamedBlockByHashResponse") + proto.RegisterType((*StreamedBlockByHeightResponse)(nil), "cometbft.rpc.grpc.v1beta3.StreamedBlockByHeightResponse") + proto.RegisterType((*CommitResponse)(nil), "cometbft.rpc.grpc.v1beta3.CommitResponse") + proto.RegisterType((*ValidatorSetResponse)(nil), "cometbft.rpc.grpc.v1beta3.ValidatorSetResponse") + proto.RegisterType((*NewHeightEvent)(nil), "cometbft.rpc.grpc.v1beta3.NewHeightEvent") + proto.RegisterType((*StatusResponse)(nil), "cometbft.rpc.grpc.v1beta3.StatusResponse") + proto.RegisterType((*SyncInfo)(nil), "cometbft.rpc.grpc.v1beta3.SyncInfo") + proto.RegisterType((*ValidatorInfo)(nil), "cometbft.rpc.grpc.v1beta3.ValidatorInfo") +} + +func init() { + proto.RegisterFile("cometbft/rpc/grpc/v1beta3/types.proto", fileDescriptor_e521bcdb5edbf680) +} + +var fileDescriptor_e521bcdb5edbf680 = []byte{ + // 1119 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x57, 0xcd, 0x6e, 0xdb, 0xc6, + 0x13, 0x37, 0xfd, 0x21, 0xcb, 0x23, 0xcb, 0x81, 0xd7, 0xfe, 0xff, 0xa3, 0x28, 0xb5, 0x9c, 0xa8, + 0xa8, 0x93, 0x06, 0x08, 0x19, 0xc9, 0xa8, 0x51, 0x14, 0x6d, 0x51, 0x7f, 0x04, 0x68, 0x90, 0x22, + 0x15, 0x68, 0xb5, 0x05, 0x0a, 0x14, 0xc4, 0x92, 0x5a, 0x4b, 0x84, 0x25, 0xed, 0x96, 0xbb, 0x64, + 0x24, 0xa0, 0xc7, 0x3e, 0x40, 0xce, 0x7d, 0x84, 0x3e, 0x49, 0x8e, 0xb9, 0x14, 0xe8, 0xa9, 0x2d, + 0xec, 0x43, 0xd0, 0xb7, 0x28, 0xb8, 0xbb, 0x24, 0x45, 0xdb, 0x92, 0x9d, 0x1e, 0x7b, 0x11, 0x96, + 0xb3, 0xb3, 0xbf, 0x9d, 0xf9, 0xcd, 0xec, 0xcc, 0x08, 0x3e, 0xf0, 0xe8, 0x80, 0x08, 0xf7, 0x44, + 0x58, 0x01, 0xf3, 0xac, 0x6e, 0xfc, 0x13, 0x35, 0x5c, 0x22, 0xf0, 0xae, 0x25, 0xc6, 0x8c, 0x70, + 0x93, 0x05, 0x54, 0x50, 0x74, 0x27, 0x51, 0x33, 0x03, 0xe6, 0x99, 0xb1, 0x9a, 0xa9, 0xd5, 0xaa, + 0x53, 0x11, 0x1a, 0x93, 0x08, 0xd5, 0xfb, 0xa9, 0x1a, 0x76, 0x3d, 0xff, 0xaa, 0x4b, 0xaa, 0x5b, + 0xa9, 0x8a, 0x94, 0x5a, 0x51, 0x33, 0xb7, 0x7d, 0x37, 0xdd, 0x66, 0x4d, 0x66, 0x45, 0x8d, 0x29, + 0x67, 0xbd, 0x60, 0xcc, 0x04, 0x8d, 0xf7, 0x4f, 0xc9, 0xf8, 0xf2, 0xed, 0x29, 0x74, 0x84, 0xfb, + 0x7e, 0x07, 0x0b, 0x1a, 0x68, 0x95, 0xed, 0x2e, 0xa5, 0xdd, 0x3e, 0xb1, 0xe4, 0x97, 0x1b, 0x9e, + 0x58, 0xc2, 0x1f, 0x10, 0x2e, 0xf0, 0x80, 0x69, 0x85, 0xcd, 0x2e, 0xed, 0x52, 0xb9, 0xb4, 0xe2, + 0x95, 0x92, 0xd6, 0x7f, 0x31, 0x60, 0xc3, 0x26, 0x9c, 0xd1, 0x21, 0x27, 0x07, 0x01, 0xc5, 0x1d, + 0x0f, 0x73, 0xd1, 0x1e, 0xa1, 0x7d, 0x28, 0x7a, 0x3d, 0xe2, 0x9d, 0x3a, 0x62, 0x54, 0x31, 0xee, + 0x19, 0x0f, 0x4b, 0xcd, 0x1d, 0x33, 0x25, 0x31, 0xa6, 0x20, 0x21, 0xd0, 0x4c, 0x4e, 0x1f, 0xc6, + 0xea, 0xed, 0x91, 0xbd, 0xec, 0xa9, 0x05, 0xfa, 0x02, 0x56, 0xc4, 0xc8, 0x09, 0x08, 0x0f, 0xfb, + 0xa2, 0x32, 0x2f, 0x31, 0xde, 0x9f, 0x82, 0xf1, 0x74, 0x44, 0xbc, 0xf6, 0xc8, 0x96, 0xaa, 0x76, + 0x51, 0xe8, 0x55, 0xfd, 0x73, 0x40, 0x07, 0x7d, 0xea, 0x9d, 0x1e, 0x8c, 0xbf, 0xc4, 0xbc, 0x67, + 0x93, 0x1f, 0x43, 0xc2, 0x05, 0x42, 0xb0, 0xd8, 0xc3, 0xbc, 0x27, 0xcd, 0x5a, 0xb5, 0xe5, 0x1a, + 0x6d, 0xc2, 0x12, 0x0b, 0x68, 0x44, 0xe4, 0x3d, 0x45, 0x5b, 0x7d, 0xd4, 0x8f, 0x60, 0x33, 0x39, + 0x4f, 0xfc, 0x6e, 0x4f, 0x24, 0x08, 0xff, 0x87, 0x42, 0x4f, 0x0a, 0x24, 0xc6, 0x82, 0xad, 0xbf, + 0xa6, 0xa0, 0x3c, 0x80, 0xf2, 0x21, 0x1d, 0x0c, 0xfc, 0xeb, 0x8e, 0xd7, 0x1f, 0xc3, 0xc6, 0xb7, + 0x49, 0x54, 0x8e, 0xc9, 0xb5, 0xea, 0xef, 0x41, 0xf5, 0x38, 0x74, 0xb9, 0x17, 0xf8, 0x2e, 0x79, + 0x41, 0x5e, 0x2a, 0x13, 0xb9, 0x3e, 0x55, 0xbf, 0x05, 0xe5, 0x63, 0x81, 0x45, 0x98, 0x0a, 0xde, + 0x1a, 0x70, 0xf7, 0x58, 0x04, 0x04, 0x0f, 0x48, 0x27, 0xc7, 0x8a, 0xa2, 0x1f, 0xed, 0x01, 0xb8, + 0xb1, 0xd8, 0x61, 0x38, 0x10, 0x3a, 0x66, 0xb7, 0x33, 0xbe, 0x55, 0xb6, 0x45, 0x4d, 0xb3, 0x85, + 0x03, 0x61, 0xaf, 0x48, 0xd5, 0x78, 0x89, 0x1a, 0x50, 0xf0, 0xa4, 0x7b, 0x3a, 0x46, 0x77, 0xae, + 0x38, 0xa3, 0xfd, 0xd7, 0x8a, 0xe8, 0x08, 0xca, 0x69, 0xfa, 0x39, 0x9c, 0x88, 0xca, 0x82, 0x3c, + 0xb9, 0x7d, 0xc5, 0xc9, 0x1c, 0x21, 0xab, 0xd1, 0xc4, 0x17, 0xba, 0x0d, 0xcb, 0x3e, 0x77, 0xfa, + 0x98, 0x8b, 0xca, 0xa2, 0xe4, 0xbb, 0xe0, 0xf3, 0xaf, 0x30, 0x17, 0xf5, 0xbf, 0x0d, 0xd8, 0xba, + 0xe8, 0xa9, 0x8e, 0xdf, 0x7f, 0xce, 0xd7, 0x43, 0x58, 0x4b, 0x92, 0x4b, 0xfb, 0x96, 0xd9, 0x68, + 0xdc, 0xd0, 0xc6, 0xba, 0x80, 0xcd, 0x7c, 0xe2, 0x69, 0xa8, 0x4b, 0xb6, 0x1b, 0xff, 0xc6, 0xf6, + 0x2c, 0x7f, 0xe7, 0x73, 0xf9, 0xfb, 0x29, 0xac, 0xa5, 0x69, 0xfb, 0x34, 0x22, 0xc3, 0xe9, 0xef, + 0x2a, 0x79, 0xb1, 0xf3, 0xd9, 0x8b, 0xad, 0x9f, 0x19, 0xb0, 0x96, 0x24, 0xb8, 0x36, 0xf7, 0x33, + 0x58, 0x19, 0xd2, 0x0e, 0x71, 0xfc, 0xe1, 0x09, 0xd5, 0xa6, 0xde, 0xcb, 0x4c, 0x65, 0x4d, 0x66, + 0x46, 0x0d, 0xf3, 0x88, 0x9c, 0xe0, 0xb0, 0x2f, 0x5e, 0xd0, 0x0e, 0x79, 0x36, 0x3c, 0xa1, 0x76, + 0x71, 0xa8, 0x57, 0x71, 0xbd, 0xe1, 0xe3, 0xa1, 0xa7, 0x8e, 0x5f, 0xaa, 0x37, 0x17, 0x0b, 0xbf, + 0x79, 0x3c, 0x1e, 0x7a, 0x0a, 0x81, 0xeb, 0x15, 0xfa, 0x1a, 0xd6, 0x32, 0xbe, 0x24, 0x8c, 0x0a, + 0xf6, 0xc3, 0x19, 0x30, 0x29, 0x71, 0x12, 0x2b, 0xe3, 0x3b, 0xfe, 0xac, 0xbf, 0x5d, 0x80, 0x62, + 0x72, 0x0f, 0x7a, 0x04, 0xeb, 0x7d, 0x2c, 0x08, 0x17, 0x8e, 0xca, 0xdd, 0x89, 0x22, 0x76, 0x4b, + 0x6d, 0xc8, 0x64, 0x8f, 0x1f, 0x35, 0xda, 0x01, 0x2d, 0x72, 0x30, 0x63, 0xce, 0x04, 0x79, 0x65, + 0x25, 0xde, 0x67, 0x4c, 0xea, 0x99, 0xb0, 0x91, 0xc7, 0x54, 0xf4, 0x2f, 0x48, 0xfa, 0xd7, 0x27, + 0x51, 0x55, 0x24, 0x5a, 0x17, 0x6c, 0x88, 0x9b, 0x84, 0xcc, 0xc8, 0x52, 0xb3, 0x6a, 0xaa, 0x0e, + 0x62, 0x26, 0x1d, 0xc4, 0x6c, 0x27, 0x1d, 0xe4, 0xa0, 0xf8, 0xfa, 0x8f, 0xed, 0xb9, 0x57, 0x7f, + 0x6e, 0x1b, 0x39, 0x4b, 0xe3, 0xfd, 0xd8, 0x02, 0x82, 0x83, 0xbe, 0x7f, 0xc1, 0xaf, 0x25, 0x69, + 0xed, 0x7a, 0xb2, 0x95, 0x79, 0xf6, 0x08, 0x52, 0x61, 0xe6, 0x5b, 0x41, 0xb1, 0x90, 0x6c, 0x24, + 0xde, 0x35, 0xe1, 0x7f, 0x17, 0xb1, 0x95, 0x7f, 0xcb, 0xd2, 0xbf, 0x8d, 0x3c, 0xba, 0xf2, 0xb0, + 0x7d, 0xc9, 0x1e, 0xe9, 0x63, 0xf1, 0x1d, 0x7c, 0xcc, 0x5b, 0x2d, 0xbd, 0xdc, 0x86, 0x92, 0x87, + 0x85, 0xd7, 0xf3, 0x87, 0x5d, 0x27, 0x64, 0x95, 0x15, 0xf9, 0x86, 0x21, 0x11, 0x7d, 0xc3, 0xea, + 0x3f, 0x1b, 0x50, 0xce, 0xa5, 0x02, 0xaa, 0xc0, 0x32, 0xee, 0x74, 0x02, 0xc2, 0xb9, 0x0e, 0x72, + 0xf2, 0x89, 0xf6, 0x60, 0x99, 0x85, 0xae, 0x73, 0x4a, 0xc6, 0x3a, 0x4d, 0xb7, 0xb2, 0xfc, 0x52, + 0xed, 0x3f, 0x4e, 0xf4, 0x56, 0xe8, 0xf6, 0x7d, 0xef, 0x39, 0x19, 0xdb, 0x05, 0x16, 0xba, 0xcf, + 0xc9, 0x18, 0xdd, 0x87, 0xd5, 0x88, 0x8a, 0xd8, 0x04, 0x46, 0x5f, 0x92, 0x40, 0x47, 0xb9, 0xa4, + 0x64, 0xad, 0x58, 0xd4, 0xfc, 0xcd, 0x80, 0xd5, 0xb4, 0x8d, 0xef, 0xb7, 0x9e, 0xa1, 0xef, 0x60, + 0xb1, 0xe5, 0x0f, 0xbb, 0x68, 0x67, 0x6a, 0x0a, 0x37, 0x4c, 0xdd, 0x61, 0x62, 0xbd, 0xea, 0x83, + 0x99, 0x7a, 0xea, 0xa1, 0x4a, 0xc0, 0x3e, 0x94, 0x26, 0xe7, 0x85, 0xc7, 0xd7, 0xe3, 0x4f, 0xa8, + 0x57, 0xcd, 0x19, 0x2f, 0xea, 0x8a, 0x71, 0xa4, 0xf9, 0xeb, 0x12, 0x14, 0x65, 0x34, 0x62, 0x9f, + 0x22, 0x28, 0x4d, 0x34, 0xc0, 0x19, 0x57, 0xef, 0x9a, 0x97, 0xc7, 0x87, 0xea, 0xde, 0xac, 0x9a, + 0x30, 0xbd, 0xbf, 0x3e, 0x31, 0xd0, 0x4f, 0x50, 0xce, 0xb5, 0x23, 0x64, 0xdd, 0xe0, 0xe6, 0xc9, + 0xc1, 0xa3, 0xfa, 0xf1, 0x3b, 0xdc, 0x9d, 0xeb, 0x78, 0x4f, 0x0c, 0xf4, 0x03, 0x14, 0x54, 0xd9, + 0x47, 0xb3, 0xca, 0x51, 0x6e, 0x52, 0xa9, 0x7e, 0x78, 0x03, 0x4d, 0x5d, 0x7c, 0x29, 0xac, 0x4e, + 0xf6, 0x00, 0x64, 0xde, 0xa4, 0xe6, 0x65, 0x53, 0x4e, 0xd5, 0xba, 0xb1, 0xbe, 0xbe, 0x70, 0x0c, + 0x1b, 0x57, 0x8c, 0x3f, 0xe8, 0xa3, 0x59, 0x14, 0x4d, 0x1d, 0x97, 0x66, 0x7a, 0x9a, 0xef, 0x52, + 0x8a, 0x4a, 0xd5, 0x7a, 0x66, 0x52, 0x99, 0x1b, 0xbf, 0x66, 0x5e, 0x90, 0xef, 0x63, 0x07, 0xed, + 0xd7, 0x67, 0x35, 0xe3, 0xcd, 0x59, 0xcd, 0xf8, 0xeb, 0xac, 0x66, 0xbc, 0x3a, 0xaf, 0xcd, 0xbd, + 0x39, 0xaf, 0xcd, 0xfd, 0x7e, 0x5e, 0x9b, 0xfb, 0xfe, 0x93, 0xae, 0x2f, 0x7a, 0xa1, 0x1b, 0x43, + 0x59, 0xd9, 0xc4, 0x9f, 0xfe, 0xb3, 0x60, 0xbe, 0x35, 0xf5, 0xff, 0x8c, 0x5b, 0x90, 0x35, 0x6b, + 0xf7, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe3, 0x64, 0x28, 0x80, 0xf3, 0x0c, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// BroadcastAPIClient is the client API for BroadcastAPI service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type BroadcastAPIClient interface { + // Ping the connection. + Ping(ctx context.Context, in *v1beta1.RequestPing, opts ...grpc.CallOption) (*v1beta1.ResponsePing, error) + // BroadcastTx broadcasts a transaction. + BroadcastTx(ctx context.Context, in *v1beta1.RequestBroadcastTx, opts ...grpc.CallOption) (*ResponseBroadcastTx, error) +} + +type broadcastAPIClient struct { + cc grpc1.ClientConn +} + +func NewBroadcastAPIClient(cc grpc1.ClientConn) BroadcastAPIClient { + return &broadcastAPIClient{cc} +} + +func (c *broadcastAPIClient) Ping(ctx context.Context, in *v1beta1.RequestPing, opts ...grpc.CallOption) (*v1beta1.ResponsePing, error) { + out := new(v1beta1.ResponsePing) + err := c.cc.Invoke(ctx, "/cometbft.rpc.grpc.v1beta3.BroadcastAPI/Ping", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *broadcastAPIClient) BroadcastTx(ctx context.Context, in *v1beta1.RequestBroadcastTx, opts ...grpc.CallOption) (*ResponseBroadcastTx, error) { + out := new(ResponseBroadcastTx) + err := c.cc.Invoke(ctx, "/cometbft.rpc.grpc.v1beta3.BroadcastAPI/BroadcastTx", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// BroadcastAPIServer is the server API for BroadcastAPI service. +type BroadcastAPIServer interface { + // Ping the connection. + Ping(context.Context, *v1beta1.RequestPing) (*v1beta1.ResponsePing, error) + // BroadcastTx broadcasts a transaction. + BroadcastTx(context.Context, *v1beta1.RequestBroadcastTx) (*ResponseBroadcastTx, error) +} + +// UnimplementedBroadcastAPIServer can be embedded to have forward compatible implementations. +type UnimplementedBroadcastAPIServer struct { +} + +func (*UnimplementedBroadcastAPIServer) Ping(ctx context.Context, req *v1beta1.RequestPing) (*v1beta1.ResponsePing, error) { + return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented") +} +func (*UnimplementedBroadcastAPIServer) BroadcastTx(ctx context.Context, req *v1beta1.RequestBroadcastTx) (*ResponseBroadcastTx, error) { + return nil, status.Errorf(codes.Unimplemented, "method BroadcastTx not implemented") +} + +func RegisterBroadcastAPIServer(s grpc1.Server, srv BroadcastAPIServer) { + s.RegisterService(&_BroadcastAPI_serviceDesc, srv) +} + +func _BroadcastAPI_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(v1beta1.RequestPing) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(BroadcastAPIServer).Ping(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cometbft.rpc.grpc.v1beta3.BroadcastAPI/Ping", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(BroadcastAPIServer).Ping(ctx, req.(*v1beta1.RequestPing)) + } + return interceptor(ctx, in, info, handler) +} + +func _BroadcastAPI_BroadcastTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(v1beta1.RequestBroadcastTx) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(BroadcastAPIServer).BroadcastTx(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cometbft.rpc.grpc.v1beta3.BroadcastAPI/BroadcastTx", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(BroadcastAPIServer).BroadcastTx(ctx, req.(*v1beta1.RequestBroadcastTx)) + } + return interceptor(ctx, in, info, handler) +} + +var BroadcastAPI_serviceDesc = _BroadcastAPI_serviceDesc +var _BroadcastAPI_serviceDesc = grpc.ServiceDesc{ + ServiceName: "cometbft.rpc.grpc.v1beta3.BroadcastAPI", + HandlerType: (*BroadcastAPIServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Ping", + Handler: _BroadcastAPI_Ping_Handler, + }, + { + MethodName: "BroadcastTx", + Handler: _BroadcastAPI_BroadcastTx_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "cometbft/rpc/grpc/v1beta3/types.proto", +} + +// BlockAPIClient is the client API for BlockAPI service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type BlockAPIClient interface { + // BlockByHash returns a block by its hash. + BlockByHash(ctx context.Context, in *BlockByHashRequest, opts ...grpc.CallOption) (BlockAPI_BlockByHashClient, error) + // BlockByHeight returns a block by its height. + BlockByHeight(ctx context.Context, in *BlockByHeightRequest, opts ...grpc.CallOption) (BlockAPI_BlockByHeightClient, error) + // Commit returns the commit of a block. + Commit(ctx context.Context, in *CommitRequest, opts ...grpc.CallOption) (*CommitResponse, error) + // ValidatorSet returns the validator set of a block. + ValidatorSet(ctx context.Context, in *ValidatorSetRequest, opts ...grpc.CallOption) (*ValidatorSetResponse, error) + // SubscribeNewHeights subscribes to new heights. + SubscribeNewHeights(ctx context.Context, in *SubscribeNewHeightsRequest, opts ...grpc.CallOption) (BlockAPI_SubscribeNewHeightsClient, error) + // Status returns the status of the node. + Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) +} + +type blockAPIClient struct { + cc grpc1.ClientConn +} + +func NewBlockAPIClient(cc grpc1.ClientConn) BlockAPIClient { + return &blockAPIClient{cc} +} + +func (c *blockAPIClient) BlockByHash(ctx context.Context, in *BlockByHashRequest, opts ...grpc.CallOption) (BlockAPI_BlockByHashClient, error) { + stream, err := c.cc.NewStream(ctx, &_BlockAPI_serviceDesc.Streams[0], "/cometbft.rpc.grpc.v1beta3.BlockAPI/BlockByHash", opts...) + if err != nil { + return nil, err + } + x := &blockAPIBlockByHashClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type BlockAPI_BlockByHashClient interface { + Recv() (*StreamedBlockByHashResponse, error) + grpc.ClientStream +} + +type blockAPIBlockByHashClient struct { + grpc.ClientStream +} + +func (x *blockAPIBlockByHashClient) Recv() (*StreamedBlockByHashResponse, error) { + m := new(StreamedBlockByHashResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *blockAPIClient) BlockByHeight(ctx context.Context, in *BlockByHeightRequest, opts ...grpc.CallOption) (BlockAPI_BlockByHeightClient, error) { + stream, err := c.cc.NewStream(ctx, &_BlockAPI_serviceDesc.Streams[1], "/cometbft.rpc.grpc.v1beta3.BlockAPI/BlockByHeight", opts...) + if err != nil { + return nil, err + } + x := &blockAPIBlockByHeightClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type BlockAPI_BlockByHeightClient interface { + Recv() (*StreamedBlockByHeightResponse, error) + grpc.ClientStream +} + +type blockAPIBlockByHeightClient struct { + grpc.ClientStream +} + +func (x *blockAPIBlockByHeightClient) Recv() (*StreamedBlockByHeightResponse, error) { + m := new(StreamedBlockByHeightResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *blockAPIClient) Commit(ctx context.Context, in *CommitRequest, opts ...grpc.CallOption) (*CommitResponse, error) { + out := new(CommitResponse) + err := c.cc.Invoke(ctx, "/cometbft.rpc.grpc.v1beta3.BlockAPI/Commit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *blockAPIClient) ValidatorSet(ctx context.Context, in *ValidatorSetRequest, opts ...grpc.CallOption) (*ValidatorSetResponse, error) { + out := new(ValidatorSetResponse) + err := c.cc.Invoke(ctx, "/cometbft.rpc.grpc.v1beta3.BlockAPI/ValidatorSet", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *blockAPIClient) SubscribeNewHeights(ctx context.Context, in *SubscribeNewHeightsRequest, opts ...grpc.CallOption) (BlockAPI_SubscribeNewHeightsClient, error) { + stream, err := c.cc.NewStream(ctx, &_BlockAPI_serviceDesc.Streams[2], "/cometbft.rpc.grpc.v1beta3.BlockAPI/SubscribeNewHeights", opts...) + if err != nil { + return nil, err + } + x := &blockAPISubscribeNewHeightsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type BlockAPI_SubscribeNewHeightsClient interface { + Recv() (*NewHeightEvent, error) + grpc.ClientStream +} + +type blockAPISubscribeNewHeightsClient struct { + grpc.ClientStream +} + +func (x *blockAPISubscribeNewHeightsClient) Recv() (*NewHeightEvent, error) { + m := new(NewHeightEvent) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *blockAPIClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) { + out := new(StatusResponse) + err := c.cc.Invoke(ctx, "/cometbft.rpc.grpc.v1beta3.BlockAPI/Status", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// BlockAPIServer is the server API for BlockAPI service. +type BlockAPIServer interface { + // BlockByHash returns a block by its hash. + BlockByHash(*BlockByHashRequest, BlockAPI_BlockByHashServer) error + // BlockByHeight returns a block by its height. + BlockByHeight(*BlockByHeightRequest, BlockAPI_BlockByHeightServer) error + // Commit returns the commit of a block. + Commit(context.Context, *CommitRequest) (*CommitResponse, error) + // ValidatorSet returns the validator set of a block. + ValidatorSet(context.Context, *ValidatorSetRequest) (*ValidatorSetResponse, error) + // SubscribeNewHeights subscribes to new heights. + SubscribeNewHeights(*SubscribeNewHeightsRequest, BlockAPI_SubscribeNewHeightsServer) error + // Status returns the status of the node. + Status(context.Context, *StatusRequest) (*StatusResponse, error) +} + +// UnimplementedBlockAPIServer can be embedded to have forward compatible implementations. +type UnimplementedBlockAPIServer struct { +} + +func (*UnimplementedBlockAPIServer) BlockByHash(req *BlockByHashRequest, srv BlockAPI_BlockByHashServer) error { + return status.Errorf(codes.Unimplemented, "method BlockByHash not implemented") +} +func (*UnimplementedBlockAPIServer) BlockByHeight(req *BlockByHeightRequest, srv BlockAPI_BlockByHeightServer) error { + return status.Errorf(codes.Unimplemented, "method BlockByHeight not implemented") +} +func (*UnimplementedBlockAPIServer) Commit(ctx context.Context, req *CommitRequest) (*CommitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Commit not implemented") +} +func (*UnimplementedBlockAPIServer) ValidatorSet(ctx context.Context, req *ValidatorSetRequest) (*ValidatorSetResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ValidatorSet not implemented") +} +func (*UnimplementedBlockAPIServer) SubscribeNewHeights(req *SubscribeNewHeightsRequest, srv BlockAPI_SubscribeNewHeightsServer) error { + return status.Errorf(codes.Unimplemented, "method SubscribeNewHeights not implemented") +} +func (*UnimplementedBlockAPIServer) Status(ctx context.Context, req *StatusRequest) (*StatusResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Status not implemented") +} + +func RegisterBlockAPIServer(s grpc1.Server, srv BlockAPIServer) { + s.RegisterService(&_BlockAPI_serviceDesc, srv) +} + +func _BlockAPI_BlockByHash_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(BlockByHashRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(BlockAPIServer).BlockByHash(m, &blockAPIBlockByHashServer{stream}) +} + +type BlockAPI_BlockByHashServer interface { + Send(*StreamedBlockByHashResponse) error + grpc.ServerStream +} + +type blockAPIBlockByHashServer struct { + grpc.ServerStream +} + +func (x *blockAPIBlockByHashServer) Send(m *StreamedBlockByHashResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _BlockAPI_BlockByHeight_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(BlockByHeightRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(BlockAPIServer).BlockByHeight(m, &blockAPIBlockByHeightServer{stream}) +} + +type BlockAPI_BlockByHeightServer interface { + Send(*StreamedBlockByHeightResponse) error + grpc.ServerStream +} + +type blockAPIBlockByHeightServer struct { + grpc.ServerStream +} + +func (x *blockAPIBlockByHeightServer) Send(m *StreamedBlockByHeightResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _BlockAPI_Commit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CommitRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(BlockAPIServer).Commit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cometbft.rpc.grpc.v1beta3.BlockAPI/Commit", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(BlockAPIServer).Commit(ctx, req.(*CommitRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _BlockAPI_ValidatorSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ValidatorSetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(BlockAPIServer).ValidatorSet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cometbft.rpc.grpc.v1beta3.BlockAPI/ValidatorSet", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(BlockAPIServer).ValidatorSet(ctx, req.(*ValidatorSetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _BlockAPI_SubscribeNewHeights_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(SubscribeNewHeightsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(BlockAPIServer).SubscribeNewHeights(m, &blockAPISubscribeNewHeightsServer{stream}) +} + +type BlockAPI_SubscribeNewHeightsServer interface { + Send(*NewHeightEvent) error + grpc.ServerStream +} + +type blockAPISubscribeNewHeightsServer struct { + grpc.ServerStream +} + +func (x *blockAPISubscribeNewHeightsServer) Send(m *NewHeightEvent) error { + return x.ServerStream.SendMsg(m) +} + +func _BlockAPI_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(BlockAPIServer).Status(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cometbft.rpc.grpc.v1beta3.BlockAPI/Status", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(BlockAPIServer).Status(ctx, req.(*StatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var BlockAPI_serviceDesc = _BlockAPI_serviceDesc +var _BlockAPI_serviceDesc = grpc.ServiceDesc{ + ServiceName: "cometbft.rpc.grpc.v1beta3.BlockAPI", + HandlerType: (*BlockAPIServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Commit", + Handler: _BlockAPI_Commit_Handler, + }, + { + MethodName: "ValidatorSet", + Handler: _BlockAPI_ValidatorSet_Handler, + }, + { + MethodName: "Status", + Handler: _BlockAPI_Status_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "BlockByHash", + Handler: _BlockAPI_BlockByHash_Handler, + ServerStreams: true, + }, + { + StreamName: "BlockByHeight", + Handler: _BlockAPI_BlockByHeight_Handler, + ServerStreams: true, + }, + { + StreamName: "SubscribeNewHeights", + Handler: _BlockAPI_SubscribeNewHeights_Handler, + ServerStreams: true, + }, + }, + Metadata: "cometbft/rpc/grpc/v1beta3/types.proto", +} + +func (m *ResponseBroadcastTx) 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 *ResponseBroadcastTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ResponseBroadcastTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TxResult != nil { + { + size, err := m.TxResult.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.CheckTx != nil { + { + size, err := m.CheckTx.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlockByHashRequest) 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 *BlockByHashRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BlockByHashRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Prove { + i-- + if m.Prove { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *BlockByHeightRequest) 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 *BlockByHeightRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BlockByHeightRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Prove { + i-- + if m.Prove { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if m.Height != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *CommitRequest) 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 *CommitRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ValidatorSetRequest) 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 *ValidatorSetRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorSetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *SubscribeNewHeightsRequest) 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 *SubscribeNewHeightsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SubscribeNewHeightsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *StatusRequest) 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 *StatusRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *StreamedBlockByHashResponse) 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 *StreamedBlockByHashResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StreamedBlockByHashResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.IsLast { + i-- + if m.IsLast { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.ValidatorSet != nil { + { + size, err := m.ValidatorSet.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Commit != nil { + { + size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.BlockPart != nil { + { + size, err := m.BlockPart.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *StreamedBlockByHeightResponse) 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 *StreamedBlockByHeightResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StreamedBlockByHeightResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.IsLast { + i-- + if m.IsLast { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.ValidatorSet != nil { + { + size, err := m.ValidatorSet.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Commit != nil { + { + size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.BlockPart != nil { + { + size, err := m.BlockPart.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CommitResponse) 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 *CommitResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CommitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Commit != nil { + { + size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValidatorSetResponse) 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 *ValidatorSetResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x10 + } + if m.ValidatorSet != nil { + { + size, err := m.ValidatorSet.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *NewHeightEvent) 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 *NewHeightEvent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NewHeightEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0x12 + } + if m.Height != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *StatusResponse) 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 *StatusResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ValidatorInfo != nil { + { + size, err := m.ValidatorInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.SyncInfo != nil { + { + size, err := m.SyncInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.NodeInfo != nil { + { + size, err := m.NodeInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *SyncInfo) 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 *SyncInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SyncInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CatchingUp { + i-- + if m.CatchingUp { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x48 + } + n14, err14 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.EarliestBlockTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.EarliestBlockTime):]) + if err14 != nil { + return 0, err14 + } + i -= n14 + i = encodeVarintTypes(dAtA, i, uint64(n14)) + i-- + dAtA[i] = 0x42 + if m.EarliestBlockHeight != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.EarliestBlockHeight)) + i-- + dAtA[i] = 0x38 + } + if len(m.EarliestAppHash) > 0 { + i -= len(m.EarliestAppHash) + copy(dAtA[i:], m.EarliestAppHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.EarliestAppHash))) + i-- + dAtA[i] = 0x32 + } + if len(m.EarliestBlockHash) > 0 { + i -= len(m.EarliestBlockHash) + copy(dAtA[i:], m.EarliestBlockHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.EarliestBlockHash))) + i-- + dAtA[i] = 0x2a + } + n15, err15 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.LatestBlockTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.LatestBlockTime):]) + if err15 != nil { + return 0, err15 + } + i -= n15 + i = encodeVarintTypes(dAtA, i, uint64(n15)) + i-- + dAtA[i] = 0x22 + if m.LatestBlockHeight != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.LatestBlockHeight)) + i-- + dAtA[i] = 0x18 + } + if len(m.LatestAppHash) > 0 { + i -= len(m.LatestAppHash) + copy(dAtA[i:], m.LatestAppHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.LatestAppHash))) + i-- + dAtA[i] = 0x12 + } + if len(m.LatestBlockHash) > 0 { + i -= len(m.LatestBlockHash) + copy(dAtA[i:], m.LatestBlockHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.LatestBlockHash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ValidatorInfo) 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 *ValidatorInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ValidatorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.VotingPower != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.VotingPower)) + i-- + dAtA[i] = 0x18 + } + if m.PubKey != nil { { - size, err := m.TxResult.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.PubKey.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { + offset -= sovTypes(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *ResponseBroadcastTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CheckTx != nil { + l = m.CheckTx.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.TxResult != nil { + l = m.TxResult.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *BlockByHashRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.Prove { + n += 2 + } + return n +} + +func (m *BlockByHeightRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + if m.Prove { + n += 2 + } + return n +} + +func (m *CommitRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + return n +} + +func (m *ValidatorSetRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + return n +} + +func (m *SubscribeNewHeightsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *StatusRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *StreamedBlockByHashResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockPart != nil { + l = m.BlockPart.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.Commit != nil { + l = m.Commit.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.ValidatorSet != nil { + l = m.ValidatorSet.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.IsLast { + n += 2 + } + return n +} + +func (m *StreamedBlockByHeightResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockPart != nil { + l = m.BlockPart.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.Commit != nil { + l = m.Commit.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.ValidatorSet != nil { + l = m.ValidatorSet.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.IsLast { + n += 2 + } + return n +} + +func (m *CommitResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Commit != nil { + l = m.Commit.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *ValidatorSetResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ValidatorSet != nil { + l = m.ValidatorSet.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + return n +} + +func (m *NewHeightEvent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *StatusResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NodeInfo != nil { + l = m.NodeInfo.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.SyncInfo != nil { + l = m.SyncInfo.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.ValidatorInfo != nil { + l = m.ValidatorInfo.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *SyncInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.LatestBlockHash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.LatestAppHash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.LatestBlockHeight != 0 { + n += 1 + sovTypes(uint64(m.LatestBlockHeight)) + } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.LatestBlockTime) + n += 1 + l + sovTypes(uint64(l)) + l = len(m.EarliestBlockHash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.EarliestAppHash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.EarliestBlockHeight != 0 { + n += 1 + sovTypes(uint64(m.EarliestBlockHeight)) + } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.EarliestBlockTime) + n += 1 + l + sovTypes(uint64(l)) + if m.CatchingUp { + n += 2 + } + return n +} + +func (m *ValidatorInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.PubKey != nil { + l = m.PubKey.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.VotingPower != 0 { + n += 1 + sovTypes(uint64(m.VotingPower)) + } + return n +} + +func sovTypes(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTypes(x uint64) (n int) { + return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ResponseBroadcastTx) 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: ResponseBroadcastTx: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseBroadcastTx: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CheckTx", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.CheckTx == nil { + m.CheckTx = &v1beta3.ResponseCheckTx{} + } + if err := m.CheckTx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TxResult", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TxResult == nil { + m.TxResult = &v1beta3.ExecTxResult{} + } + if err := m.TxResult.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + 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 *BlockByHashRequest) 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: BlockByHashRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlockByHashRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) + if m.Hash == nil { + m.Hash = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Prove", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Prove = bool(v != 0) + 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 *BlockByHeightRequest) 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: BlockByHeightRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlockByHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Prove", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Prove = bool(v != 0) + 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 *CommitRequest) 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: CommitRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + 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 *ValidatorSetRequest) 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: ValidatorSetRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorSetRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + 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 *SubscribeNewHeightsRequest) 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: SubscribeNewHeightsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SubscribeNewHeightsRequest: 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 *StatusRequest) 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: StatusRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StatusRequest: 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 *StreamedBlockByHashResponse) 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: StreamedBlockByHashResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StreamedBlockByHashResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockPart", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockPart == nil { + m.BlockPart = &v2.Part{} + } + if err := m.BlockPart.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Commit == nil { + m.Commit = &v2.Commit{} + } + if err := m.Commit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSet", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValidatorSet == nil { + m.ValidatorSet = &v2.ValidatorSet{} + } + if err := m.ValidatorSet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsLast", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsLast = bool(v != 0) + 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 *StreamedBlockByHeightResponse) 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: StreamedBlockByHeightResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StreamedBlockByHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockPart", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockPart == nil { + m.BlockPart = &v2.Part{} + } + if err := m.BlockPart.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Commit == nil { + m.Commit = &v2.Commit{} + } + if err := m.Commit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSet", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValidatorSet == nil { + m.ValidatorSet = &v2.ValidatorSet{} + } + if err := m.ValidatorSet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsLast", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsLast = bool(v != 0) + 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 *CommitResponse) 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: CommitResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Commit == nil { + m.Commit = &v2.Commit{} + } + if err := m.Commit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + 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 *ValidatorSetResponse) 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: ValidatorSetResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorSetResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSet", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValidatorSet == nil { + m.ValidatorSet = &v2.ValidatorSet{} + } + if err := m.ValidatorSet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + 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 *NewHeightEvent) 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: NewHeightEvent: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NewHeightEvent: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) + if m.Hash == nil { + m.Hash = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) if err != nil { - return 0, err + 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 *StatusResponse) 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: StatusResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NodeInfo == nil { + m.NodeInfo = &v1.DefaultNodeInfo{} + } + if err := m.NodeInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SyncInfo == nil { + m.SyncInfo = &SyncInfo{} + } + if err := m.SyncInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ValidatorInfo == nil { + m.ValidatorInfo = &ValidatorInfo{} + } + if err := m.ValidatorInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + 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 *SyncInfo) 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: SyncInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestBlockHash", 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.LatestBlockHash = append(m.LatestBlockHash[:0], dAtA[iNdEx:postIndex]...) + if m.LatestBlockHash == nil { + m.LatestBlockHash = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestAppHash", 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 } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.CheckTx != nil { - { - size, err := m.CheckTx.MarshalToSizedBuffer(dAtA[:i]) + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LatestAppHash = append(m.LatestAppHash[:0], dAtA[iNdEx:postIndex]...) + if m.LatestAppHash == nil { + m.LatestAppHash = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestBlockHeight", wireType) + } + m.LatestBlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LatestBlockHeight |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestBlockTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.LatestBlockTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EarliestBlockHash", 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.EarliestBlockHash = append(m.EarliestBlockHash[:0], dAtA[iNdEx:postIndex]...) + if m.EarliestBlockHash == nil { + m.EarliestBlockHash = []byte{} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EarliestAppHash", 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.EarliestAppHash = append(m.EarliestAppHash[:0], dAtA[iNdEx:postIndex]...) + if m.EarliestAppHash == nil { + m.EarliestAppHash = []byte{} + } + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EarliestBlockHeight", wireType) + } + m.EarliestBlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EarliestBlockHeight |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EarliestBlockTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.EarliestBlockTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CatchingUp", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CatchingUp = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) if err != nil { - return 0, err + return err } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy } - i-- - dAtA[i] = 0xa } - return len(dAtA) - i, nil -} -func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { - offset -= sovTypes(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *ResponseBroadcastTx) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.CheckTx != nil { - l = m.CheckTx.Size() - n += 1 + l + sovTypes(uint64(l)) - } - if m.TxResult != nil { - l = m.TxResult.Size() - n += 1 + l + sovTypes(uint64(l)) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n -} - -func sovTypes(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozTypes(x uint64) (n int) { - return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63)))) + return nil } -func (m *ResponseBroadcastTx) Unmarshal(dAtA []byte) error { +func (m *ValidatorInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -339,17 +4106,17 @@ func (m *ResponseBroadcastTx) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ResponseBroadcastTx: wiretype end group for non-group") + return fmt.Errorf("proto: ValidatorInfo: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseBroadcastTx: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ValidatorInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CheckTx", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -359,31 +4126,29 @@ func (m *ResponseBroadcastTx) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - if m.CheckTx == nil { - m.CheckTx = &v1beta3.ResponseCheckTx{} - } - if err := m.CheckTx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...) + if m.Address == nil { + m.Address = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TxResult", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -410,13 +4175,32 @@ func (m *ResponseBroadcastTx) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.TxResult == nil { - m.TxResult = &v1beta3.ExecTxResult{} + if m.PubKey == nil { + m.PubKey = &v11.PublicKey{} } - if err := m.TxResult.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.PubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType) + } + m.VotingPower = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.VotingPower |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) diff --git a/api/cometbft/state/v2/types.pb.go b/api/cometbft/state/v2/types.pb.go index a250f69ffef..60727e340cf 100644 --- a/api/cometbft/state/v2/types.pb.go +++ b/api/cometbft/state/v2/types.pb.go @@ -597,6 +597,79 @@ func (m *State) GetNextBlockDelay() time.Duration { return 0 } +// TxInfo describes the location of a tx inside a committed block +// as well as the result of executing the transaction and the error log output. +type TxInfo struct { + Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` + Index uint32 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` + // The response code of executing the tx. 0 means + // successfully executed, all others are error codes. + Code uint32 `protobuf:"varint,3,opt,name=code,proto3" json:"code,omitempty"` + // The error log output generated if the transaction execution fails. + Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"` +} + +func (m *TxInfo) Reset() { *m = TxInfo{} } +func (m *TxInfo) String() string { return proto.CompactTextString(m) } +func (*TxInfo) ProtoMessage() {} +func (*TxInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_c6c696255fbe933e, []int{8} +} +func (m *TxInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TxInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TxInfo.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 *TxInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_TxInfo.Merge(m, src) +} +func (m *TxInfo) XXX_Size() int { + return m.Size() +} +func (m *TxInfo) XXX_DiscardUnknown() { + xxx_messageInfo_TxInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_TxInfo proto.InternalMessageInfo + +func (m *TxInfo) GetHeight() int64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *TxInfo) GetIndex() uint32 { + if m != nil { + return m.Index + } + return 0 +} + +func (m *TxInfo) GetCode() uint32 { + if m != nil { + return m.Code + } + return 0 +} + +func (m *TxInfo) GetError() string { + if m != nil { + return m.Error + } + return "" +} + func init() { proto.RegisterType((*LegacyABCIResponses)(nil), "cometbft.state.v2.LegacyABCIResponses") proto.RegisterType((*ResponseBeginBlock)(nil), "cometbft.state.v2.ResponseBeginBlock") @@ -606,76 +679,80 @@ func init() { proto.RegisterType((*ABCIResponsesInfo)(nil), "cometbft.state.v2.ABCIResponsesInfo") proto.RegisterType((*Version)(nil), "cometbft.state.v2.Version") proto.RegisterType((*State)(nil), "cometbft.state.v2.State") + proto.RegisterType((*TxInfo)(nil), "cometbft.state.v2.TxInfo") } func init() { proto.RegisterFile("cometbft/state/v2/types.proto", fileDescriptor_c6c696255fbe933e) } var fileDescriptor_c6c696255fbe933e = []byte{ - // 1013 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xcd, 0x6e, 0xdb, 0x46, - 0x10, 0x36, 0xa3, 0xc4, 0x92, 0x46, 0xd1, 0x8f, 0x57, 0x4d, 0xc3, 0xb8, 0x8d, 0xe4, 0xa8, 0x4d, - 0x6a, 0x14, 0x05, 0x85, 0xa8, 0xb7, 0x5e, 0xd2, 0x50, 0x4a, 0x60, 0x01, 0x6e, 0x50, 0xd0, 0x6e, - 0x0e, 0xbe, 0x10, 0x2b, 0x72, 0x25, 0x2d, 0x4a, 0x91, 0x84, 0x76, 0xc5, 0xca, 0x7d, 0x80, 0x5e, - 0x9b, 0x63, 0xd1, 0x07, 0xe9, 0x33, 0xe4, 0x98, 0x5b, 0x7b, 0x72, 0x03, 0xf9, 0xd6, 0xa7, 0x28, - 0x76, 0xb9, 0xfc, 0xd1, 0x0f, 0x0a, 0x17, 0xb9, 0x91, 0x3b, 0x33, 0xdf, 0x7c, 0xf3, 0xed, 0xcc, - 0xee, 0xc2, 0x43, 0x27, 0x98, 0x11, 0x3e, 0x1a, 0xf3, 0x2e, 0xe3, 0x98, 0x93, 0x6e, 0xd4, 0xeb, - 0xf2, 0xcb, 0x90, 0x30, 0x23, 0x9c, 0x07, 0x3c, 0x40, 0x07, 0x89, 0xd9, 0x90, 0x66, 0x23, 0xea, - 0x1d, 0x7e, 0x9a, 0x46, 0xe0, 0x91, 0x43, 0x37, 0x02, 0x0e, 0x5b, 0xa9, 0x55, 0xae, 0x0a, 0x73, - 0x88, 0xe7, 0x78, 0x96, 0xd8, 0x1f, 0x6e, 0xdb, 0xf3, 0xe1, 0x8f, 0xb6, 0xcd, 0x11, 0xf6, 0xa8, - 0x8b, 0x79, 0x30, 0x57, 0x2e, 0xed, 0xd4, 0x25, 0x22, 0x73, 0x46, 0x03, 0xbf, 0x1b, 0x3d, 0x5d, - 0xc3, 0xf8, 0x68, 0x12, 0x4c, 0x02, 0xf9, 0xd9, 0x15, 0x5f, 0x49, 0xd8, 0x24, 0x08, 0x26, 0x1e, - 0xe9, 0xca, 0xbf, 0xd1, 0x62, 0xdc, 0xe5, 0x74, 0x46, 0x18, 0xc7, 0xb3, 0x30, 0x61, 0xbe, 0xe9, - 0xe0, 0x2e, 0xe6, 0x98, 0xd3, 0xc0, 0x8f, 0xed, 0x9d, 0xf7, 0x1a, 0x34, 0x4f, 0xc9, 0x04, 0x3b, - 0x97, 0xcf, 0xcd, 0xfe, 0xd0, 0x22, 0x2c, 0x0c, 0x7c, 0x46, 0x18, 0x7a, 0x06, 0x15, 0x97, 0x78, - 0x34, 0x22, 0x73, 0x9b, 0x2f, 0x99, 0xae, 0x1d, 0x15, 0x8e, 0x2b, 0xbd, 0x96, 0x91, 0x0a, 0x27, - 0x54, 0x32, 0xa2, 0x9e, 0xf1, 0x62, 0x49, 0x9c, 0xf3, 0xa5, 0x45, 0xd8, 0xc2, 0xe3, 0x16, 0xa8, - 0x90, 0xf3, 0x25, 0x43, 0xdf, 0x42, 0x99, 0xf8, 0xae, 0x3d, 0xf2, 0x02, 0xe7, 0x47, 0xfd, 0xd6, - 0x91, 0x76, 0x5c, 0xe9, 0x7d, 0x66, 0x6c, 0xe9, 0x6e, 0x24, 0x19, 0x5f, 0xf8, 0xae, 0x29, 0x5c, - 0xad, 0x12, 0x51, 0x5f, 0xe8, 0x25, 0x54, 0x46, 0x64, 0x42, 0x7d, 0x85, 0x51, 0x90, 0x18, 0x8f, - 0xff, 0x03, 0xc3, 0x14, 0xde, 0x31, 0x0a, 0x8c, 0xd2, 0xef, 0x8e, 0x0d, 0x68, 0xdb, 0x03, 0x0d, - 0x61, 0x9f, 0x44, 0xc4, 0xe7, 0x49, 0x6d, 0xf7, 0x77, 0xd4, 0x26, 0xec, 0xa6, 0xfe, 0xf6, 0xaa, - 0xbd, 0xf7, 0xcf, 0x55, 0xbb, 0x11, 0xbb, 0x7f, 0x15, 0xcc, 0x28, 0x27, 0xb3, 0x90, 0x5f, 0x5a, - 0x0a, 0xa0, 0xf3, 0xeb, 0x2d, 0x68, 0x6c, 0xd6, 0x81, 0xce, 0xe1, 0x20, 0xdd, 0x63, 0x7b, 0x11, - 0xba, 0x98, 0x93, 0x24, 0xd5, 0xa3, 0xed, 0x54, 0xaf, 0x13, 0xd7, 0x1f, 0xa4, 0xa7, 0x79, 0x5b, - 0x24, 0xb5, 0x1a, 0xd1, 0xfa, 0x32, 0x43, 0x17, 0x70, 0xdf, 0x11, 0x69, 0x7c, 0xb6, 0x60, 0xb6, - 0x6c, 0xc1, 0x14, 0x3b, 0xd6, 0xb8, 0x93, 0x61, 0xc7, 0xdd, 0x13, 0xf5, 0x8c, 0x7e, 0x12, 0xf1, - 0xbd, 0xec, 0x59, 0xeb, 0x9e, 0xb3, 0xb6, 0x90, 0x60, 0x67, 0x8a, 0x14, 0x3e, 0x54, 0x91, 0x5f, - 0x34, 0xa8, 0xa5, 0x25, 0xb1, 0xa1, 0x3f, 0x0e, 0xd0, 0x00, 0xaa, 0x99, 0x1e, 0x8c, 0x70, 0x5d, - 0x93, 0x7c, 0xdb, 0x3b, 0xf8, 0xa6, 0x91, 0x67, 0x84, 0x5b, 0x77, 0xa3, 0xdc, 0x1f, 0x32, 0xa0, - 0xe9, 0x61, 0xc6, 0xed, 0x29, 0xa1, 0x93, 0x29, 0xb7, 0x9d, 0x29, 0xf6, 0x27, 0xc4, 0x95, 0xb5, - 0x17, 0xac, 0x03, 0x61, 0x3a, 0x91, 0x96, 0x7e, 0x6c, 0xe8, 0xfc, 0xae, 0x41, 0x73, 0xa3, 0x7c, - 0xc9, 0xe6, 0x0c, 0x1a, 0x1b, 0x3a, 0x32, 0x45, 0xe8, 0x06, 0x02, 0xaa, 0xdd, 0xa9, 0xaf, 0xcb, - 0xc8, 0xfe, 0x37, 0xb9, 0x3f, 0x35, 0x38, 0x58, 0x9b, 0x3a, 0x49, 0xed, 0x02, 0xee, 0x79, 0x72, - 0x20, 0x6d, 0xa1, 0xba, 0x3d, 0x4f, 0x8c, 0x8a, 0xdf, 0x93, 0x1d, 0x03, 0xb0, 0x63, 0x80, 0xad, - 0x66, 0x0c, 0xf2, 0x7c, 0xe4, 0xd0, 0x6c, 0xaa, 0x3f, 0x86, 0xfd, 0x98, 0x9c, 0x22, 0xa5, 0xfe, - 0xd0, 0x2b, 0xa8, 0x8d, 0xa9, 0x8f, 0x3d, 0xfa, 0x33, 0x59, 0x9b, 0xb6, 0x2f, 0xb6, 0x5b, 0xe0, - 0xa5, 0xf2, 0x8b, 0xe7, 0x4c, 0x21, 0x5b, 0xd5, 0x71, 0x7e, 0xb9, 0x43, 0xa1, 0xf8, 0x3a, 0x3e, - 0xc6, 0x90, 0x09, 0xe5, 0x54, 0x27, 0x55, 0x42, 0xee, 0x18, 0x51, 0x87, 0x9d, 0x11, 0x3d, 0xcd, - 0x44, 0x56, 0xf2, 0x66, 0x61, 0xe8, 0x10, 0x4a, 0x2c, 0x18, 0xf3, 0x9f, 0xf0, 0x9c, 0x48, 0xe2, - 0x65, 0x2b, 0xfd, 0xef, 0xfc, 0x51, 0x84, 0x3b, 0x67, 0x42, 0x08, 0xf4, 0x0d, 0x14, 0x15, 0x9c, - 0xca, 0x73, 0xb8, 0x43, 0x2a, 0x45, 0x4b, 0xe5, 0x48, 0x02, 0xd0, 0x13, 0x28, 0x39, 0x53, 0x4c, - 0x7d, 0x9b, 0xc6, 0xfb, 0x55, 0x36, 0x2b, 0xab, 0xab, 0x76, 0xb1, 0x2f, 0xd6, 0x86, 0x03, 0xab, - 0x28, 0x8d, 0x43, 0x17, 0x3d, 0x86, 0x1a, 0xf5, 0x29, 0xa7, 0xd8, 0x53, 0xbb, 0xac, 0xd7, 0xa4, - 0x90, 0x55, 0xb5, 0x1a, 0x6f, 0x30, 0xfa, 0x12, 0xe4, 0x76, 0xc7, 0x5a, 0x26, 0x9e, 0x05, 0xe9, - 0x59, 0x17, 0x06, 0xa9, 0x92, 0xf2, 0x3d, 0x83, 0x6a, 0xce, 0x97, 0xba, 0xfa, 0xed, 0x4d, 0xf2, - 0x69, 0x1f, 0xca, 0xb0, 0xe1, 0xc0, 0x6c, 0x0a, 0xf2, 0xab, 0xab, 0x76, 0xe5, 0x34, 0xc1, 0x1a, - 0x0e, 0xac, 0x4a, 0x0a, 0x3c, 0x74, 0xd1, 0x29, 0xd4, 0x73, 0xa0, 0xe2, 0x52, 0xd0, 0xef, 0x28, - 0xd8, 0xf8, 0x42, 0x30, 0x92, 0x0b, 0xc1, 0x38, 0x4f, 0x6e, 0x0c, 0xb3, 0x24, 0x60, 0xdf, 0xfc, - 0xdd, 0xd6, 0xac, 0x6a, 0x8a, 0x25, 0xac, 0xe8, 0x04, 0xea, 0x3e, 0x59, 0x72, 0x3b, 0x1d, 0x45, - 0xa6, 0xef, 0xdf, 0x6c, 0x7a, 0x6b, 0x22, 0x2e, 0x3b, 0x09, 0xd0, 0x33, 0x80, 0x1c, 0x48, 0xf1, - 0x66, 0x20, 0xb9, 0x10, 0x41, 0x45, 0x16, 0x96, 0x43, 0x29, 0xdd, 0x90, 0x8a, 0x88, 0xcb, 0x51, - 0xe9, 0x43, 0x2b, 0x3f, 0xad, 0x19, 0x60, 0x3a, 0xb8, 0x65, 0xb9, 0x61, 0x9f, 0x64, 0x83, 0x9b, - 0x45, 0xab, 0x11, 0xde, 0x79, 0x8e, 0xc0, 0x87, 0x9e, 0x23, 0xaf, 0xe0, 0xf3, 0xb5, 0x73, 0x64, - 0x23, 0x41, 0xca, 0xaf, 0x22, 0xf9, 0x1d, 0xe5, 0x0e, 0x96, 0x75, 0xa0, 0x84, 0x64, 0xd2, 0x8d, - 0x73, 0x79, 0x4b, 0x33, 0x7b, 0x8a, 0xd9, 0x54, 0xbf, 0x7b, 0xa4, 0x1d, 0xdf, 0x8d, 0xbb, 0x31, - 0xbe, 0xbd, 0xd9, 0x09, 0x66, 0x53, 0xf4, 0x00, 0x4a, 0x38, 0x0c, 0x63, 0x97, 0xaa, 0x74, 0x29, - 0xe2, 0x30, 0x94, 0xa6, 0xef, 0xa0, 0x21, 0xbb, 0x20, 0xee, 0x29, 0x97, 0x78, 0xf8, 0x52, 0xaf, - 0xcb, 0x5a, 0x1f, 0x6c, 0x35, 0xd5, 0x40, 0xbd, 0x32, 0xe2, 0x9e, 0xfa, 0x4d, 0xf4, 0x94, 0x6c, - 0x05, 0xd9, 0x53, 0x03, 0x11, 0x6a, 0x9e, 0xbe, 0x5d, 0xb5, 0xb4, 0x77, 0xab, 0x96, 0xf6, 0x7e, - 0xd5, 0xd2, 0xde, 0x5c, 0xb7, 0xf6, 0xde, 0x5d, 0xb7, 0xf6, 0xfe, 0xba, 0x6e, 0xed, 0x5d, 0xf4, - 0x26, 0x94, 0x4f, 0x17, 0x23, 0x21, 0x60, 0x37, 0x7d, 0x16, 0x65, 0xef, 0xb3, 0x90, 0x76, 0xb7, - 0x9e, 0x77, 0xa3, 0x7d, 0x99, 0xfa, 0xeb, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x2d, 0x7a, 0x66, - 0xcf, 0xfa, 0x09, 0x00, 0x00, + // 1060 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4b, 0x6f, 0xdb, 0x46, + 0x10, 0x36, 0xe3, 0x87, 0xa4, 0x91, 0xe5, 0xc7, 0x3a, 0x69, 0x14, 0xb7, 0x91, 0x1c, 0xb5, 0x49, + 0x8d, 0xa2, 0xa0, 0x10, 0xf5, 0xd6, 0x4b, 0x1a, 0x5a, 0x09, 0x2c, 0xc0, 0x0d, 0x0a, 0xda, 0xcd, + 0xc1, 0x17, 0x76, 0x45, 0xae, 0xa4, 0x45, 0x29, 0x92, 0xe0, 0xae, 0x58, 0xb9, 0x3f, 0xa0, 0xd7, + 0xe6, 0x58, 0xf4, 0x87, 0xf4, 0x37, 0xe4, 0x98, 0x5b, 0x7b, 0x72, 0x03, 0xf9, 0xd6, 0x5f, 0x51, + 0xec, 0x83, 0x0f, 0x3d, 0x50, 0xb8, 0xc8, 0x8d, 0xbb, 0x33, 0xf3, 0xed, 0x37, 0xdf, 0xce, 0xcc, + 0x12, 0x1e, 0xba, 0xe1, 0x98, 0xf0, 0xfe, 0x80, 0xb7, 0x19, 0xc7, 0x9c, 0xb4, 0x93, 0x4e, 0x9b, + 0x5f, 0x45, 0x84, 0x99, 0x51, 0x1c, 0xf2, 0x10, 0xed, 0xa7, 0x66, 0x53, 0x9a, 0xcd, 0xa4, 0x73, + 0xf8, 0x49, 0x16, 0x81, 0xfb, 0x2e, 0x5d, 0x08, 0x38, 0x6c, 0x64, 0x56, 0xb9, 0x2b, 0xcc, 0x11, + 0x8e, 0xf1, 0x38, 0xb5, 0x3f, 0x5c, 0xb6, 0x17, 0xc3, 0x1f, 0x2d, 0x9b, 0x13, 0xec, 0x53, 0x0f, + 0xf3, 0x30, 0xd6, 0x2e, 0xcd, 0xcc, 0x25, 0x21, 0x31, 0xa3, 0x61, 0xd0, 0x4e, 0x9e, 0xce, 0x61, + 0xdc, 0x1d, 0x86, 0xc3, 0x50, 0x7e, 0xb6, 0xc5, 0x57, 0x1a, 0x36, 0x0c, 0xc3, 0xa1, 0x4f, 0xda, + 0x72, 0xd5, 0x9f, 0x0c, 0xda, 0x9c, 0x8e, 0x09, 0xe3, 0x78, 0x1c, 0xa5, 0xcc, 0x17, 0x1d, 0xbc, + 0x49, 0x8c, 0x39, 0x0d, 0x03, 0x65, 0x6f, 0xbd, 0x37, 0xe0, 0xe0, 0x8c, 0x0c, 0xb1, 0x7b, 0xf5, + 0xdc, 0x3a, 0xe9, 0xd9, 0x84, 0x45, 0x61, 0xc0, 0x08, 0x43, 0xcf, 0xa0, 0xea, 0x11, 0x9f, 0x26, + 0x24, 0x76, 0xf8, 0x94, 0xd5, 0x8d, 0xa3, 0xf5, 0xe3, 0x6a, 0xa7, 0x61, 0x66, 0xc2, 0x09, 0x95, + 0xcc, 0xa4, 0x63, 0xbe, 0x98, 0x12, 0xf7, 0x62, 0x6a, 0x13, 0x36, 0xf1, 0xb9, 0x0d, 0x3a, 0xe4, + 0x62, 0xca, 0xd0, 0x37, 0x50, 0x21, 0x81, 0xe7, 0xf4, 0xfd, 0xd0, 0xfd, 0xb1, 0x7e, 0xe7, 0xc8, + 0x38, 0xae, 0x76, 0x3e, 0x35, 0x97, 0x74, 0x37, 0xd3, 0x13, 0x5f, 0x04, 0x9e, 0x25, 0x5c, 0xed, + 0x32, 0xd1, 0x5f, 0xe8, 0x25, 0x54, 0xfb, 0x64, 0x48, 0x03, 0x8d, 0xb1, 0x2e, 0x31, 0x1e, 0xff, + 0x07, 0x86, 0x25, 0xbc, 0x15, 0x0a, 0xf4, 0xb3, 0xef, 0x96, 0x03, 0x68, 0xd9, 0x03, 0xf5, 0x60, + 0x8b, 0x24, 0x24, 0xe0, 0x69, 0x6e, 0xf7, 0x57, 0xe4, 0x26, 0xec, 0x56, 0xfd, 0xed, 0x75, 0x73, + 0xed, 0x9f, 0xeb, 0xe6, 0x9e, 0x72, 0xff, 0x32, 0x1c, 0x53, 0x4e, 0xc6, 0x11, 0xbf, 0xb2, 0x35, + 0x40, 0xeb, 0xd7, 0x3b, 0xb0, 0xb7, 0x98, 0x07, 0xba, 0x80, 0xfd, 0xec, 0x8e, 0x9d, 0x49, 0xe4, + 0x61, 0x4e, 0xd2, 0xa3, 0x1e, 0x2d, 0x1f, 0xf5, 0x3a, 0x75, 0xfd, 0x5e, 0x7a, 0x5a, 0x1b, 0xe2, + 0x50, 0x7b, 0x2f, 0x99, 0xdf, 0x66, 0xe8, 0x12, 0xee, 0xbb, 0xe2, 0x98, 0x80, 0x4d, 0x98, 0x23, + 0x4b, 0x30, 0xc3, 0x56, 0x1a, 0xb7, 0x72, 0x6c, 0x55, 0x3d, 0x49, 0xc7, 0x3c, 0x49, 0x23, 0xbe, + 0x93, 0x35, 0x6b, 0xdf, 0x73, 0xe7, 0x36, 0x52, 0xec, 0x5c, 0x91, 0xf5, 0x0f, 0x55, 0xe4, 0x17, + 0x03, 0x76, 0xb2, 0x94, 0x58, 0x2f, 0x18, 0x84, 0xa8, 0x0b, 0xb5, 0x5c, 0x0f, 0x46, 0x78, 0xdd, + 0x90, 0x7c, 0x9b, 0x2b, 0xf8, 0x66, 0x91, 0xe7, 0x84, 0xdb, 0xdb, 0x49, 0x61, 0x85, 0x4c, 0x38, + 0xf0, 0x31, 0xe3, 0xce, 0x88, 0xd0, 0xe1, 0x88, 0x3b, 0xee, 0x08, 0x07, 0x43, 0xe2, 0xc9, 0xdc, + 0xd7, 0xed, 0x7d, 0x61, 0x3a, 0x95, 0x96, 0x13, 0x65, 0x68, 0xfd, 0x6e, 0xc0, 0xc1, 0x42, 0xfa, + 0x92, 0xcd, 0x39, 0xec, 0x2d, 0xe8, 0xc8, 0x34, 0xa1, 0x5b, 0x08, 0xa8, 0x6f, 0x67, 0x77, 0x5e, + 0x46, 0xf6, 0xbf, 0xc9, 0xfd, 0x69, 0xc0, 0xfe, 0x5c, 0xd7, 0x49, 0x6a, 0x97, 0x70, 0xcf, 0x97, + 0x0d, 0xe9, 0x08, 0xd5, 0x9d, 0x38, 0x35, 0x6a, 0x7e, 0x4f, 0x56, 0x34, 0xc0, 0x8a, 0x06, 0xb6, + 0x0f, 0x14, 0xc8, 0xf3, 0xbe, 0x4b, 0xf3, 0xae, 0xfe, 0x08, 0xb6, 0x14, 0x39, 0x4d, 0x4a, 0xaf, + 0xd0, 0x2b, 0xd8, 0x19, 0xd0, 0x00, 0xfb, 0xf4, 0x67, 0x32, 0xd7, 0x6d, 0x9f, 0x2f, 0x97, 0xc0, + 0x4b, 0xed, 0xa7, 0xfa, 0x4c, 0x23, 0xdb, 0xb5, 0x41, 0x71, 0xbb, 0x45, 0xa1, 0xf4, 0x5a, 0x8d, + 0x31, 0x64, 0x41, 0x25, 0xd3, 0x49, 0xa7, 0x50, 0x18, 0x23, 0x7a, 0xd8, 0x99, 0xc9, 0xd3, 0x5c, + 0x64, 0x2d, 0x6f, 0x1e, 0x86, 0x0e, 0xa1, 0xcc, 0xc2, 0x01, 0xff, 0x09, 0xc7, 0x44, 0x12, 0xaf, + 0xd8, 0xd9, 0xba, 0xf5, 0x47, 0x09, 0x36, 0xcf, 0x85, 0x10, 0xe8, 0x6b, 0x28, 0x69, 0x38, 0x7d, + 0xce, 0xe1, 0x0a, 0xa9, 0x34, 0x2d, 0x7d, 0x46, 0x1a, 0x80, 0x9e, 0x40, 0xd9, 0x1d, 0x61, 0x1a, + 0x38, 0x54, 0xdd, 0x57, 0xc5, 0xaa, 0xce, 0xae, 0x9b, 0xa5, 0x13, 0xb1, 0xd7, 0xeb, 0xda, 0x25, + 0x69, 0xec, 0x79, 0xe8, 0x31, 0xec, 0xd0, 0x80, 0x72, 0x8a, 0x7d, 0x7d, 0xcb, 0xf5, 0x1d, 0x29, + 0x64, 0x4d, 0xef, 0xaa, 0x0b, 0x46, 0x5f, 0x80, 0xbc, 0x6e, 0xa5, 0x65, 0xea, 0xb9, 0x2e, 0x3d, + 0x77, 0x85, 0x41, 0xaa, 0xa4, 0x7d, 0xcf, 0xa1, 0x56, 0xf0, 0xa5, 0x5e, 0x7d, 0x63, 0x91, 0x7c, + 0x56, 0x87, 0x32, 0xac, 0xd7, 0xb5, 0x0e, 0x04, 0xf9, 0xd9, 0x75, 0xb3, 0x7a, 0x96, 0x62, 0xf5, + 0xba, 0x76, 0x35, 0x03, 0xee, 0x79, 0xe8, 0x0c, 0x76, 0x0b, 0xa0, 0xe2, 0x51, 0xa8, 0x6f, 0x6a, + 0x58, 0xf5, 0x20, 0x98, 0xe9, 0x83, 0x60, 0x5e, 0xa4, 0x2f, 0x86, 0x55, 0x16, 0xb0, 0x6f, 0xfe, + 0x6e, 0x1a, 0x76, 0x2d, 0xc3, 0x12, 0x56, 0x74, 0x0a, 0xbb, 0x01, 0x99, 0x72, 0x27, 0x6b, 0x45, + 0x56, 0xdf, 0xba, 0x5d, 0xf7, 0xee, 0x88, 0xb8, 0x7c, 0x12, 0xa0, 0x67, 0x00, 0x05, 0x90, 0xd2, + 0xed, 0x40, 0x0a, 0x21, 0x82, 0x8a, 0x4c, 0xac, 0x80, 0x52, 0xbe, 0x25, 0x15, 0x11, 0x57, 0xa0, + 0x72, 0x02, 0x8d, 0x62, 0xb7, 0xe6, 0x80, 0x59, 0xe3, 0x56, 0xe4, 0x85, 0x7d, 0x9c, 0x37, 0x6e, + 0x1e, 0xad, 0x5b, 0x78, 0xe5, 0x1c, 0x81, 0x0f, 0x9d, 0x23, 0xaf, 0xe0, 0xb3, 0xb9, 0x39, 0xb2, + 0x70, 0x40, 0xc6, 0xaf, 0x2a, 0xf9, 0x1d, 0x15, 0x06, 0xcb, 0x3c, 0x50, 0x4a, 0x32, 0xad, 0xc6, + 0x58, 0xbe, 0xd2, 0xcc, 0x19, 0x61, 0x36, 0xaa, 0x6f, 0x1f, 0x19, 0xc7, 0xdb, 0xaa, 0x1a, 0xd5, + 0xeb, 0xcd, 0x4e, 0x31, 0x1b, 0xa1, 0x07, 0x50, 0xc6, 0x51, 0xa4, 0x5c, 0x6a, 0xd2, 0xa5, 0x84, + 0xa3, 0x48, 0x9a, 0xbe, 0x85, 0x3d, 0x59, 0x05, 0xaa, 0xa6, 0x3c, 0xe2, 0xe3, 0xab, 0xfa, 0xae, + 0xcc, 0xf5, 0xc1, 0x52, 0x51, 0x75, 0xf5, 0x5f, 0x86, 0xaa, 0xa9, 0xdf, 0x44, 0x4d, 0xc9, 0x52, + 0x90, 0x35, 0xd5, 0x15, 0xa1, 0xad, 0x1f, 0x60, 0xeb, 0x62, 0x2a, 0x27, 0x5e, 0x3e, 0x95, 0x8c, + 0xb9, 0xa9, 0x74, 0x17, 0x36, 0x69, 0xe0, 0x91, 0xa9, 0xec, 0xc8, 0x9a, 0xad, 0x16, 0x08, 0xc1, + 0x86, 0x1b, 0x7a, 0x44, 0xb6, 0x53, 0xcd, 0x96, 0xdf, 0xc2, 0x93, 0xc4, 0x71, 0x18, 0xcb, 0xde, + 0xa9, 0xd8, 0x6a, 0x61, 0x9d, 0xbd, 0x9d, 0x35, 0x8c, 0x77, 0xb3, 0x86, 0xf1, 0x7e, 0xd6, 0x30, + 0xde, 0xdc, 0x34, 0xd6, 0xde, 0xdd, 0x34, 0xd6, 0xfe, 0xba, 0x69, 0xac, 0x5d, 0x76, 0x86, 0x94, + 0x8f, 0x26, 0x7d, 0x71, 0x45, 0xed, 0xec, 0xc7, 0x2b, 0xff, 0x03, 0x8c, 0x68, 0x7b, 0xe9, 0x07, + 0xb2, 0xbf, 0x25, 0x93, 0xfb, 0xea, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4a, 0x2b, 0xae, 0x92, + 0x5c, 0x0a, 0x00, 0x00, } func (m *LegacyABCIResponses) Marshal() (dAtA []byte, err error) { @@ -1155,6 +1232,51 @@ func (m *State) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *TxInfo) 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 *TxInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TxInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Error) > 0 { + i -= len(m.Error) + copy(dAtA[i:], m.Error) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Error))) + i-- + dAtA[i] = 0x22 + } + if m.Code != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Code)) + i-- + dAtA[i] = 0x18 + } + if m.Index != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x10 + } + if m.Height != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { offset -= sovTypes(v) base := offset @@ -1349,6 +1471,28 @@ func (m *State) Size() (n int) { return n } +func (m *TxInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + if m.Index != 0 { + n += 1 + sovTypes(uint64(m.Index)) + } + if m.Code != 0 { + n += 1 + sovTypes(uint64(m.Code)) + } + l = len(m.Error) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + func sovTypes(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -2711,6 +2855,145 @@ func (m *State) Unmarshal(dAtA []byte) error { } return nil } +func (m *TxInfo) 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: TxInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TxInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + } + m.Code = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Code |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Error = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTypes(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/api/cometbft/types/v2/types.pb.go b/api/cometbft/types/v2/types.pb.go index af501b39e2f..68da659d7f8 100644 --- a/api/cometbft/types/v2/types.pb.go +++ b/api/cometbft/types/v2/types.pb.go @@ -392,6 +392,12 @@ type Data struct { // NOTE: not all txs here are valid. We're just agreeing on the order first. // This means that block.AppHash does not include these txs. Txs [][]byte `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"` + // SquareSize is the number of rows or columns in the original data square. + SquareSize uint64 `protobuf:"varint,5,opt,name=square_size,json=squareSize,proto3" json:"square_size,omitempty"` + // Hash is the root of a binary Merkle tree where the leaves of the tree are + // the row and column roots of an extended data square. Hash is often referred + // to as the "data root". + Hash []byte `protobuf:"bytes,6,opt,name=hash,proto3" json:"hash,omitempty"` } func (m *Data) Reset() { *m = Data{} } @@ -434,6 +440,92 @@ func (m *Data) GetTxs() [][]byte { return nil } +func (m *Data) GetSquareSize() uint64 { + if m != nil { + return m.SquareSize + } + return 0 +} + +func (m *Data) GetHash() []byte { + if m != nil { + return m.Hash + } + return nil +} + +// Blob (named after binary large object) is a chunk of data submitted by a user +// to be published to the Celestia blockchain. The data of a Blob is published +// to a namespace and is encoded into shares based on the format specified by +// share_version. +type Blob struct { + NamespaceId []byte `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + ShareVersion uint32 `protobuf:"varint,3,opt,name=share_version,json=shareVersion,proto3" json:"share_version,omitempty"` + NamespaceVersion uint32 `protobuf:"varint,4,opt,name=namespace_version,json=namespaceVersion,proto3" json:"namespace_version,omitempty"` +} + +func (m *Blob) Reset() { *m = Blob{} } +func (m *Blob) String() string { return proto.CompactTextString(m) } +func (*Blob) ProtoMessage() {} +func (*Blob) Descriptor() ([]byte, []int) { + return fileDescriptor_b33958ab5ece188f, []int{5} +} +func (m *Blob) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Blob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Blob.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 *Blob) XXX_Merge(src proto.Message) { + xxx_messageInfo_Blob.Merge(m, src) +} +func (m *Blob) XXX_Size() int { + return m.Size() +} +func (m *Blob) XXX_DiscardUnknown() { + xxx_messageInfo_Blob.DiscardUnknown(m) +} + +var xxx_messageInfo_Blob proto.InternalMessageInfo + +func (m *Blob) GetNamespaceId() []byte { + if m != nil { + return m.NamespaceId + } + return nil +} + +func (m *Blob) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +func (m *Blob) GetShareVersion() uint32 { + if m != nil { + return m.ShareVersion + } + return 0 +} + +func (m *Blob) GetNamespaceVersion() uint32 { + if m != nil { + return m.NamespaceVersion + } + return 0 +} + // Vote represents a prevote or precommit vote from validators for // consensus. // For precommit messages, the message contains vote extensions (replay-protected and non-replay-protected) @@ -469,7 +561,7 @@ func (m *Vote) Reset() { *m = Vote{} } func (m *Vote) String() string { return proto.CompactTextString(m) } func (*Vote) ProtoMessage() {} func (*Vote) Descriptor() ([]byte, []int) { - return fileDescriptor_b33958ab5ece188f, []int{5} + return fileDescriptor_b33958ab5ece188f, []int{6} } func (m *Vote) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -594,7 +686,7 @@ func (m *Commit) Reset() { *m = Commit{} } func (m *Commit) String() string { return proto.CompactTextString(m) } func (*Commit) ProtoMessage() {} func (*Commit) Descriptor() ([]byte, []int) { - return fileDescriptor_b33958ab5ece188f, []int{6} + return fileDescriptor_b33958ab5ece188f, []int{7} } func (m *Commit) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -663,7 +755,7 @@ func (m *CommitSig) Reset() { *m = CommitSig{} } func (m *CommitSig) String() string { return proto.CompactTextString(m) } func (*CommitSig) ProtoMessage() {} func (*CommitSig) Descriptor() ([]byte, []int) { - return fileDescriptor_b33958ab5ece188f, []int{7} + return fileDescriptor_b33958ab5ece188f, []int{8} } func (m *CommitSig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -732,7 +824,7 @@ func (m *ExtendedCommit) Reset() { *m = ExtendedCommit{} } func (m *ExtendedCommit) String() string { return proto.CompactTextString(m) } func (*ExtendedCommit) ProtoMessage() {} func (*ExtendedCommit) Descriptor() ([]byte, []int) { - return fileDescriptor_b33958ab5ece188f, []int{8} + return fileDescriptor_b33958ab5ece188f, []int{9} } func (m *ExtendedCommit) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -814,7 +906,7 @@ func (m *ExtendedCommitSig) Reset() { *m = ExtendedCommitSig{} } func (m *ExtendedCommitSig) String() string { return proto.CompactTextString(m) } func (*ExtendedCommitSig) ProtoMessage() {} func (*ExtendedCommitSig) Descriptor() ([]byte, []int) { - return fileDescriptor_b33958ab5ece188f, []int{9} + return fileDescriptor_b33958ab5ece188f, []int{10} } func (m *ExtendedCommitSig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -914,7 +1006,7 @@ func (m *Proposal) Reset() { *m = Proposal{} } func (m *Proposal) String() string { return proto.CompactTextString(m) } func (*Proposal) ProtoMessage() {} func (*Proposal) Descriptor() ([]byte, []int) { - return fileDescriptor_b33958ab5ece188f, []int{10} + return fileDescriptor_b33958ab5ece188f, []int{11} } func (m *Proposal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1002,7 +1094,7 @@ func (m *SignedHeader) Reset() { *m = SignedHeader{} } func (m *SignedHeader) String() string { return proto.CompactTextString(m) } func (*SignedHeader) ProtoMessage() {} func (*SignedHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_b33958ab5ece188f, []int{11} + return fileDescriptor_b33958ab5ece188f, []int{12} } func (m *SignedHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1055,7 +1147,7 @@ func (m *LightBlock) Reset() { *m = LightBlock{} } func (m *LightBlock) String() string { return proto.CompactTextString(m) } func (*LightBlock) ProtoMessage() {} func (*LightBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_b33958ab5ece188f, []int{12} + return fileDescriptor_b33958ab5ece188f, []int{13} } func (m *LightBlock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1110,7 +1202,7 @@ func (m *BlockMeta) Reset() { *m = BlockMeta{} } func (m *BlockMeta) String() string { return proto.CompactTextString(m) } func (*BlockMeta) ProtoMessage() {} func (*BlockMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_b33958ab5ece188f, []int{13} + return fileDescriptor_b33958ab5ece188f, []int{14} } func (m *BlockMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1178,7 +1270,7 @@ func (m *TxProof) Reset() { *m = TxProof{} } func (m *TxProof) String() string { return proto.CompactTextString(m) } func (*TxProof) ProtoMessage() {} func (*TxProof) Descriptor() ([]byte, []int) { - return fileDescriptor_b33958ab5ece188f, []int{14} + return fileDescriptor_b33958ab5ece188f, []int{15} } func (m *TxProof) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1228,364 +1320,510 @@ func (m *TxProof) GetProof() *v1.Proof { return nil } -func init() { - proto.RegisterEnum("cometbft.types.v2.SignedMsgType", SignedMsgType_name, SignedMsgType_value) - proto.RegisterType((*PartSetHeader)(nil), "cometbft.types.v2.PartSetHeader") - proto.RegisterType((*Part)(nil), "cometbft.types.v2.Part") - proto.RegisterType((*BlockID)(nil), "cometbft.types.v2.BlockID") - proto.RegisterType((*Header)(nil), "cometbft.types.v2.Header") - proto.RegisterType((*Data)(nil), "cometbft.types.v2.Data") - proto.RegisterType((*Vote)(nil), "cometbft.types.v2.Vote") - proto.RegisterType((*Commit)(nil), "cometbft.types.v2.Commit") - proto.RegisterType((*CommitSig)(nil), "cometbft.types.v2.CommitSig") - proto.RegisterType((*ExtendedCommit)(nil), "cometbft.types.v2.ExtendedCommit") - proto.RegisterType((*ExtendedCommitSig)(nil), "cometbft.types.v2.ExtendedCommitSig") - proto.RegisterType((*Proposal)(nil), "cometbft.types.v2.Proposal") - proto.RegisterType((*SignedHeader)(nil), "cometbft.types.v2.SignedHeader") - proto.RegisterType((*LightBlock)(nil), "cometbft.types.v2.LightBlock") - proto.RegisterType((*BlockMeta)(nil), "cometbft.types.v2.BlockMeta") - proto.RegisterType((*TxProof)(nil), "cometbft.types.v2.TxProof") +// IndexWrapper adds index metadata to a transaction. This is used to track +// transactions that pay for blobs, and where the blobs start in the square. +type IndexWrapper struct { + Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"` + ShareIndexes []uint32 `protobuf:"varint,2,rep,packed,name=share_indexes,json=shareIndexes,proto3" json:"share_indexes,omitempty"` + TypeId string `protobuf:"bytes,3,opt,name=type_id,json=typeId,proto3" json:"type_id,omitempty"` } -func init() { proto.RegisterFile("cometbft/types/v2/types.proto", fileDescriptor_b33958ab5ece188f) } - -var fileDescriptor_b33958ab5ece188f = []byte{ - // 1363 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x57, 0x4f, 0x6f, 0x1b, 0x45, - 0x14, 0xcf, 0xc6, 0x1b, 0xff, 0x79, 0xb6, 0x13, 0x67, 0x89, 0xa8, 0xe3, 0xb6, 0x8e, 0x31, 0xff, - 0x4c, 0x41, 0x76, 0x6b, 0x40, 0x80, 0x90, 0x90, 0xea, 0x24, 0x6d, 0x23, 0x9a, 0xc4, 0x5a, 0xbb, - 0x45, 0xc0, 0x61, 0xb5, 0xf6, 0x4e, 0xec, 0x55, 0xed, 0x9d, 0xd5, 0xee, 0xd8, 0x24, 0xfd, 0x04, - 0xa8, 0xa7, 0x1e, 0x39, 0x50, 0x09, 0x09, 0x0e, 0x7c, 0x01, 0xbe, 0x00, 0xe2, 0xd0, 0x63, 0x6f, - 0x70, 0x2a, 0x28, 0xb9, 0xf0, 0x31, 0xd0, 0xbc, 0x99, 0xdd, 0xb5, 0x63, 0x87, 0x96, 0xb6, 0x02, - 0x89, 0xdb, 0xcc, 0x7b, 0xbf, 0xf7, 0xe6, 0xed, 0x7b, 0xbf, 0x79, 0xfb, 0x06, 0x2e, 0x76, 0xe9, - 0x90, 0xb0, 0xce, 0x01, 0xab, 0xb1, 0x23, 0x97, 0xf8, 0xb5, 0x71, 0x5d, 0x2c, 0xaa, 0xae, 0x47, - 0x19, 0xd5, 0x56, 0x03, 0x75, 0x55, 0x48, 0xc7, 0xf5, 0x42, 0x31, 0xb4, 0xe8, 0x7a, 0x47, 0x2e, - 0xa3, 0xb5, 0xf1, 0x95, 0x9a, 0xeb, 0x51, 0x7a, 0x20, 0x4c, 0x0a, 0xaf, 0xcc, 0x7a, 0x1c, 0x9b, - 0x03, 0xdb, 0x32, 0x19, 0xf5, 0x24, 0x64, 0x23, 0x84, 0x8c, 0x89, 0xe7, 0xdb, 0xd4, 0xe1, 0x3e, - 0x26, 0x8e, 0x2d, 0xac, 0xf5, 0x68, 0x8f, 0xe2, 0xb2, 0xc6, 0x57, 0x81, 0x59, 0x8f, 0xd2, 0xde, - 0x80, 0xd4, 0x70, 0xd7, 0x19, 0x1d, 0xd4, 0x98, 0x3d, 0x24, 0x3e, 0x33, 0x87, 0xae, 0x00, 0x94, - 0x3f, 0x82, 0x6c, 0xd3, 0xf4, 0x58, 0x8b, 0xb0, 0x1b, 0xc4, 0xb4, 0x88, 0xa7, 0xad, 0xc1, 0x12, - 0xa3, 0xcc, 0x1c, 0xe4, 0x95, 0x92, 0x52, 0xc9, 0xea, 0x62, 0xa3, 0x69, 0xa0, 0xf6, 0x4d, 0xbf, - 0x9f, 0x5f, 0x2c, 0x29, 0x95, 0x8c, 0x8e, 0xeb, 0xb2, 0x0d, 0x2a, 0x37, 0xe5, 0x16, 0xb6, 0x63, - 0x91, 0xc3, 0xc0, 0x02, 0x37, 0x5c, 0xda, 0x39, 0x62, 0xc4, 0x97, 0x26, 0x62, 0xa3, 0xbd, 0x0f, - 0x4b, 0xf8, 0xe1, 0xf9, 0x58, 0x49, 0xa9, 0xa4, 0xeb, 0xeb, 0xd5, 0x30, 0x59, 0x22, 0x33, 0xd5, - 0xf1, 0x95, 0x6a, 0x93, 0x03, 0x1a, 0xea, 0xc3, 0xc7, 0x1b, 0x0b, 0xba, 0x40, 0x97, 0x87, 0x90, - 0x68, 0x0c, 0x68, 0xf7, 0xce, 0xce, 0x56, 0x18, 0x89, 0x12, 0x45, 0xa2, 0xed, 0xc1, 0x8a, 0x6b, - 0x7a, 0xcc, 0xf0, 0x09, 0x33, 0xfa, 0xf8, 0x19, 0x78, 0x6a, 0xba, 0x5e, 0xaa, 0xce, 0x14, 0xa3, - 0x3a, 0xf5, 0xb9, 0xf2, 0x98, 0xac, 0x3b, 0x29, 0x2c, 0xff, 0xa9, 0x42, 0x5c, 0xa6, 0xe3, 0x13, - 0x48, 0xc8, 0x84, 0xe3, 0x89, 0xe9, 0x7a, 0x31, 0x72, 0x29, 0x15, 0x3c, 0xe6, 0x4d, 0xea, 0xf8, - 0xc4, 0xf1, 0x47, 0xbe, 0x74, 0x18, 0x18, 0x69, 0x6f, 0x40, 0xb2, 0xdb, 0x37, 0x6d, 0xc7, 0xb0, - 0x2d, 0x8c, 0x29, 0xd5, 0x48, 0x1f, 0x3f, 0xde, 0x48, 0x6c, 0x72, 0xd9, 0xce, 0x96, 0x9e, 0x40, - 0xe5, 0x8e, 0xa5, 0xbd, 0x0c, 0xf1, 0x3e, 0xb1, 0x7b, 0x7d, 0x86, 0x99, 0x89, 0xe9, 0x72, 0xa7, - 0x7d, 0x08, 0x2a, 0x2f, 0x59, 0x5e, 0xc5, 0xc3, 0x0b, 0x55, 0x51, 0xcf, 0x6a, 0x50, 0xcf, 0x6a, - 0x3b, 0xa8, 0x67, 0x23, 0xc9, 0x0f, 0xbe, 0xff, 0xfb, 0x86, 0xa2, 0xa3, 0x85, 0xb6, 0x05, 0xd9, - 0x81, 0xe9, 0x33, 0xa3, 0xc3, 0x13, 0xc7, 0x8f, 0x5f, 0x92, 0x2e, 0x66, 0x53, 0x22, 0x73, 0x2b, - 0x63, 0x4f, 0x73, 0x33, 0x21, 0xb2, 0xb4, 0x0a, 0xe4, 0xd0, 0x4b, 0x97, 0x0e, 0x87, 0x36, 0x33, - 0x30, 0xf5, 0x71, 0x4c, 0xfd, 0x32, 0x97, 0x6f, 0xa2, 0xf8, 0x06, 0x2f, 0xc2, 0x79, 0x48, 0x59, - 0x26, 0x33, 0x05, 0x24, 0x81, 0x90, 0x24, 0x17, 0xa0, 0xf2, 0x4d, 0x58, 0x09, 0x19, 0xed, 0x0b, - 0x48, 0x52, 0x78, 0x89, 0xc4, 0x08, 0xbc, 0x0c, 0x6b, 0x0e, 0x39, 0x64, 0xc6, 0x69, 0x74, 0x0a, - 0xd1, 0x1a, 0xd7, 0xdd, 0x9e, 0xb6, 0x78, 0x1d, 0x96, 0xbb, 0x41, 0xf6, 0x05, 0x16, 0x10, 0x9b, - 0x0d, 0xa5, 0x08, 0x5b, 0x87, 0xa4, 0xe9, 0xba, 0x02, 0x90, 0x46, 0x40, 0xc2, 0x74, 0x5d, 0x54, - 0x5d, 0x82, 0x55, 0xfc, 0x46, 0x8f, 0xf8, 0xa3, 0x01, 0x93, 0x4e, 0x32, 0x88, 0x59, 0xe1, 0x0a, - 0x5d, 0xc8, 0x11, 0xfb, 0x2a, 0x64, 0xc9, 0xd8, 0xb6, 0x88, 0xd3, 0x25, 0x02, 0x97, 0x45, 0x5c, - 0x26, 0x10, 0x22, 0xe8, 0x2d, 0xc8, 0xb9, 0x1e, 0x75, 0xa9, 0x4f, 0x3c, 0xc3, 0xb4, 0x2c, 0x8f, - 0xf8, 0x7e, 0x7e, 0x59, 0xf8, 0x0b, 0xe4, 0x57, 0x85, 0xb8, 0x9c, 0x07, 0x75, 0xcb, 0x64, 0xa6, - 0x96, 0x83, 0x18, 0x3b, 0xf4, 0xf3, 0x4a, 0x29, 0x56, 0xc9, 0xe8, 0x7c, 0x59, 0xfe, 0x4e, 0x05, - 0xf5, 0x36, 0x65, 0x44, 0x7b, 0x0f, 0x54, 0x5e, 0x29, 0xe4, 0xdf, 0xf2, 0x5c, 0x4a, 0xb7, 0xec, - 0x9e, 0x43, 0xac, 0x5d, 0xbf, 0xd7, 0x3e, 0x72, 0x89, 0x8e, 0xe8, 0x09, 0x42, 0x2d, 0x4e, 0x11, - 0x6a, 0x0d, 0x96, 0x3c, 0x3a, 0x72, 0x2c, 0xe4, 0xd9, 0x92, 0x2e, 0x36, 0xda, 0x35, 0x48, 0x86, - 0x3c, 0x51, 0x9f, 0xc8, 0x93, 0x15, 0xce, 0x13, 0x4e, 0x63, 0x29, 0xd0, 0x13, 0x1d, 0x49, 0x97, - 0x06, 0xa4, 0xc2, 0x0e, 0x13, 0x12, 0xee, 0x69, 0x38, 0x1b, 0x99, 0x69, 0x6f, 0xc3, 0x6a, 0x58, - 0xfd, 0x30, 0x7d, 0x82, 0x73, 0xb9, 0x50, 0x21, 0xf3, 0x37, 0x45, 0x2c, 0x43, 0xb4, 0xa1, 0x04, - 0x7e, 0x58, 0x44, 0xac, 0x1d, 0xec, 0x47, 0x17, 0x20, 0xe5, 0xdb, 0x3d, 0xc7, 0x64, 0x23, 0x8f, - 0x48, 0xee, 0x45, 0x02, 0xae, 0x25, 0x87, 0x8c, 0x38, 0x78, 0xd1, 0x05, 0xd7, 0x22, 0x81, 0x56, - 0x83, 0x97, 0xc2, 0x8d, 0x11, 0x79, 0x11, 0x3c, 0xd3, 0x42, 0x55, 0x2b, 0x74, 0x57, 0x81, 0x9c, - 0x43, 0x1d, 0xc3, 0x73, 0x8d, 0xc8, 0xab, 0x20, 0xdd, 0xb2, 0x43, 0x1d, 0xdd, 0xdd, 0x0e, 0x5d, - 0x7f, 0x0c, 0x85, 0xd3, 0xc8, 0x89, 0x13, 0x04, 0x09, 0xcf, 0x4d, 0xdb, 0x84, 0xc7, 0x94, 0x7f, - 0x56, 0x20, 0x2e, 0x6e, 0xe0, 0x44, 0xb9, 0x95, 0xf9, 0xe5, 0x5e, 0x3c, 0xab, 0xdc, 0xb1, 0xe7, - 0x2a, 0x37, 0x84, 0xc1, 0xfa, 0x79, 0xb5, 0x14, 0xab, 0xa4, 0xeb, 0x17, 0xe6, 0x78, 0x12, 0x41, - 0xb6, 0xec, 0x9e, 0x6c, 0x31, 0x13, 0x56, 0xe5, 0xc7, 0x0a, 0xa4, 0x42, 0xbd, 0xd6, 0x80, 0x6c, - 0x10, 0x99, 0x71, 0x30, 0x30, 0x7b, 0x92, 0xf5, 0xc5, 0xb3, 0xc3, 0xbb, 0x36, 0x30, 0x7b, 0x7a, - 0x5a, 0x46, 0xc4, 0x37, 0xf3, 0x09, 0xb4, 0x78, 0x06, 0x81, 0xa6, 0x18, 0x1b, 0x7b, 0x36, 0xc6, - 0x4e, 0x71, 0x4b, 0x3d, 0xc5, 0xad, 0xf2, 0x89, 0x02, 0xcb, 0x58, 0x3c, 0x8b, 0x58, 0xff, 0x69, - 0xb5, 0xbe, 0x94, 0x34, 0xb6, 0x88, 0x65, 0xcc, 0x94, 0xed, 0xb5, 0x39, 0x2e, 0xa7, 0xa3, 0x8e, - 0xca, 0xa7, 0x05, 0x6e, 0x5a, 0x51, 0x19, 0xbf, 0x8d, 0xc1, 0xea, 0x0c, 0xfe, 0x7f, 0x58, 0xce, - 0xe9, 0x56, 0xb1, 0xf4, 0x94, 0xad, 0x22, 0xfe, 0x8f, 0x5a, 0x45, 0xe2, 0x19, 0x5a, 0x45, 0xf2, - 0xef, 0x5b, 0xc5, 0x4f, 0x8b, 0x90, 0x6c, 0xe2, 0xbf, 0xc7, 0x1c, 0xfc, 0x2b, 0x7f, 0x94, 0xf3, - 0x90, 0x72, 0xe9, 0xc0, 0x10, 0x1a, 0x15, 0x35, 0x49, 0x97, 0x0e, 0xf4, 0x19, 0x46, 0x2f, 0xbd, - 0xa8, 0xdf, 0x4d, 0xfc, 0x05, 0x54, 0x3b, 0x71, 0xfa, 0xf2, 0x32, 0xc8, 0x88, 0x5c, 0xc8, 0x79, - 0xf0, 0x0a, 0x4f, 0x02, 0x4e, 0x98, 0xca, 0xe9, 0x09, 0x36, 0x8c, 0x5b, 0x40, 0x75, 0x09, 0xe4, - 0x26, 0x62, 0x7a, 0x92, 0x43, 0xe9, 0xfa, 0x99, 0x0d, 0x52, 0x97, 0xc0, 0xf2, 0x37, 0x0a, 0xc0, - 0x4d, 0x9e, 0x5c, 0xfc, 0x62, 0x3e, 0xca, 0xf9, 0x18, 0x84, 0x31, 0x75, 0xf6, 0xc6, 0x99, 0x85, - 0x93, 0x11, 0x64, 0xfc, 0xc9, 0xd0, 0xb7, 0x20, 0x1b, 0xdd, 0x23, 0x9f, 0x04, 0xe1, 0xcc, 0xf3, - 0x12, 0x8e, 0x58, 0x2d, 0xc2, 0xf4, 0xcc, 0x78, 0x62, 0x57, 0xfe, 0x45, 0x81, 0x14, 0x46, 0xb5, - 0x4b, 0x98, 0x39, 0x55, 0x48, 0xe5, 0x39, 0x0a, 0x79, 0x11, 0x40, 0xf8, 0xf1, 0xed, 0xbb, 0x44, - 0xf2, 0x2b, 0x85, 0x92, 0x96, 0x7d, 0x97, 0x68, 0x1f, 0x84, 0x59, 0x8f, 0x3d, 0x21, 0xeb, 0xb2, - 0x43, 0x05, 0xb9, 0x3f, 0x07, 0x09, 0x67, 0x34, 0x34, 0xf8, 0x68, 0xa5, 0x0a, 0xd2, 0x3a, 0xa3, - 0x61, 0xfb, 0xd0, 0x2f, 0xdf, 0x81, 0x44, 0xfb, 0x10, 0x5f, 0x1a, 0x9c, 0xa9, 0x1e, 0xa5, 0x72, - 0xb6, 0x15, 0xcf, 0x8a, 0x24, 0x17, 0xe0, 0x28, 0xa7, 0x81, 0xca, 0x87, 0xd8, 0xe0, 0xe1, 0xc3, - 0xd7, 0x5a, 0xed, 0x69, 0x1f, 0x31, 0xf2, 0xf9, 0x72, 0xe9, 0x57, 0x05, 0xb2, 0x53, 0x37, 0x4a, - 0x7b, 0x07, 0xce, 0xb5, 0x76, 0xae, 0xef, 0x6d, 0x6f, 0x19, 0xbb, 0xad, 0xeb, 0x46, 0xfb, 0xf3, - 0xe6, 0xb6, 0x71, 0x6b, 0xef, 0xd3, 0xbd, 0xfd, 0xcf, 0xf6, 0x72, 0x0b, 0x85, 0x95, 0x7b, 0x0f, - 0x4a, 0xe9, 0x5b, 0xce, 0x1d, 0x87, 0x7e, 0xe5, 0x9c, 0x85, 0x6e, 0xea, 0xdb, 0xb7, 0xf7, 0xdb, - 0xdb, 0x39, 0x45, 0xa0, 0x9b, 0x1e, 0x19, 0x53, 0x46, 0x10, 0x7d, 0x19, 0xd6, 0xe7, 0xa0, 0x37, - 0xf7, 0x77, 0x77, 0x77, 0xda, 0xb9, 0xc5, 0xc2, 0xea, 0xbd, 0x07, 0xa5, 0x6c, 0xd3, 0x23, 0x82, - 0x6a, 0x68, 0x51, 0x85, 0xfc, 0xac, 0xc5, 0x7e, 0x73, 0xbf, 0x75, 0xf5, 0x66, 0xae, 0x54, 0xc8, - 0xdd, 0x7b, 0x50, 0xca, 0x04, 0xbd, 0x83, 0xe3, 0x0b, 0xc9, 0xaf, 0xbf, 0x2f, 0x2e, 0xfc, 0xf8, - 0x43, 0x51, 0x69, 0xdc, 0x7c, 0x78, 0x5c, 0x54, 0x1e, 0x1d, 0x17, 0x95, 0x3f, 0x8e, 0x8b, 0xca, - 0xfd, 0x93, 0xe2, 0xc2, 0xa3, 0x93, 0xe2, 0xc2, 0x6f, 0x27, 0xc5, 0x85, 0x2f, 0xea, 0x3d, 0x9b, - 0xf5, 0x47, 0x1d, 0x9e, 0x9b, 0x5a, 0xf4, 0xfc, 0x0d, 0x16, 0xa6, 0x6b, 0xd7, 0x66, 0x1e, 0xbd, - 0x9d, 0x38, 0xde, 0xd9, 0x77, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x67, 0x89, 0x32, 0x06, 0x62, - 0x0f, 0x00, 0x00, +func (m *IndexWrapper) Reset() { *m = IndexWrapper{} } +func (m *IndexWrapper) String() string { return proto.CompactTextString(m) } +func (*IndexWrapper) ProtoMessage() {} +func (*IndexWrapper) Descriptor() ([]byte, []int) { + return fileDescriptor_b33958ab5ece188f, []int{16} } - -func (m *PartSetHeader) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *IndexWrapper) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *IndexWrapper) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_IndexWrapper.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return dAtA[:n], nil } - -func (m *PartSetHeader) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *IndexWrapper) XXX_Merge(src proto.Message) { + xxx_messageInfo_IndexWrapper.Merge(m, src) +} +func (m *IndexWrapper) XXX_Size() int { + return m.Size() +} +func (m *IndexWrapper) XXX_DiscardUnknown() { + xxx_messageInfo_IndexWrapper.DiscardUnknown(m) } -func (m *PartSetHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Hash) > 0 { - i -= len(m.Hash) - copy(dAtA[i:], m.Hash) - i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) - i-- - dAtA[i] = 0x12 +var xxx_messageInfo_IndexWrapper proto.InternalMessageInfo + +func (m *IndexWrapper) GetTx() []byte { + if m != nil { + return m.Tx } - if m.Total != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.Total)) - i-- - dAtA[i] = 0x8 + return nil +} + +func (m *IndexWrapper) GetShareIndexes() []uint32 { + if m != nil { + return m.ShareIndexes } - return len(dAtA) - i, nil + return nil } -func (m *Part) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *IndexWrapper) GetTypeId() string { + if m != nil { + return m.TypeId } - return dAtA[:n], nil + return "" } -func (m *Part) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +// BlobTx wraps an encoded sdk.Tx with a second field to contain blobs of data. +// The raw bytes of the blobs are not signed over, instead we verify each blob +// using the relevant MsgPayForBlobs that is signed over in the encoded sdk.Tx. +type BlobTx struct { + Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"` + Blobs []*Blob `protobuf:"bytes,2,rep,name=blobs,proto3" json:"blobs,omitempty"` + TypeId string `protobuf:"bytes,3,opt,name=type_id,json=typeId,proto3" json:"type_id,omitempty"` } -func (m *Part) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) +func (m *BlobTx) Reset() { *m = BlobTx{} } +func (m *BlobTx) String() string { return proto.CompactTextString(m) } +func (*BlobTx) ProtoMessage() {} +func (*BlobTx) Descriptor() ([]byte, []int) { + return fileDescriptor_b33958ab5ece188f, []int{17} +} +func (m *BlobTx) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BlobTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BlobTx.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) if err != nil { - return 0, err + return nil, err } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) + return b[:n], nil } - i-- - dAtA[i] = 0x1a - if len(m.Bytes) > 0 { - i -= len(m.Bytes) - copy(dAtA[i:], m.Bytes) - i = encodeVarintTypes(dAtA, i, uint64(len(m.Bytes))) - i-- - dAtA[i] = 0x12 +} +func (m *BlobTx) XXX_Merge(src proto.Message) { + xxx_messageInfo_BlobTx.Merge(m, src) +} +func (m *BlobTx) XXX_Size() int { + return m.Size() +} +func (m *BlobTx) XXX_DiscardUnknown() { + xxx_messageInfo_BlobTx.DiscardUnknown(m) +} + +var xxx_messageInfo_BlobTx proto.InternalMessageInfo + +func (m *BlobTx) GetTx() []byte { + if m != nil { + return m.Tx } - if m.Index != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.Index)) - i-- - dAtA[i] = 0x8 + return nil +} + +func (m *BlobTx) GetBlobs() []*Blob { + if m != nil { + return m.Blobs } - return len(dAtA) - i, nil + return nil } -func (m *BlockID) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func (m *BlobTx) GetTypeId() string { + if m != nil { + return m.TypeId } - return dAtA[:n], nil + return "" } -func (m *BlockID) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +// ShareProof is an NMT proof that a set of shares exist in a set of rows and a +// Merkle proof that those rows exist in a Merkle tree with a given data root. +type ShareProof struct { + Data [][]byte `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"` + ShareProofs []*NMTProof `protobuf:"bytes,2,rep,name=share_proofs,json=shareProofs,proto3" json:"share_proofs,omitempty"` + NamespaceId []byte `protobuf:"bytes,3,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + RowProof *RowProof `protobuf:"bytes,4,opt,name=row_proof,json=rowProof,proto3" json:"row_proof,omitempty"` + NamespaceVersion uint32 `protobuf:"varint,5,opt,name=namespace_version,json=namespaceVersion,proto3" json:"namespace_version,omitempty"` } -func (m *BlockID) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.PartSetHeader.MarshalToSizedBuffer(dAtA[:i]) +func (m *ShareProof) Reset() { *m = ShareProof{} } +func (m *ShareProof) String() string { return proto.CompactTextString(m) } +func (*ShareProof) ProtoMessage() {} +func (*ShareProof) Descriptor() ([]byte, []int) { + return fileDescriptor_b33958ab5ece188f, []int{18} +} +func (m *ShareProof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ShareProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ShareProof.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) if err != nil { - return 0, err + return nil, err } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - if len(m.Hash) > 0 { - i -= len(m.Hash) - copy(dAtA[i:], m.Hash) - i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) - i-- - dAtA[i] = 0xa + return b[:n], nil } - return len(dAtA) - i, nil +} +func (m *ShareProof) XXX_Merge(src proto.Message) { + xxx_messageInfo_ShareProof.Merge(m, src) +} +func (m *ShareProof) XXX_Size() int { + return m.Size() +} +func (m *ShareProof) XXX_DiscardUnknown() { + xxx_messageInfo_ShareProof.DiscardUnknown(m) } -func (m *Header) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +var xxx_messageInfo_ShareProof proto.InternalMessageInfo + +func (m *ShareProof) GetData() [][]byte { + if m != nil { + return m.Data } - return dAtA[:n], nil + return nil } -func (m *Header) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *ShareProof) GetShareProofs() []*NMTProof { + if m != nil { + return m.ShareProofs + } + return nil } -func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.ProposerAddress) > 0 { - i -= len(m.ProposerAddress) - copy(dAtA[i:], m.ProposerAddress) - i = encodeVarintTypes(dAtA, i, uint64(len(m.ProposerAddress))) - i-- - dAtA[i] = 0x72 +func (m *ShareProof) GetNamespaceId() []byte { + if m != nil { + return m.NamespaceId } - if len(m.EvidenceHash) > 0 { - i -= len(m.EvidenceHash) - copy(dAtA[i:], m.EvidenceHash) - i = encodeVarintTypes(dAtA, i, uint64(len(m.EvidenceHash))) - i-- - dAtA[i] = 0x6a + return nil +} + +func (m *ShareProof) GetRowProof() *RowProof { + if m != nil { + return m.RowProof } - if len(m.LastResultsHash) > 0 { - i -= len(m.LastResultsHash) - copy(dAtA[i:], m.LastResultsHash) - i = encodeVarintTypes(dAtA, i, uint64(len(m.LastResultsHash))) - i-- - dAtA[i] = 0x62 + return nil +} + +func (m *ShareProof) GetNamespaceVersion() uint32 { + if m != nil { + return m.NamespaceVersion } - if len(m.AppHash) > 0 { - i -= len(m.AppHash) - copy(dAtA[i:], m.AppHash) - i = encodeVarintTypes(dAtA, i, uint64(len(m.AppHash))) - i-- - dAtA[i] = 0x5a + return 0 +} + +// RowProof is a Merkle proof that a set of rows exist in a Merkle tree with a +// given data root. +type RowProof struct { + RowRoots [][]byte `protobuf:"bytes,1,rep,name=row_roots,json=rowRoots,proto3" json:"row_roots,omitempty"` + Proofs []*v1.Proof `protobuf:"bytes,2,rep,name=proofs,proto3" json:"proofs,omitempty"` + Root []byte `protobuf:"bytes,3,opt,name=root,proto3" json:"root,omitempty"` + StartRow uint32 `protobuf:"varint,4,opt,name=start_row,json=startRow,proto3" json:"start_row,omitempty"` + EndRow uint32 `protobuf:"varint,5,opt,name=end_row,json=endRow,proto3" json:"end_row,omitempty"` +} + +func (m *RowProof) Reset() { *m = RowProof{} } +func (m *RowProof) String() string { return proto.CompactTextString(m) } +func (*RowProof) ProtoMessage() {} +func (*RowProof) Descriptor() ([]byte, []int) { + return fileDescriptor_b33958ab5ece188f, []int{19} +} +func (m *RowProof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RowProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RowProof.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - if len(m.ConsensusHash) > 0 { - i -= len(m.ConsensusHash) - copy(dAtA[i:], m.ConsensusHash) - i = encodeVarintTypes(dAtA, i, uint64(len(m.ConsensusHash))) - i-- - dAtA[i] = 0x52 +} +func (m *RowProof) XXX_Merge(src proto.Message) { + xxx_messageInfo_RowProof.Merge(m, src) +} +func (m *RowProof) XXX_Size() int { + return m.Size() +} +func (m *RowProof) XXX_DiscardUnknown() { + xxx_messageInfo_RowProof.DiscardUnknown(m) +} + +var xxx_messageInfo_RowProof proto.InternalMessageInfo + +func (m *RowProof) GetRowRoots() [][]byte { + if m != nil { + return m.RowRoots } - if len(m.NextValidatorsHash) > 0 { - i -= len(m.NextValidatorsHash) - copy(dAtA[i:], m.NextValidatorsHash) - i = encodeVarintTypes(dAtA, i, uint64(len(m.NextValidatorsHash))) - i-- - dAtA[i] = 0x4a + return nil +} + +func (m *RowProof) GetProofs() []*v1.Proof { + if m != nil { + return m.Proofs } - if len(m.ValidatorsHash) > 0 { - i -= len(m.ValidatorsHash) - copy(dAtA[i:], m.ValidatorsHash) - i = encodeVarintTypes(dAtA, i, uint64(len(m.ValidatorsHash))) - i-- - dAtA[i] = 0x42 + return nil +} + +func (m *RowProof) GetRoot() []byte { + if m != nil { + return m.Root } - if len(m.DataHash) > 0 { - i -= len(m.DataHash) - copy(dAtA[i:], m.DataHash) - i = encodeVarintTypes(dAtA, i, uint64(len(m.DataHash))) - i-- - dAtA[i] = 0x3a + return nil +} + +func (m *RowProof) GetStartRow() uint32 { + if m != nil { + return m.StartRow } - if len(m.LastCommitHash) > 0 { - i -= len(m.LastCommitHash) - copy(dAtA[i:], m.LastCommitHash) - i = encodeVarintTypes(dAtA, i, uint64(len(m.LastCommitHash))) - i-- - dAtA[i] = 0x32 + return 0 +} + +func (m *RowProof) GetEndRow() uint32 { + if m != nil { + return m.EndRow } - { - size, err := m.LastBlockId.MarshalToSizedBuffer(dAtA[:i]) + return 0 +} + +// NMTProof is a proof of a namespace.ID in an NMT. +// In case this proof proves the absence of a namespace.ID +// in a tree it also contains the leaf hashes of the range +// where that namespace would be. +type NMTProof struct { + // Start index of this proof. + Start int32 `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"` + // End index of this proof. + End int32 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"` + // Nodes that together with the corresponding leaf values can be used to + // recompute the root and verify this proof. Nodes should consist of the max + // and min namespaces along with the actual hash, resulting in each being 48 + // bytes each + Nodes [][]byte `protobuf:"bytes,3,rep,name=nodes,proto3" json:"nodes,omitempty"` + // leafHash are nil if the namespace is present in the NMT. In case the + // namespace to be proved is in the min/max range of the tree but absent, this + // will contain the leaf hash necessary to verify the proof of absence. Leaf + // hashes should consist of the namespace along with the actual hash, + // resulting 40 bytes total. + LeafHash []byte `protobuf:"bytes,4,opt,name=leaf_hash,json=leafHash,proto3" json:"leaf_hash,omitempty"` +} + +func (m *NMTProof) Reset() { *m = NMTProof{} } +func (m *NMTProof) String() string { return proto.CompactTextString(m) } +func (*NMTProof) ProtoMessage() {} +func (*NMTProof) Descriptor() ([]byte, []int) { + return fileDescriptor_b33958ab5ece188f, []int{20} +} +func (m *NMTProof) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NMTProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_NMTProof.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) if err != nil { - return 0, err + return nil, err } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) + return b[:n], nil } - i-- - dAtA[i] = 0x2a - n4, err4 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):]) - if err4 != nil { - return 0, err4 +} +func (m *NMTProof) XXX_Merge(src proto.Message) { + xxx_messageInfo_NMTProof.Merge(m, src) +} +func (m *NMTProof) XXX_Size() int { + return m.Size() +} +func (m *NMTProof) XXX_DiscardUnknown() { + xxx_messageInfo_NMTProof.DiscardUnknown(m) +} + +var xxx_messageInfo_NMTProof proto.InternalMessageInfo + +func (m *NMTProof) GetStart() int32 { + if m != nil { + return m.Start } - i -= n4 - i = encodeVarintTypes(dAtA, i, uint64(n4)) - i-- - dAtA[i] = 0x22 - if m.Height != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.Height)) - i-- - dAtA[i] = 0x18 + return 0 +} + +func (m *NMTProof) GetEnd() int32 { + if m != nil { + return m.End } - if len(m.ChainID) > 0 { - i -= len(m.ChainID) - copy(dAtA[i:], m.ChainID) - i = encodeVarintTypes(dAtA, i, uint64(len(m.ChainID))) - i-- - dAtA[i] = 0x12 + return 0 +} + +func (m *NMTProof) GetNodes() [][]byte { + if m != nil { + return m.Nodes } - { - size, err := m.Version.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) + return nil +} + +func (m *NMTProof) GetLeafHash() []byte { + if m != nil { + return m.LeafHash } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil + return nil } -func (m *Data) Marshal() (dAtA []byte, err error) { +func init() { + proto.RegisterEnum("cometbft.types.v2.SignedMsgType", SignedMsgType_name, SignedMsgType_value) + proto.RegisterType((*PartSetHeader)(nil), "cometbft.types.v2.PartSetHeader") + proto.RegisterType((*Part)(nil), "cometbft.types.v2.Part") + proto.RegisterType((*BlockID)(nil), "cometbft.types.v2.BlockID") + proto.RegisterType((*Header)(nil), "cometbft.types.v2.Header") + proto.RegisterType((*Data)(nil), "cometbft.types.v2.Data") + proto.RegisterType((*Blob)(nil), "cometbft.types.v2.Blob") + proto.RegisterType((*Vote)(nil), "cometbft.types.v2.Vote") + proto.RegisterType((*Commit)(nil), "cometbft.types.v2.Commit") + proto.RegisterType((*CommitSig)(nil), "cometbft.types.v2.CommitSig") + proto.RegisterType((*ExtendedCommit)(nil), "cometbft.types.v2.ExtendedCommit") + proto.RegisterType((*ExtendedCommitSig)(nil), "cometbft.types.v2.ExtendedCommitSig") + proto.RegisterType((*Proposal)(nil), "cometbft.types.v2.Proposal") + proto.RegisterType((*SignedHeader)(nil), "cometbft.types.v2.SignedHeader") + proto.RegisterType((*LightBlock)(nil), "cometbft.types.v2.LightBlock") + proto.RegisterType((*BlockMeta)(nil), "cometbft.types.v2.BlockMeta") + proto.RegisterType((*TxProof)(nil), "cometbft.types.v2.TxProof") + proto.RegisterType((*IndexWrapper)(nil), "cometbft.types.v2.IndexWrapper") + proto.RegisterType((*BlobTx)(nil), "cometbft.types.v2.BlobTx") + proto.RegisterType((*ShareProof)(nil), "cometbft.types.v2.ShareProof") + proto.RegisterType((*RowProof)(nil), "cometbft.types.v2.RowProof") + proto.RegisterType((*NMTProof)(nil), "cometbft.types.v2.NMTProof") +} + +func init() { proto.RegisterFile("cometbft/types/v2/types.proto", fileDescriptor_b33958ab5ece188f) } + +var fileDescriptor_b33958ab5ece188f = []byte{ + // 1714 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0x5f, 0x6f, 0x2b, 0x47, + 0x15, 0xcf, 0xda, 0x6b, 0x7b, 0x7d, 0x6c, 0x27, 0xce, 0x12, 0x11, 0xc7, 0xb7, 0x75, 0x5c, 0xf3, + 0x2f, 0x14, 0xb0, 0x7b, 0x0d, 0x88, 0x22, 0xa4, 0x4a, 0x75, 0x92, 0xb6, 0xbe, 0xdc, 0x24, 0xd6, + 0xda, 0x4d, 0xc5, 0x1f, 0x69, 0x59, 0x7b, 0x27, 0xf6, 0xea, 0xda, 0x3b, 0xcb, 0xee, 0xd8, 0x71, + 0xfa, 0x09, 0xd0, 0x7d, 0xa1, 0x8f, 0x3c, 0x70, 0x25, 0x24, 0xfa, 0xc0, 0x17, 0xe0, 0x0b, 0x20, + 0x1e, 0xfa, 0xd8, 0x37, 0x78, 0xba, 0xa0, 0xe4, 0x05, 0xf1, 0x29, 0xd0, 0x9c, 0x99, 0xdd, 0xb5, + 0x63, 0xbb, 0xbd, 0xb4, 0x15, 0x48, 0x7d, 0x9b, 0x39, 0xe7, 0x77, 0xfe, 0xcc, 0xf9, 0x33, 0x7b, + 0x66, 0xe1, 0xe5, 0x01, 0x9d, 0x10, 0xd6, 0xbf, 0x62, 0x0d, 0x76, 0xe3, 0x91, 0xa0, 0x31, 0x6b, + 0x8a, 0x45, 0xdd, 0xf3, 0x29, 0xa3, 0xfa, 0x6e, 0xc8, 0xae, 0x0b, 0xea, 0xac, 0x59, 0xae, 0x44, + 0x12, 0x03, 0xff, 0xc6, 0x63, 0xb4, 0x31, 0x7b, 0xd8, 0xf0, 0x7c, 0x4a, 0xaf, 0x84, 0x48, 0xf9, + 0x95, 0x55, 0x8d, 0x33, 0x6b, 0xec, 0xd8, 0x16, 0xa3, 0xbe, 0x84, 0x1c, 0x46, 0x90, 0x19, 0xf1, + 0x03, 0x87, 0xba, 0x5c, 0xc7, 0x82, 0xd9, 0xf2, 0xde, 0x90, 0x0e, 0x29, 0x2e, 0x1b, 0x7c, 0x15, + 0x8a, 0x0d, 0x29, 0x1d, 0x8e, 0x49, 0x03, 0x77, 0xfd, 0xe9, 0x55, 0x83, 0x39, 0x13, 0x12, 0x30, + 0x6b, 0xe2, 0x09, 0x40, 0xed, 0xc7, 0x50, 0xe8, 0x58, 0x3e, 0xeb, 0x12, 0xf6, 0x0e, 0xb1, 0x6c, + 0xe2, 0xeb, 0x7b, 0x90, 0x62, 0x94, 0x59, 0xe3, 0x92, 0x52, 0x55, 0x8e, 0x0a, 0x86, 0xd8, 0xe8, + 0x3a, 0xa8, 0x23, 0x2b, 0x18, 0x95, 0x12, 0x55, 0xe5, 0x28, 0x6f, 0xe0, 0xba, 0xe6, 0x80, 0xca, + 0x45, 0xb9, 0x84, 0xe3, 0xda, 0x64, 0x1e, 0x4a, 0xe0, 0x86, 0x53, 0xfb, 0x37, 0x8c, 0x04, 0x52, + 0x44, 0x6c, 0xf4, 0x1f, 0x42, 0x0a, 0x0f, 0x5e, 0x4a, 0x56, 0x95, 0xa3, 0x5c, 0xf3, 0xa0, 0x1e, + 0x05, 0x4b, 0x44, 0xa6, 0x3e, 0x7b, 0x58, 0xef, 0x70, 0x40, 0x4b, 0xfd, 0xe8, 0xf9, 0xe1, 0x96, + 0x21, 0xd0, 0xb5, 0x09, 0x64, 0x5a, 0x63, 0x3a, 0x78, 0xd2, 0x3e, 0x89, 0x3c, 0x51, 0x62, 0x4f, + 0xf4, 0x73, 0xd8, 0xf1, 0x2c, 0x9f, 0x99, 0x01, 0x61, 0xe6, 0x08, 0x8f, 0x81, 0x56, 0x73, 0xcd, + 0x6a, 0x7d, 0x25, 0x19, 0xf5, 0xa5, 0xe3, 0x4a, 0x33, 0x05, 0x6f, 0x91, 0x58, 0xfb, 0x97, 0x0a, + 0x69, 0x19, 0x8e, 0x37, 0x20, 0x23, 0x03, 0x8e, 0x16, 0x73, 0xcd, 0x4a, 0xac, 0x52, 0x32, 0xb8, + 0xcf, 0xc7, 0xd4, 0x0d, 0x88, 0x1b, 0x4c, 0x03, 0xa9, 0x30, 0x14, 0xd2, 0xbf, 0x09, 0xda, 0x60, + 0x64, 0x39, 0xae, 0xe9, 0xd8, 0xe8, 0x53, 0xb6, 0x95, 0xbb, 0x7d, 0x7e, 0x98, 0x39, 0xe6, 0xb4, + 0xf6, 0x89, 0x91, 0x41, 0x66, 0xdb, 0xd6, 0xbf, 0x0a, 0xe9, 0x11, 0x71, 0x86, 0x23, 0x86, 0x91, + 0x49, 0x1a, 0x72, 0xa7, 0xbf, 0x0e, 0x2a, 0x4f, 0x59, 0x49, 0x45, 0xe3, 0xe5, 0xba, 0xc8, 0x67, + 0x3d, 0xcc, 0x67, 0xbd, 0x17, 0xe6, 0xb3, 0xa5, 0x71, 0xc3, 0x1f, 0xfc, 0xe3, 0x50, 0x31, 0x50, + 0x42, 0x3f, 0x81, 0xc2, 0xd8, 0x0a, 0x98, 0xd9, 0xe7, 0x81, 0xe3, 0xe6, 0x53, 0x52, 0xc5, 0x6a, + 0x48, 0x64, 0x6c, 0xa5, 0xef, 0x39, 0x2e, 0x26, 0x48, 0xb6, 0x7e, 0x04, 0x45, 0xd4, 0x32, 0xa0, + 0x93, 0x89, 0xc3, 0x4c, 0x0c, 0x7d, 0x1a, 0x43, 0xbf, 0xcd, 0xe9, 0xc7, 0x48, 0x7e, 0x87, 0x27, + 0xe1, 0x01, 0x64, 0x6d, 0x8b, 0x59, 0x02, 0x92, 0x41, 0x88, 0xc6, 0x09, 0xc8, 0xfc, 0x16, 0xec, + 0x44, 0x15, 0x1d, 0x08, 0x88, 0x26, 0xb4, 0xc4, 0x64, 0x04, 0xbe, 0x06, 0x7b, 0x2e, 0x99, 0x33, + 0xf3, 0x3e, 0x3a, 0x8b, 0x68, 0x9d, 0xf3, 0x2e, 0x97, 0x25, 0xbe, 0x01, 0xdb, 0x83, 0x30, 0xfa, + 0x02, 0x0b, 0x88, 0x2d, 0x44, 0x54, 0x84, 0x1d, 0x80, 0x66, 0x79, 0x9e, 0x00, 0xe4, 0x10, 0x90, + 0xb1, 0x3c, 0x0f, 0x59, 0xaf, 0xc2, 0x2e, 0x9e, 0xd1, 0x27, 0xc1, 0x74, 0xcc, 0xa4, 0x92, 0x3c, + 0x62, 0x76, 0x38, 0xc3, 0x10, 0x74, 0xc4, 0x7e, 0x0d, 0x0a, 0x64, 0xe6, 0xd8, 0xc4, 0x1d, 0x10, + 0x81, 0x2b, 0x20, 0x2e, 0x1f, 0x12, 0x11, 0xf4, 0x6d, 0x28, 0x7a, 0x3e, 0xf5, 0x68, 0x40, 0x7c, + 0xd3, 0xb2, 0x6d, 0x9f, 0x04, 0x41, 0x69, 0x5b, 0xe8, 0x0b, 0xe9, 0x6f, 0x0a, 0x72, 0xcd, 0x04, + 0xf5, 0xc4, 0x62, 0x96, 0x5e, 0x84, 0x24, 0x9b, 0x07, 0x25, 0xa5, 0x9a, 0x3c, 0xca, 0x1b, 0x7c, + 0xa9, 0x1f, 0x42, 0x2e, 0xf8, 0xf5, 0xd4, 0xf2, 0x89, 0x19, 0x38, 0xef, 0x13, 0xcc, 0x9e, 0x6a, + 0x80, 0x20, 0x75, 0x9d, 0xf7, 0x49, 0xd4, 0x09, 0xe9, 0xb8, 0x13, 0x1e, 0xa9, 0x5a, 0xa2, 0x98, + 0x7c, 0xa4, 0x6a, 0xc9, 0xa2, 0xfa, 0x48, 0xd5, 0xd4, 0x62, 0xaa, 0xf6, 0x5b, 0x05, 0xd4, 0xd6, + 0x98, 0xf6, 0xf5, 0x57, 0x20, 0xef, 0x5a, 0x13, 0x12, 0x78, 0xd6, 0x80, 0xf0, 0x72, 0x10, 0x0d, + 0x94, 0x8b, 0x68, 0x6d, 0x9b, 0x6b, 0xe4, 0x19, 0x0b, 0xbb, 0x9c, 0xaf, 0xf9, 0x81, 0x83, 0x11, + 0xf7, 0x22, 0x6c, 0x83, 0x24, 0x76, 0x79, 0x1e, 0x89, 0x97, 0xb2, 0xca, 0xbf, 0x03, 0xbb, 0xb1, + 0xee, 0x10, 0xa8, 0x22, 0xb0, 0x18, 0x31, 0x24, 0xb8, 0xf6, 0x07, 0x15, 0xd4, 0x4b, 0xca, 0x88, + 0xfe, 0x03, 0x50, 0x79, 0x09, 0xa2, 0x27, 0xdb, 0x6b, 0x7b, 0xb5, 0xeb, 0x0c, 0x5d, 0x62, 0x9f, + 0x05, 0xc3, 0xde, 0x8d, 0x47, 0x0c, 0x44, 0x2f, 0x74, 0x4a, 0x62, 0xa9, 0x53, 0xf6, 0x20, 0xe5, + 0xd3, 0xa9, 0x6b, 0xa3, 0x83, 0x29, 0x43, 0x6c, 0xf4, 0xb7, 0x40, 0x8b, 0x1a, 0x40, 0xfd, 0xd4, + 0x06, 0xd8, 0xe1, 0x0d, 0xc0, 0xfb, 0x53, 0x12, 0x8c, 0x4c, 0x5f, 0xf6, 0x41, 0x0b, 0xb2, 0xd1, + 0xd5, 0x19, 0x75, 0xd2, 0x8b, 0x34, 0x63, 0x2c, 0xc6, 0xa3, 0x14, 0x95, 0x75, 0x54, 0x17, 0x22, + 0x7b, 0xc5, 0x88, 0x21, 0x0b, 0x63, 0xa9, 0x63, 0x4c, 0x71, 0xbf, 0x66, 0xf0, 0x60, 0x71, 0xc7, + 0xb4, 0xf1, 0xa2, 0x7d, 0x09, 0xb2, 0x81, 0x33, 0x74, 0x2d, 0x36, 0xf5, 0x89, 0x6c, 0xaa, 0x98, + 0xc0, 0xb9, 0x64, 0xce, 0x88, 0x8b, 0x19, 0x11, 0x4d, 0x14, 0x13, 0xf4, 0x06, 0x7c, 0x25, 0xda, + 0x98, 0xb1, 0x16, 0xd1, 0x40, 0x7a, 0xc4, 0xea, 0x46, 0xea, 0x8e, 0xa0, 0xe8, 0x52, 0xd7, 0xf4, + 0x3d, 0x33, 0xd6, 0x2a, 0xba, 0x69, 0xdb, 0xa5, 0xae, 0xe1, 0x9d, 0x46, 0xaa, 0x7f, 0x02, 0xe5, + 0xfb, 0xc8, 0x05, 0x0b, 0xa2, 0xbb, 0xf6, 0x97, 0x65, 0x22, 0x33, 0xb5, 0xbf, 0x28, 0x90, 0x16, + 0x57, 0xcb, 0x42, 0xba, 0x95, 0xf5, 0xe9, 0x4e, 0x6c, 0x4a, 0x77, 0xf2, 0x73, 0xa5, 0x1b, 0x22, + 0x67, 0x83, 0x92, 0x5a, 0x4d, 0x1e, 0xe5, 0x9a, 0x2f, 0xad, 0xd1, 0x24, 0x9c, 0xec, 0x3a, 0x43, + 0x79, 0x77, 0x2e, 0x48, 0xd5, 0x9e, 0x2b, 0x90, 0x8d, 0xf8, 0x7a, 0x0b, 0x0a, 0xa1, 0x67, 0xe6, + 0xd5, 0xd8, 0x1a, 0xca, 0xaa, 0xaf, 0x6c, 0x76, 0xef, 0xad, 0xb1, 0x35, 0x34, 0x72, 0xd2, 0x23, + 0xbe, 0x59, 0x5f, 0x40, 0x89, 0x0d, 0x05, 0xb4, 0x54, 0xb1, 0xc9, 0xcf, 0x56, 0xb1, 0x4b, 0xb5, + 0xa5, 0xde, 0xab, 0xad, 0xda, 0x9d, 0x02, 0xdb, 0x98, 0x3c, 0x9b, 0xd8, 0xff, 0xd7, 0x6c, 0xfd, + 0x42, 0x96, 0xb1, 0x4d, 0x6c, 0x73, 0x25, 0x6d, 0x5f, 0x5f, 0xa3, 0x72, 0xd9, 0xeb, 0x38, 0x7d, + 0x7a, 0xa8, 0xa6, 0x1b, 0xa7, 0xf1, 0xf7, 0x49, 0xd8, 0x5d, 0xc1, 0x7f, 0x09, 0xd3, 0xb9, 0x7c, + 0x55, 0xa4, 0x5e, 0xf0, 0xaa, 0x48, 0xff, 0x57, 0x57, 0x45, 0xe6, 0x33, 0x5c, 0x15, 0xda, 0x27, + 0x5f, 0x15, 0x7f, 0x4e, 0x80, 0xd6, 0xc1, 0x8f, 0xaa, 0x35, 0xfe, 0x9f, 0x7c, 0x51, 0x1e, 0x40, + 0xd6, 0xa3, 0x63, 0x53, 0x70, 0x54, 0xe4, 0x68, 0x1e, 0x1d, 0x1b, 0x2b, 0x15, 0x9d, 0xfa, 0xa2, + 0x3e, 0x37, 0xe9, 0x2f, 0x20, 0xdb, 0x99, 0xfb, 0xcd, 0xcb, 0x20, 0x2f, 0x62, 0x21, 0x07, 0xdd, + 0x87, 0x3c, 0x08, 0x38, 0x3a, 0x2b, 0xf7, 0x47, 0xf3, 0xc8, 0x6f, 0x01, 0x35, 0x24, 0x90, 0x8b, + 0x88, 0xb1, 0x50, 0x4e, 0xdb, 0x07, 0x1b, 0x2f, 0x48, 0x43, 0x02, 0x6b, 0xbf, 0x53, 0x00, 0x1e, + 0xf3, 0xe0, 0xe2, 0x89, 0xf9, 0x8c, 0x1a, 0xa0, 0x13, 0xe6, 0x92, 0xed, 0xc3, 0x8d, 0x89, 0x93, + 0x1e, 0xe4, 0x83, 0x45, 0xd7, 0x4f, 0xa0, 0x10, 0xf7, 0x51, 0x40, 0x42, 0x77, 0xd6, 0x69, 0x89, + 0x66, 0xc7, 0x2e, 0x61, 0x46, 0x7e, 0xb6, 0xb0, 0xab, 0xfd, 0x55, 0x81, 0x2c, 0x7a, 0x75, 0x46, + 0x98, 0xb5, 0x94, 0x48, 0xe5, 0x73, 0x24, 0xf2, 0x65, 0x00, 0xa1, 0x07, 0x87, 0x38, 0x51, 0x5f, + 0x59, 0xa4, 0xe0, 0x0c, 0xf7, 0xa3, 0x28, 0xea, 0xc9, 0x4f, 0x89, 0xba, 0xbc, 0xa1, 0xc2, 0xd8, + 0xef, 0x43, 0xc6, 0x9d, 0x4e, 0x4c, 0x3e, 0x33, 0xaa, 0xa2, 0x68, 0xdd, 0xe9, 0xa4, 0x37, 0x0f, + 0x6a, 0x4f, 0x20, 0xd3, 0x9b, 0xe3, 0x13, 0x8a, 0x57, 0xaa, 0x4f, 0xa9, 0x1c, 0xda, 0xc5, 0xb8, + 0xa7, 0x71, 0x02, 0xce, 0xa8, 0xeb, 0x66, 0xbd, 0xc6, 0x8b, 0xbe, 0xce, 0xc2, 0x77, 0xd9, 0x2f, + 0x21, 0x8f, 0x43, 0xc8, 0x7b, 0xbe, 0xe5, 0x79, 0xc4, 0xd7, 0xb7, 0x21, 0xc1, 0xe6, 0xd2, 0x54, + 0x82, 0xcd, 0xe3, 0xe1, 0x11, 0x07, 0x18, 0x7c, 0x0c, 0x26, 0xa3, 0xe1, 0xb1, 0x2d, 0x68, 0xfc, + 0x28, 0xfc, 0xac, 0xe1, 0x47, 0x20, 0x6b, 0xa4, 0xf9, 0xb6, 0x6d, 0xd7, 0x7e, 0x05, 0x69, 0x3e, + 0xb9, 0xf6, 0xe6, 0x2b, 0x7a, 0xbf, 0x07, 0xa9, 0xfe, 0x98, 0xf6, 0x85, 0xbe, 0x5c, 0x73, 0x7f, + 0x7d, 0x6a, 0xfa, 0x86, 0x40, 0x6d, 0xb6, 0xf0, 0x6f, 0x05, 0xa0, 0xcb, 0x7d, 0x11, 0x01, 0x0b, + 0x63, 0x22, 0xa6, 0x70, 0x11, 0x93, 0x37, 0x40, 0x78, 0x6b, 0xe2, 0x89, 0x43, 0x8b, 0x0f, 0xd6, + 0x58, 0x3c, 0x3f, 0xeb, 0x89, 0xe0, 0xe4, 0x82, 0x48, 0x65, 0xb0, 0x32, 0x76, 0x27, 0x57, 0xc7, + 0xee, 0xd7, 0x79, 0x9e, 0xae, 0x85, 0x01, 0x39, 0xa4, 0xae, 0xd3, 0x6f, 0xd0, 0x6b, 0xa1, 0x5f, + 0xf3, 0xe5, 0x6a, 0xfd, 0xdc, 0x9d, 0xda, 0x30, 0x77, 0x7f, 0xa8, 0x80, 0x16, 0xea, 0x10, 0xb5, + 0x71, 0x6d, 0xf2, 0x72, 0x08, 0x5f, 0x1d, 0x5c, 0xad, 0xc1, 0xf7, 0xbc, 0xb1, 0x97, 0x4e, 0xfb, + 0x09, 0x85, 0x20, 0x81, 0x3c, 0x74, 0x5c, 0x97, 0x3c, 0x1e, 0xae, 0xb9, 0x8d, 0x80, 0xf1, 0x77, + 0xb9, 0x4f, 0xaf, 0xe5, 0x6b, 0x40, 0x43, 0x82, 0x41, 0xaf, 0x79, 0x4e, 0x88, 0x6b, 0x23, 0x4b, + 0x38, 0x9c, 0x26, 0xae, 0x6d, 0xd0, 0xeb, 0x1a, 0x01, 0x2d, 0x8c, 0x24, 0xbf, 0x81, 0x51, 0x00, + 0x53, 0x9f, 0x32, 0xc4, 0x86, 0xbf, 0x95, 0x48, 0x34, 0x4a, 0xf0, 0x25, 0xc7, 0xb9, 0xd4, 0x26, + 0x41, 0x29, 0x89, 0x27, 0x11, 0x1b, 0x6e, 0x7f, 0x4c, 0xac, 0x2b, 0x51, 0xff, 0xe2, 0x73, 0xa7, + 0x71, 0x02, 0xaf, 0xff, 0x57, 0xff, 0xa6, 0x40, 0x61, 0xe9, 0x63, 0xa0, 0x7f, 0x17, 0xf6, 0xbb, + 0xed, 0xb7, 0xcf, 0x4f, 0x4f, 0xcc, 0xb3, 0xee, 0xdb, 0x66, 0xef, 0x67, 0x9d, 0x53, 0xf3, 0xdd, + 0xf3, 0x9f, 0x9e, 0x5f, 0xbc, 0x77, 0x5e, 0xdc, 0x2a, 0xef, 0x3c, 0x7d, 0x56, 0xcd, 0xbd, 0xeb, + 0x3e, 0x71, 0xe9, 0xb5, 0xbb, 0x09, 0xdd, 0x31, 0x4e, 0x2f, 0x2f, 0x7a, 0xa7, 0x45, 0x45, 0xa0, + 0x3b, 0x3e, 0x99, 0x51, 0x46, 0x10, 0xfd, 0x1a, 0x1c, 0xac, 0x41, 0x1f, 0x5f, 0x9c, 0x9d, 0xb5, + 0x7b, 0xc5, 0x44, 0x79, 0xf7, 0xe9, 0xb3, 0x6a, 0xa1, 0xe3, 0x13, 0x71, 0x4b, 0xa2, 0x44, 0x1d, + 0x4a, 0xab, 0x12, 0x17, 0x9d, 0x8b, 0xee, 0x9b, 0x8f, 0x8b, 0xd5, 0x72, 0xf1, 0xe9, 0xb3, 0x6a, + 0x3e, 0xfc, 0xec, 0x71, 0x7c, 0x59, 0xfb, 0xcd, 0x1f, 0x2b, 0x5b, 0x7f, 0xfa, 0xb0, 0xa2, 0xb4, + 0x1e, 0x7f, 0x74, 0x5b, 0x51, 0x3e, 0xbe, 0xad, 0x28, 0xff, 0xbc, 0xad, 0x28, 0x1f, 0xdc, 0x55, + 0xb6, 0x3e, 0xbe, 0xab, 0x6c, 0xfd, 0xfd, 0xae, 0xb2, 0xf5, 0xf3, 0xe6, 0xd0, 0x61, 0xa3, 0x69, + 0x9f, 0x67, 0xb3, 0x11, 0xff, 0x92, 0x0a, 0x17, 0x96, 0xe7, 0x34, 0x56, 0x7e, 0x44, 0xf5, 0xd3, + 0xf8, 0xb9, 0xf9, 0xfe, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xee, 0x9b, 0x90, 0x95, 0xf6, 0x12, + 0x00, 0x00, +} + +func (m *PartSetHeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -1595,29 +1833,32 @@ func (m *Data) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Data) MarshalTo(dAtA []byte) (int, error) { +func (m *PartSetHeader) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Data) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PartSetHeader) 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 - } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0x12 + } + if m.Total != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Total)) + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *Vote) Marshal() (dAtA []byte, err error) { +func (m *Part) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -1627,73 +1868,63 @@ func (m *Vote) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Vote) MarshalTo(dAtA []byte) (int, error) { +func (m *Part) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Vote) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Part) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.NonRpExtensionSignature) > 0 { - i -= len(m.NonRpExtensionSignature) - copy(dAtA[i:], m.NonRpExtensionSignature) - i = encodeVarintTypes(dAtA, i, uint64(len(m.NonRpExtensionSignature))) - i-- - dAtA[i] = 0x62 + { + size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) } - if len(m.NonRpExtension) > 0 { - i -= len(m.NonRpExtension) - copy(dAtA[i:], m.NonRpExtension) - i = encodeVarintTypes(dAtA, i, uint64(len(m.NonRpExtension))) + i-- + dAtA[i] = 0x1a + if len(m.Bytes) > 0 { + i -= len(m.Bytes) + copy(dAtA[i:], m.Bytes) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Bytes))) i-- - dAtA[i] = 0x5a - } - if len(m.ExtensionSignature) > 0 { - i -= len(m.ExtensionSignature) - copy(dAtA[i:], m.ExtensionSignature) - i = encodeVarintTypes(dAtA, i, uint64(len(m.ExtensionSignature))) - i-- - dAtA[i] = 0x52 - } - if len(m.Extension) > 0 { - i -= len(m.Extension) - copy(dAtA[i:], m.Extension) - i = encodeVarintTypes(dAtA, i, uint64(len(m.Extension))) - i-- - dAtA[i] = 0x4a - } - if len(m.Signature) > 0 { - i -= len(m.Signature) - copy(dAtA[i:], m.Signature) - i = encodeVarintTypes(dAtA, i, uint64(len(m.Signature))) - i-- - dAtA[i] = 0x42 - } - if m.ValidatorIndex != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.ValidatorIndex)) - i-- - dAtA[i] = 0x38 + dAtA[i] = 0x12 } - if len(m.ValidatorAddress) > 0 { - i -= len(m.ValidatorAddress) - copy(dAtA[i:], m.ValidatorAddress) - i = encodeVarintTypes(dAtA, i, uint64(len(m.ValidatorAddress))) + if m.Index != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Index)) i-- - dAtA[i] = 0x32 + dAtA[i] = 0x8 } - n6, err6 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):]) - if err6 != nil { - return 0, err6 + return len(dAtA) - i, nil +} + +func (m *BlockID) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - i -= n6 - i = encodeVarintTypes(dAtA, i, uint64(n6)) - i-- - dAtA[i] = 0x2a + return dAtA[:n], nil +} + +func (m *BlockID) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BlockID) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l { - size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.PartSetHeader.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -1701,26 +1932,18 @@ func (m *Vote) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintTypes(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x22 - if m.Round != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.Round)) - i-- - dAtA[i] = 0x18 - } - if m.Height != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.Height)) - i-- - dAtA[i] = 0x10 - } - if m.Type != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.Type)) + dAtA[i] = 0x12 + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *Commit) Marshal() (dAtA []byte, err error) { +func (m *Header) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -1730,32 +1953,81 @@ func (m *Commit) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Commit) MarshalTo(dAtA []byte) (int, error) { +func (m *Header) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Signatures) > 0 { - for iNdEx := len(m.Signatures) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Signatures[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } + if len(m.ProposerAddress) > 0 { + i -= len(m.ProposerAddress) + copy(dAtA[i:], m.ProposerAddress) + i = encodeVarintTypes(dAtA, i, uint64(len(m.ProposerAddress))) + i-- + dAtA[i] = 0x72 + } + if len(m.EvidenceHash) > 0 { + i -= len(m.EvidenceHash) + copy(dAtA[i:], m.EvidenceHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.EvidenceHash))) + i-- + dAtA[i] = 0x6a + } + if len(m.LastResultsHash) > 0 { + i -= len(m.LastResultsHash) + copy(dAtA[i:], m.LastResultsHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.LastResultsHash))) + i-- + dAtA[i] = 0x62 + } + if len(m.AppHash) > 0 { + i -= len(m.AppHash) + copy(dAtA[i:], m.AppHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.AppHash))) + i-- + dAtA[i] = 0x5a + } + if len(m.ConsensusHash) > 0 { + i -= len(m.ConsensusHash) + copy(dAtA[i:], m.ConsensusHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.ConsensusHash))) + i-- + dAtA[i] = 0x52 + } + if len(m.NextValidatorsHash) > 0 { + i -= len(m.NextValidatorsHash) + copy(dAtA[i:], m.NextValidatorsHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.NextValidatorsHash))) + i-- + dAtA[i] = 0x4a + } + if len(m.ValidatorsHash) > 0 { + i -= len(m.ValidatorsHash) + copy(dAtA[i:], m.ValidatorsHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.ValidatorsHash))) + i-- + dAtA[i] = 0x42 + } + if len(m.DataHash) > 0 { + i -= len(m.DataHash) + copy(dAtA[i:], m.DataHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.DataHash))) + i-- + dAtA[i] = 0x3a + } + if len(m.LastCommitHash) > 0 { + i -= len(m.LastCommitHash) + copy(dAtA[i:], m.LastCommitHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.LastCommitHash))) + i-- + dAtA[i] = 0x32 } { - size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.LastBlockId.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -1763,21 +2035,41 @@ func (m *Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintTypes(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a - if m.Round != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.Round)) - i-- - dAtA[i] = 0x10 + dAtA[i] = 0x2a + n4, err4 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):]) + if err4 != nil { + return 0, err4 } + i -= n4 + i = encodeVarintTypes(dAtA, i, uint64(n4)) + i-- + dAtA[i] = 0x22 if m.Height != 0 { i = encodeVarintTypes(dAtA, i, uint64(m.Height)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x18 + } + if len(m.ChainID) > 0 { + i -= len(m.ChainID) + copy(dAtA[i:], m.ChainID) + i = encodeVarintTypes(dAtA, i, uint64(len(m.ChainID))) + i-- + dAtA[i] = 0x12 } + { + size, err := m.Version.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa return len(dAtA) - i, nil } -func (m *CommitSig) Marshal() (dAtA []byte, err error) { +func (m *Data) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -1787,47 +2079,41 @@ func (m *CommitSig) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *CommitSig) MarshalTo(dAtA []byte) (int, error) { +func (m *Data) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *CommitSig) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Data) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Signature) > 0 { - i -= len(m.Signature) - copy(dAtA[i:], m.Signature) - i = encodeVarintTypes(dAtA, i, uint64(len(m.Signature))) + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) i-- - dAtA[i] = 0x22 - } - n9, err9 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):]) - if err9 != nil { - return 0, err9 + dAtA[i] = 0x32 } - i -= n9 - i = encodeVarintTypes(dAtA, i, uint64(n9)) - i-- - dAtA[i] = 0x1a - if len(m.ValidatorAddress) > 0 { - i -= len(m.ValidatorAddress) - copy(dAtA[i:], m.ValidatorAddress) - i = encodeVarintTypes(dAtA, i, uint64(len(m.ValidatorAddress))) + if m.SquareSize != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.SquareSize)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x28 } - if m.BlockIdFlag != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.BlockIdFlag)) - i-- - dAtA[i] = 0x8 + 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 *ExtendedCommit) Marshal() (dAtA []byte, err error) { +func (m *Blob) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -1837,54 +2123,44 @@ func (m *ExtendedCommit) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ExtendedCommit) MarshalTo(dAtA []byte) (int, error) { +func (m *Blob) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ExtendedCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Blob) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.ExtendedSignatures) > 0 { - for iNdEx := len(m.ExtendedSignatures) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.ExtendedSignatures[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } + if m.NamespaceVersion != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.NamespaceVersion)) + i-- + dAtA[i] = 0x20 } - { - size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) + if m.ShareVersion != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.ShareVersion)) + i-- + dAtA[i] = 0x18 } - i-- - dAtA[i] = 0x1a - if m.Round != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.Round)) + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } - if m.Height != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.Height)) + if len(m.NamespaceId) > 0 { + i -= len(m.NamespaceId) + copy(dAtA[i:], m.NamespaceId) + i = encodeVarintTypes(dAtA, i, uint64(len(m.NamespaceId))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *ExtendedCommitSig) Marshal() (dAtA []byte, err error) { +func (m *Vote) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -1894,12 +2170,12 @@ func (m *ExtendedCommitSig) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ExtendedCommitSig) MarshalTo(dAtA []byte) (int, error) { +func (m *Vote) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ExtendedCommitSig) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Vote) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -1909,94 +2185,56 @@ func (m *ExtendedCommitSig) MarshalToSizedBuffer(dAtA []byte) (int, error) { copy(dAtA[i:], m.NonRpExtensionSignature) i = encodeVarintTypes(dAtA, i, uint64(len(m.NonRpExtensionSignature))) i-- - dAtA[i] = 0x42 + dAtA[i] = 0x62 } if len(m.NonRpExtension) > 0 { i -= len(m.NonRpExtension) copy(dAtA[i:], m.NonRpExtension) i = encodeVarintTypes(dAtA, i, uint64(len(m.NonRpExtension))) i-- - dAtA[i] = 0x3a + dAtA[i] = 0x5a } if len(m.ExtensionSignature) > 0 { i -= len(m.ExtensionSignature) copy(dAtA[i:], m.ExtensionSignature) i = encodeVarintTypes(dAtA, i, uint64(len(m.ExtensionSignature))) i-- - dAtA[i] = 0x32 + dAtA[i] = 0x52 } if len(m.Extension) > 0 { i -= len(m.Extension) copy(dAtA[i:], m.Extension) i = encodeVarintTypes(dAtA, i, uint64(len(m.Extension))) i-- - dAtA[i] = 0x2a + dAtA[i] = 0x4a } if len(m.Signature) > 0 { i -= len(m.Signature) copy(dAtA[i:], m.Signature) i = encodeVarintTypes(dAtA, i, uint64(len(m.Signature))) i-- - dAtA[i] = 0x22 + dAtA[i] = 0x42 } - n11, err11 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):]) - if err11 != nil { - return 0, err11 + if m.ValidatorIndex != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.ValidatorIndex)) + i-- + dAtA[i] = 0x38 } - i -= n11 - i = encodeVarintTypes(dAtA, i, uint64(n11)) - i-- - dAtA[i] = 0x1a if len(m.ValidatorAddress) > 0 { i -= len(m.ValidatorAddress) copy(dAtA[i:], m.ValidatorAddress) i = encodeVarintTypes(dAtA, i, uint64(len(m.ValidatorAddress))) i-- - dAtA[i] = 0x12 - } - if m.BlockIdFlag != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.BlockIdFlag)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *Proposal) 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 *Proposal) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Signature) > 0 { - i -= len(m.Signature) - copy(dAtA[i:], m.Signature) - i = encodeVarintTypes(dAtA, i, uint64(len(m.Signature))) - i-- - dAtA[i] = 0x3a + dAtA[i] = 0x32 } - n12, err12 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):]) - if err12 != nil { - return 0, err12 + n6, err6 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):]) + if err6 != nil { + return 0, err6 } - i -= n12 - i = encodeVarintTypes(dAtA, i, uint64(n12)) + i -= n6 + i = encodeVarintTypes(dAtA, i, uint64(n6)) i-- - dAtA[i] = 0x32 + dAtA[i] = 0x2a { size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i]) if err != nil { @@ -2006,12 +2244,7 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintTypes(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x2a - if m.PolRound != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.PolRound)) - i-- - dAtA[i] = 0x20 - } + dAtA[i] = 0x22 if m.Round != 0 { i = encodeVarintTypes(dAtA, i, uint64(m.Round)) i-- @@ -2030,7 +2263,7 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *SignedHeader) Marshal() (dAtA []byte, err error) { +func (m *Commit) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2040,44 +2273,54 @@ func (m *SignedHeader) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SignedHeader) MarshalTo(dAtA []byte) (int, error) { +func (m *Commit) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SignedHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Commit != nil { - { - size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.Signatures) > 0 { + for iNdEx := len(m.Signatures) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Signatures[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 } - i-- - dAtA[i] = 0x12 } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) + { + size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if m.Round != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Round)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x10 + } + if m.Height != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *LightBlock) Marshal() (dAtA []byte, err error) { +func (m *CommitSig) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2087,44 +2330,47 @@ func (m *LightBlock) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *LightBlock) MarshalTo(dAtA []byte) (int, error) { +func (m *CommitSig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *LightBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *CommitSig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.ValidatorSet != nil { - { - size, err := m.ValidatorSet.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) - } + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x22 + } + n9, err9 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):]) + if err9 != nil { + return 0, err9 + } + i -= n9 + i = encodeVarintTypes(dAtA, i, uint64(n9)) + i-- + dAtA[i] = 0x1a + if len(m.ValidatorAddress) > 0 { + i -= len(m.ValidatorAddress) + copy(dAtA[i:], m.ValidatorAddress) + i = encodeVarintTypes(dAtA, i, uint64(len(m.ValidatorAddress))) i-- dAtA[i] = 0x12 } - if m.SignedHeader != nil { - { - size, err := m.SignedHeader.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) - } + if m.BlockIdFlag != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.BlockIdFlag)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *BlockMeta) Marshal() (dAtA []byte, err error) { +func (m *ExtendedCommit) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2134,23 +2380,32 @@ func (m *BlockMeta) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *BlockMeta) MarshalTo(dAtA []byte) (int, error) { +func (m *ExtendedCommit) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BlockMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ExtendedCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.NumTxs != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.NumTxs)) - i-- - dAtA[i] = 0x20 + if len(m.ExtendedSignatures) > 0 { + for iNdEx := len(m.ExtendedSignatures) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ExtendedSignatures[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } } { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -2159,25 +2414,20 @@ func (m *BlockMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) { } i-- dAtA[i] = 0x1a - if m.BlockSize != 0 { - i = encodeVarintTypes(dAtA, i, uint64(m.BlockSize)) + if m.Round != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Round)) i-- dAtA[i] = 0x10 } - { - size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) + if m.Height != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 } - i-- - dAtA[i] = 0xa return len(dAtA) - i, nil } -func (m *TxProof) Marshal() (dAtA []byte, err error) { +func (m *ExtendedCommitSig) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2187,443 +2437,1545 @@ func (m *TxProof) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TxProof) MarshalTo(dAtA []byte) (int, error) { +func (m *ExtendedCommitSig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TxProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ExtendedCommitSig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Proof != nil { - { - size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTypes(dAtA, i, uint64(size)) - } + if len(m.NonRpExtensionSignature) > 0 { + i -= len(m.NonRpExtensionSignature) + copy(dAtA[i:], m.NonRpExtensionSignature) + i = encodeVarintTypes(dAtA, i, uint64(len(m.NonRpExtensionSignature))) i-- - dAtA[i] = 0x1a + dAtA[i] = 0x42 } - if len(m.Data) > 0 { - i -= len(m.Data) - copy(dAtA[i:], m.Data) - i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) + if len(m.NonRpExtension) > 0 { + i -= len(m.NonRpExtension) + copy(dAtA[i:], m.NonRpExtension) + i = encodeVarintTypes(dAtA, i, uint64(len(m.NonRpExtension))) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x3a } - if len(m.RootHash) > 0 { - i -= len(m.RootHash) - copy(dAtA[i:], m.RootHash) - i = encodeVarintTypes(dAtA, i, uint64(len(m.RootHash))) + if len(m.ExtensionSignature) > 0 { + i -= len(m.ExtensionSignature) + copy(dAtA[i:], m.ExtensionSignature) + i = encodeVarintTypes(dAtA, i, uint64(len(m.ExtensionSignature))) i-- - dAtA[i] = 0xa + dAtA[i] = 0x32 } - return len(dAtA) - i, nil -} - -func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { - offset -= sovTypes(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ + if len(m.Extension) > 0 { + i -= len(m.Extension) + copy(dAtA[i:], m.Extension) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Extension))) + i-- + dAtA[i] = 0x2a } - dAtA[offset] = uint8(v) - return base -} -func (m *PartSetHeader) Size() (n int) { - if m == nil { - return 0 + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x22 } - var l int - _ = l - if m.Total != 0 { - n += 1 + sovTypes(uint64(m.Total)) + n11, err11 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):]) + if err11 != nil { + return 0, err11 } - l = len(m.Hash) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + i -= n11 + i = encodeVarintTypes(dAtA, i, uint64(n11)) + i-- + dAtA[i] = 0x1a + if len(m.ValidatorAddress) > 0 { + i -= len(m.ValidatorAddress) + copy(dAtA[i:], m.ValidatorAddress) + i = encodeVarintTypes(dAtA, i, uint64(len(m.ValidatorAddress))) + i-- + dAtA[i] = 0x12 } - return n + if m.BlockIdFlag != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.BlockIdFlag)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil } -func (m *Part) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Index != 0 { - n += 1 + sovTypes(uint64(m.Index)) - } - l = len(m.Bytes) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) +func (m *Proposal) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - l = m.Proof.Size() - n += 1 + l + sovTypes(uint64(l)) - return n + return dAtA[:n], nil } -func (m *BlockID) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Hash) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) - } - l = m.PartSetHeader.Size() - n += 1 + l + sovTypes(uint64(l)) - return n +func (m *Proposal) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Header) Size() (n int) { - if m == nil { - return 0 - } +func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = m.Version.Size() - n += 1 + l + sovTypes(uint64(l)) - l = len(m.ChainID) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) - } - if m.Height != 0 { - n += 1 + sovTypes(uint64(m.Height)) - } - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time) - n += 1 + l + sovTypes(uint64(l)) - l = m.LastBlockId.Size() - n += 1 + l + sovTypes(uint64(l)) - l = len(m.LastCommitHash) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) - } - l = len(m.DataHash) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) - } - l = len(m.ValidatorsHash) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + if len(m.Signature) > 0 { + i -= len(m.Signature) + copy(dAtA[i:], m.Signature) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Signature))) + i-- + dAtA[i] = 0x3a } - l = len(m.NextValidatorsHash) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + n12, err12 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):]) + if err12 != nil { + return 0, err12 } - l = len(m.ConsensusHash) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + i -= n12 + i = encodeVarintTypes(dAtA, i, uint64(n12)) + i-- + dAtA[i] = 0x32 + { + size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) } - l = len(m.AppHash) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + i-- + dAtA[i] = 0x2a + if m.PolRound != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.PolRound)) + i-- + dAtA[i] = 0x20 } - l = len(m.LastResultsHash) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + if m.Round != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Round)) + i-- + dAtA[i] = 0x18 } - l = len(m.EvidenceHash) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + if m.Height != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x10 } - l = len(m.ProposerAddress) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + if m.Type != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *Data) 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)) - } +func (m *SignedHeader) 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 n + return dAtA[:n], nil } -func (m *Vote) Size() (n int) { - if m == nil { - return 0 - } +func (m *SignedHeader) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SignedHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Type != 0 { - n += 1 + sovTypes(uint64(m.Type)) - } - if m.Height != 0 { - n += 1 + sovTypes(uint64(m.Height)) - } - if m.Round != 0 { - n += 1 + sovTypes(uint64(m.Round)) - } - l = m.BlockID.Size() - n += 1 + l + sovTypes(uint64(l)) - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp) - n += 1 + l + sovTypes(uint64(l)) - l = len(m.ValidatorAddress) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) - } - if m.ValidatorIndex != 0 { - n += 1 + sovTypes(uint64(m.ValidatorIndex)) - } - l = len(m.Signature) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) - } - l = len(m.Extension) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) - } - l = len(m.ExtensionSignature) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) - } - l = len(m.NonRpExtension) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + if m.Commit != nil { + { + size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - l = len(m.NonRpExtensionSignature) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *Commit) Size() (n int) { - if m == nil { - return 0 +func (m *LightBlock) 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 *LightBlock) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LightBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Height != 0 { - n += 1 + sovTypes(uint64(m.Height)) - } - if m.Round != 0 { - n += 1 + sovTypes(uint64(m.Round)) + if m.ValidatorSet != nil { + { + size, err := m.ValidatorSet.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - l = m.BlockID.Size() - n += 1 + l + sovTypes(uint64(l)) - if len(m.Signatures) > 0 { - for _, e := range m.Signatures { - l = e.Size() - n += 1 + l + sovTypes(uint64(l)) + if m.SignedHeader != nil { + { + size, err := m.SignedHeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *CommitSig) Size() (n int) { - if m == nil { - return 0 +func (m *BlockMeta) 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 *BlockMeta) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BlockMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.BlockIdFlag != 0 { - n += 1 + sovTypes(uint64(m.BlockIdFlag)) + if m.NumTxs != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.NumTxs)) + i-- + dAtA[i] = 0x20 } - l = len(m.ValidatorAddress) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) } - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp) - n += 1 + l + sovTypes(uint64(l)) - l = len(m.Signature) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + i-- + dAtA[i] = 0x1a + if m.BlockSize != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.BlockSize)) + i-- + dAtA[i] = 0x10 } - return n + { + size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil } -func (m *ExtendedCommit) Size() (n int) { - if m == nil { - return 0 +func (m *TxProof) 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 *TxProof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TxProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Height != 0 { - n += 1 + sovTypes(uint64(m.Height)) + if m.Proof != nil { + { + size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - if m.Round != 0 { - n += 1 + sovTypes(uint64(m.Round)) + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x12 } - l = m.BlockID.Size() - n += 1 + l + sovTypes(uint64(l)) - if len(m.ExtendedSignatures) > 0 { - for _, e := range m.ExtendedSignatures { - l = e.Size() - n += 1 + l + sovTypes(uint64(l)) - } + if len(m.RootHash) > 0 { + i -= len(m.RootHash) + copy(dAtA[i:], m.RootHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.RootHash))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *ExtendedCommitSig) Size() (n int) { - if m == nil { - return 0 +func (m *IndexWrapper) 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 *IndexWrapper) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *IndexWrapper) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.BlockIdFlag != 0 { - n += 1 + sovTypes(uint64(m.BlockIdFlag)) + if len(m.TypeId) > 0 { + i -= len(m.TypeId) + copy(dAtA[i:], m.TypeId) + i = encodeVarintTypes(dAtA, i, uint64(len(m.TypeId))) + i-- + dAtA[i] = 0x1a } - l = len(m.ValidatorAddress) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + if len(m.ShareIndexes) > 0 { + dAtA22 := make([]byte, len(m.ShareIndexes)*10) + var j21 int + for _, num := range m.ShareIndexes { + for num >= 1<<7 { + dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j21++ + } + dAtA22[j21] = uint8(num) + j21++ + } + i -= j21 + copy(dAtA[i:], dAtA22[:j21]) + i = encodeVarintTypes(dAtA, i, uint64(j21)) + i-- + dAtA[i] = 0x12 } - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp) - n += 1 + l + sovTypes(uint64(l)) - l = len(m.Signature) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + if len(m.Tx) > 0 { + i -= len(m.Tx) + copy(dAtA[i:], m.Tx) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Tx))) + i-- + dAtA[i] = 0xa } - l = len(m.Extension) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + return len(dAtA) - i, nil +} + +func (m *BlobTx) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - l = len(m.ExtensionSignature) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + return dAtA[:n], nil +} + +func (m *BlobTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BlobTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.TypeId) > 0 { + i -= len(m.TypeId) + copy(dAtA[i:], m.TypeId) + i = encodeVarintTypes(dAtA, i, uint64(len(m.TypeId))) + i-- + dAtA[i] = 0x1a } - l = len(m.NonRpExtension) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + if len(m.Blobs) > 0 { + for iNdEx := len(m.Blobs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Blobs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } } - l = len(m.NonRpExtensionSignature) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + if len(m.Tx) > 0 { + i -= len(m.Tx) + copy(dAtA[i:], m.Tx) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Tx))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *Proposal) Size() (n int) { - if m == nil { - return 0 +func (m *ShareProof) 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 *ShareProof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ShareProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Type != 0 { - n += 1 + sovTypes(uint64(m.Type)) + if m.NamespaceVersion != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.NamespaceVersion)) + i-- + dAtA[i] = 0x28 } - if m.Height != 0 { - n += 1 + sovTypes(uint64(m.Height)) + if m.RowProof != nil { + { + size, err := m.RowProof.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } - if m.Round != 0 { - n += 1 + sovTypes(uint64(m.Round)) + if len(m.NamespaceId) > 0 { + i -= len(m.NamespaceId) + copy(dAtA[i:], m.NamespaceId) + i = encodeVarintTypes(dAtA, i, uint64(len(m.NamespaceId))) + i-- + dAtA[i] = 0x1a } - if m.PolRound != 0 { - n += 1 + sovTypes(uint64(m.PolRound)) + if len(m.ShareProofs) > 0 { + for iNdEx := len(m.ShareProofs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ShareProofs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } } - l = m.BlockID.Size() - n += 1 + l + sovTypes(uint64(l)) - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp) - n += 1 + l + sovTypes(uint64(l)) - l = len(m.Signature) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) + if len(m.Data) > 0 { + for iNdEx := len(m.Data) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Data[iNdEx]) + copy(dAtA[i:], m.Data[iNdEx]) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Data[iNdEx]))) + i-- + dAtA[i] = 0xa + } } - return n + return len(dAtA) - i, nil } -func (m *SignedHeader) Size() (n int) { +func (m *RowProof) 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 *RowProof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RowProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.EndRow != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.EndRow)) + i-- + dAtA[i] = 0x28 + } + if m.StartRow != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.StartRow)) + i-- + dAtA[i] = 0x20 + } + if len(m.Root) > 0 { + i -= len(m.Root) + copy(dAtA[i:], m.Root) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Root))) + i-- + dAtA[i] = 0x1a + } + if len(m.Proofs) > 0 { + for iNdEx := len(m.Proofs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Proofs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.RowRoots) > 0 { + for iNdEx := len(m.RowRoots) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.RowRoots[iNdEx]) + copy(dAtA[i:], m.RowRoots[iNdEx]) + i = encodeVarintTypes(dAtA, i, uint64(len(m.RowRoots[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *NMTProof) 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 *NMTProof) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *NMTProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.LeafHash) > 0 { + i -= len(m.LeafHash) + copy(dAtA[i:], m.LeafHash) + i = encodeVarintTypes(dAtA, i, uint64(len(m.LeafHash))) + i-- + dAtA[i] = 0x22 + } + if len(m.Nodes) > 0 { + for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Nodes[iNdEx]) + copy(dAtA[i:], m.Nodes[iNdEx]) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Nodes[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if m.End != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.End)) + i-- + dAtA[i] = 0x10 + } + if m.Start != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Start)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { + offset -= sovTypes(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *PartSetHeader) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovTypes(uint64(l)) + if m.Total != 0 { + n += 1 + sovTypes(uint64(m.Total)) } - if m.Commit != nil { - l = m.Commit.Size() + l = len(m.Hash) + if l > 0 { n += 1 + l + sovTypes(uint64(l)) } return n } -func (m *LightBlock) Size() (n int) { +func (m *Part) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.SignedHeader != nil { - l = m.SignedHeader.Size() - n += 1 + l + sovTypes(uint64(l)) + if m.Index != 0 { + n += 1 + sovTypes(uint64(m.Index)) } - if m.ValidatorSet != nil { - l = m.ValidatorSet.Size() + l = len(m.Bytes) + if l > 0 { n += 1 + l + sovTypes(uint64(l)) } + l = m.Proof.Size() + n += 1 + l + sovTypes(uint64(l)) return n } -func (m *BlockMeta) Size() (n int) { +func (m *BlockID) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = m.BlockID.Size() - n += 1 + l + sovTypes(uint64(l)) - if m.BlockSize != 0 { - n += 1 + sovTypes(uint64(m.BlockSize)) + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) } - l = m.Header.Size() + l = m.PartSetHeader.Size() n += 1 + l + sovTypes(uint64(l)) - if m.NumTxs != 0 { - n += 1 + sovTypes(uint64(m.NumTxs)) - } return n } -func (m *TxProof) Size() (n int) { +func (m *Header) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.RootHash) + l = m.Version.Size() + n += 1 + l + sovTypes(uint64(l)) + l = len(m.ChainID) if l > 0 { n += 1 + l + sovTypes(uint64(l)) } - l = len(m.Data) + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time) + n += 1 + l + sovTypes(uint64(l)) + l = m.LastBlockId.Size() + n += 1 + l + sovTypes(uint64(l)) + l = len(m.LastCommitHash) if l > 0 { n += 1 + l + sovTypes(uint64(l)) } - if m.Proof != nil { - l = m.Proof.Size() + l = len(m.DataHash) + if l > 0 { n += 1 + l + sovTypes(uint64(l)) } - return n -} - -func sovTypes(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} + l = len(m.ValidatorsHash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.NextValidatorsHash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.ConsensusHash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.AppHash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.LastResultsHash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.EvidenceHash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.ProposerAddress) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *Data) 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)) + } + } + if m.SquareSize != 0 { + n += 1 + sovTypes(uint64(m.SquareSize)) + } + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *Blob) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.NamespaceId) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.ShareVersion != 0 { + n += 1 + sovTypes(uint64(m.ShareVersion)) + } + if m.NamespaceVersion != 0 { + n += 1 + sovTypes(uint64(m.NamespaceVersion)) + } + return n +} + +func (m *Vote) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Type != 0 { + n += 1 + sovTypes(uint64(m.Type)) + } + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + if m.Round != 0 { + n += 1 + sovTypes(uint64(m.Round)) + } + l = m.BlockID.Size() + n += 1 + l + sovTypes(uint64(l)) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp) + n += 1 + l + sovTypes(uint64(l)) + l = len(m.ValidatorAddress) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.ValidatorIndex != 0 { + n += 1 + sovTypes(uint64(m.ValidatorIndex)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.Extension) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.ExtensionSignature) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.NonRpExtension) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.NonRpExtensionSignature) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *Commit) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + if m.Round != 0 { + n += 1 + sovTypes(uint64(m.Round)) + } + l = m.BlockID.Size() + n += 1 + l + sovTypes(uint64(l)) + if len(m.Signatures) > 0 { + for _, e := range m.Signatures { + l = e.Size() + n += 1 + l + sovTypes(uint64(l)) + } + } + return n +} + +func (m *CommitSig) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockIdFlag != 0 { + n += 1 + sovTypes(uint64(m.BlockIdFlag)) + } + l = len(m.ValidatorAddress) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp) + n += 1 + l + sovTypes(uint64(l)) + l = len(m.Signature) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *ExtendedCommit) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + if m.Round != 0 { + n += 1 + sovTypes(uint64(m.Round)) + } + l = m.BlockID.Size() + n += 1 + l + sovTypes(uint64(l)) + if len(m.ExtendedSignatures) > 0 { + for _, e := range m.ExtendedSignatures { + l = e.Size() + n += 1 + l + sovTypes(uint64(l)) + } + } + return n +} + +func (m *ExtendedCommitSig) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockIdFlag != 0 { + n += 1 + sovTypes(uint64(m.BlockIdFlag)) + } + l = len(m.ValidatorAddress) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp) + n += 1 + l + sovTypes(uint64(l)) + l = len(m.Signature) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.Extension) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.ExtensionSignature) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.NonRpExtension) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.NonRpExtensionSignature) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *Proposal) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Type != 0 { + n += 1 + sovTypes(uint64(m.Type)) + } + if m.Height != 0 { + n += 1 + sovTypes(uint64(m.Height)) + } + if m.Round != 0 { + n += 1 + sovTypes(uint64(m.Round)) + } + if m.PolRound != 0 { + n += 1 + sovTypes(uint64(m.PolRound)) + } + l = m.BlockID.Size() + n += 1 + l + sovTypes(uint64(l)) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp) + n += 1 + l + sovTypes(uint64(l)) + l = len(m.Signature) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *SignedHeader) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.Commit != nil { + l = m.Commit.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *LightBlock) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SignedHeader != nil { + l = m.SignedHeader.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.ValidatorSet != nil { + l = m.ValidatorSet.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *BlockMeta) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.BlockID.Size() + n += 1 + l + sovTypes(uint64(l)) + if m.BlockSize != 0 { + n += 1 + sovTypes(uint64(m.BlockSize)) + } + l = m.Header.Size() + n += 1 + l + sovTypes(uint64(l)) + if m.NumTxs != 0 { + n += 1 + sovTypes(uint64(m.NumTxs)) + } + return n +} + +func (m *TxProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.RootHash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.Proof != nil { + l = m.Proof.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *IndexWrapper) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Tx) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if len(m.ShareIndexes) > 0 { + l = 0 + for _, e := range m.ShareIndexes { + l += sovTypes(uint64(e)) + } + n += 1 + sovTypes(uint64(l)) + l + } + l = len(m.TypeId) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *BlobTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Tx) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if len(m.Blobs) > 0 { + for _, e := range m.Blobs { + l = e.Size() + n += 1 + l + sovTypes(uint64(l)) + } + } + l = len(m.TypeId) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func (m *ShareProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Data) > 0 { + for _, b := range m.Data { + l = len(b) + n += 1 + l + sovTypes(uint64(l)) + } + } + if len(m.ShareProofs) > 0 { + for _, e := range m.ShareProofs { + l = e.Size() + n += 1 + l + sovTypes(uint64(l)) + } + } + l = len(m.NamespaceId) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.RowProof != nil { + l = m.RowProof.Size() + n += 1 + l + sovTypes(uint64(l)) + } + if m.NamespaceVersion != 0 { + n += 1 + sovTypes(uint64(m.NamespaceVersion)) + } + return n +} + +func (m *RowProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.RowRoots) > 0 { + for _, b := range m.RowRoots { + l = len(b) + n += 1 + l + sovTypes(uint64(l)) + } + } + if len(m.Proofs) > 0 { + for _, e := range m.Proofs { + l = e.Size() + n += 1 + l + sovTypes(uint64(l)) + } + } + l = len(m.Root) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.StartRow != 0 { + n += 1 + sovTypes(uint64(m.StartRow)) + } + if m.EndRow != 0 { + n += 1 + sovTypes(uint64(m.EndRow)) + } + return n +} + +func (m *NMTProof) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Start != 0 { + n += 1 + sovTypes(uint64(m.Start)) + } + if m.End != 0 { + n += 1 + sovTypes(uint64(m.End)) + } + if len(m.Nodes) > 0 { + for _, b := range m.Nodes { + l = len(b) + n += 1 + l + sovTypes(uint64(l)) + } + } + l = len(m.LeafHash) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + +func sovTypes(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} func sozTypes(x uint64) (n int) { return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } -func (m *PartSetHeader) Unmarshal(dAtA []byte) error { +func (m *PartSetHeader) 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: PartSetHeader: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PartSetHeader: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType) + } + m.Total = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Total |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) + if m.Hash == nil { + m.Hash = []byte{} + } + iNdEx = postIndex + 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 *Part) 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: Part: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Part: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Bytes", 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.Bytes = append(m.Bytes[:0], dAtA[iNdEx:postIndex]...) + if m.Bytes == nil { + m.Bytes = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + 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 *BlockID) 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: BlockID: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlockID: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) + if m.Hash == nil { + m.Hash = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PartSetHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.PartSetHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + 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 *Header) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2633,30 +3985,282 @@ func (m *PartSetHeader) Unmarshal(dAtA []byte) error { if shift >= 64 { return ErrIntOverflowTypes } - if iNdEx >= l { + 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: Header: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastBlockId", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LastBlockId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastCommitHash", 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.LastCommitHash = append(m.LastCommitHash[:0], dAtA[iNdEx:postIndex]...) + if m.LastCommitHash == nil { + m.LastCommitHash = []byte{} + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DataHash", 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.DataHash = append(m.DataHash[:0], dAtA[iNdEx:postIndex]...) + if m.DataHash == nil { + m.DataHash = []byte{} + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorsHash", 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 } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.ValidatorsHash = append(m.ValidatorsHash[:0], dAtA[iNdEx:postIndex]...) + if m.ValidatorsHash == nil { + m.ValidatorsHash = []byte{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: PartSetHeader: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PartSetHeader: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NextValidatorsHash", wireType) } - m.Total = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -2666,14 +4270,29 @@ func (m *PartSetHeader) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Total |= uint32(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 2: + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NextValidatorsHash = append(m.NextValidatorsHash[:0], dAtA[iNdEx:postIndex]...) + if m.NextValidatorsHash == nil { + m.NextValidatorsHash = []byte{} + } + iNdEx = postIndex + case 10: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusHash", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -2700,9 +4319,145 @@ func (m *PartSetHeader) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) - if m.Hash == nil { - m.Hash = []byte{} + m.ConsensusHash = append(m.ConsensusHash[:0], dAtA[iNdEx:postIndex]...) + if m.ConsensusHash == nil { + m.ConsensusHash = []byte{} + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AppHash", 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.AppHash = append(m.AppHash[:0], dAtA[iNdEx:postIndex]...) + if m.AppHash == nil { + m.AppHash = []byte{} + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastResultsHash", 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.LastResultsHash = append(m.LastResultsHash[:0], dAtA[iNdEx:postIndex]...) + if m.LastResultsHash == nil { + m.LastResultsHash = []byte{} + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EvidenceHash", 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.EvidenceHash = append(m.EvidenceHash[:0], dAtA[iNdEx:postIndex]...) + if m.EvidenceHash == nil { + m.EvidenceHash = []byte{} + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerAddress", 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.ProposerAddress = append(m.ProposerAddress[:0], dAtA[iNdEx:postIndex]...) + if m.ProposerAddress == nil { + m.ProposerAddress = []byte{} } iNdEx = postIndex default: @@ -2726,7 +4481,7 @@ func (m *PartSetHeader) Unmarshal(dAtA []byte) error { } return nil } -func (m *Part) Unmarshal(dAtA []byte) error { +func (m *Data) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2749,17 +4504,17 @@ func (m *Part) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Part: wiretype end group for non-group") + return fmt.Errorf("proto: Data: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Part: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Data: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Txs", wireType) } - m.Index = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -2769,16 +4524,29 @@ func (m *Part) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Index |= uint32(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Bytes", wireType) + 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 + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SquareSize", wireType) } - var byteLen int + m.SquareSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -2788,31 +4556,16 @@ func (m *Part) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.SquareSize |= uint64(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.Bytes = append(m.Bytes[:0], dAtA[iNdEx:postIndex]...) - if m.Bytes == nil { - m.Bytes = []byte{} - } - iNdEx = postIndex - case 3: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -2822,23 +4575,24 @@ func (m *Part) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) + if m.Hash == nil { + m.Hash = []byte{} } iNdEx = postIndex default: @@ -2862,7 +4616,7 @@ func (m *Part) Unmarshal(dAtA []byte) error { } return nil } -func (m *BlockID) Unmarshal(dAtA []byte) error { +func (m *Blob) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -2885,15 +4639,15 @@ func (m *BlockID) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BlockID: wiretype end group for non-group") + return fmt.Errorf("proto: Blob: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BlockID: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Blob: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field NamespaceId", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -2920,16 +4674,16 @@ func (m *BlockID) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) - if m.Hash == nil { - m.Hash = []byte{} + m.NamespaceId = append(m.NamespaceId[:0], dAtA[iNdEx:postIndex]...) + if m.NamespaceId == nil { + m.NamespaceId = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PartSetHeader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -2939,25 +4693,64 @@ func (m *BlockID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.PartSetHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} } iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ShareVersion", wireType) + } + m.ShareVersion = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ShareVersion |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NamespaceVersion", wireType) + } + m.NamespaceVersion = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NamespaceVersion |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) @@ -2979,7 +4772,7 @@ func (m *BlockID) Unmarshal(dAtA []byte) error { } return nil } -func (m *Header) Unmarshal(dAtA []byte) error { +func (m *Vote) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3002,17 +4795,17 @@ func (m *Header) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Header: wiretype end group for non-group") + return fmt.Errorf("proto: Vote: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Vote: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } - var msglen int + m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -3022,30 +4815,16 @@ func (m *Header) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.Type |= SignedMsgType(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTypes - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) } - var stringLen uint64 + m.Height = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -3055,29 +4834,16 @@ func (m *Header) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.Height |= int64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthTypes - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ChainID = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType) } - m.Height = 0 + m.Round = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -3087,14 +4853,14 @@ func (m *Header) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Height |= int64(b&0x7F) << shift + m.Round |= int32(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BlockID", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3121,13 +4887,13 @@ func (m *Header) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil { + if err := m.BlockID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LastBlockId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3154,13 +4920,13 @@ func (m *Header) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.LastBlockId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LastCommitHash", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -3187,14 +4953,33 @@ func (m *Header) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.LastCommitHash = append(m.LastCommitHash[:0], dAtA[iNdEx:postIndex]...) - if m.LastCommitHash == nil { - m.LastCommitHash = []byte{} + m.ValidatorAddress = append(m.ValidatorAddress[:0], dAtA[iNdEx:postIndex]...) + if m.ValidatorAddress == nil { + m.ValidatorAddress = []byte{} } iNdEx = postIndex case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + m.ValidatorIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ValidatorIndex |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DataHash", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -3221,14 +5006,82 @@ func (m *Header) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.DataHash = append(m.DataHash[:0], dAtA[iNdEx:postIndex]...) - if m.DataHash == nil { - m.DataHash = []byte{} + m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []byte{} } iNdEx = postIndex - case 8: + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Extension", 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.Extension = append(m.Extension[:0], dAtA[iNdEx:postIndex]...) + if m.Extension == nil { + m.Extension = []byte{} + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtensionSignature", 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.ExtensionSignature = append(m.ExtensionSignature[:0], dAtA[iNdEx:postIndex]...) + if m.ExtensionSignature == nil { + m.ExtensionSignature = []byte{} + } + iNdEx = postIndex + case 11: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorsHash", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field NonRpExtension", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -3255,14 +5108,14 @@ func (m *Header) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ValidatorsHash = append(m.ValidatorsHash[:0], dAtA[iNdEx:postIndex]...) - if m.ValidatorsHash == nil { - m.ValidatorsHash = []byte{} + m.NonRpExtension = append(m.NonRpExtension[:0], dAtA[iNdEx:postIndex]...) + if m.NonRpExtension == nil { + m.NonRpExtension = []byte{} } iNdEx = postIndex - case 9: + case 12: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NextValidatorsHash", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field NonRpExtensionSignature", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -3289,16 +5142,66 @@ func (m *Header) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.NextValidatorsHash = append(m.NextValidatorsHash[:0], dAtA[iNdEx:postIndex]...) - if m.NextValidatorsHash == nil { - m.NextValidatorsHash = []byte{} + m.NonRpExtensionSignature = append(m.NonRpExtensionSignature[:0], dAtA[iNdEx:postIndex]...) + if m.NonRpExtensionSignature == nil { + m.NonRpExtensionSignature = []byte{} } iNdEx = postIndex - case 10: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConsensusHash", wireType) + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err } - var byteLen int + 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 *Commit) 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: Commit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Commit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -3308,31 +5211,35 @@ func (m *Header) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.Height |= int64(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 + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType) } - m.ConsensusHash = append(m.ConsensusHash[:0], dAtA[iNdEx:postIndex]...) - if m.ConsensusHash == nil { - m.ConsensusHash = []byte{} + m.Round = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Round |= int32(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex - case 11: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AppHash", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BlockID", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -3342,31 +5249,30 @@ func (m *Header) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.AppHash = append(m.AppHash[:0], dAtA[iNdEx:postIndex]...) - if m.AppHash == nil { - m.AppHash = []byte{} + if err := m.BlockID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex - case 12: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LastResultsHash", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -3376,31 +5282,81 @@ func (m *Header) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.LastResultsHash = append(m.LastResultsHash[:0], dAtA[iNdEx:postIndex]...) - if m.LastResultsHash == nil { - m.LastResultsHash = []byte{} + m.Signatures = append(m.Signatures, CommitSig{}) + if err := m.Signatures[len(m.Signatures)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex - case 13: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EvidenceHash", wireType) + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err } - var byteLen int + 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 *CommitSig) 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: CommitSig: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CommitSig: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockIdFlag", wireType) + } + m.BlockIdFlag = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -3410,29 +5366,14 @@ func (m *Header) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.BlockIdFlag |= BlockIDFlag(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.EvidenceHash = append(m.EvidenceHash[:0], dAtA[iNdEx:postIndex]...) - if m.EvidenceHash == nil { - m.EvidenceHash = []byte{} - } - iNdEx = postIndex - case 14: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProposerAddress", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -3459,64 +5400,47 @@ func (m *Header) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ProposerAddress = append(m.ProposerAddress[:0], dAtA[iNdEx:postIndex]...) - if m.ProposerAddress == nil { - m.ProposerAddress = []byte{} + m.ValidatorAddress = append(m.ValidatorAddress[:0], dAtA[iNdEx:postIndex]...) + if m.ValidatorAddress == nil { + m.ValidatorAddress = []byte{} } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTypes(dAtA[iNdEx:]) - if err != nil { - return err + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTypes + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + if msglen < 0 { + return ErrInvalidLengthTypes } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Data) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Data: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Data: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Txs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -3543,8 +5467,10 @@ func (m *Data) Unmarshal(dAtA []byte) error { 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]) + m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []byte{} + } iNdEx = postIndex default: iNdEx = preIndex @@ -3567,7 +5493,7 @@ func (m *Data) Unmarshal(dAtA []byte) error { } return nil } -func (m *Vote) Unmarshal(dAtA []byte) error { +func (m *ExtendedCommit) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3590,32 +5516,13 @@ func (m *Vote) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Vote: wiretype end group for non-group") + return fmt.Errorf("proto: ExtendedCommit: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Vote: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ExtendedCommit: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) - } - m.Type = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Type |= SignedMsgType(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) } @@ -3634,7 +5541,7 @@ func (m *Vote) Unmarshal(dAtA []byte) error { break } } - case 3: + case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType) } @@ -3653,7 +5560,7 @@ func (m *Vote) Unmarshal(dAtA []byte) error { break } } - case 4: + case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field BlockID", wireType) } @@ -3686,9 +5593,9 @@ func (m *Vote) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 5: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ExtendedSignatures", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -3715,11 +5622,81 @@ func (m *Vote) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { + m.ExtendedSignatures = append(m.ExtendedSignatures, ExtendedCommitSig{}) + if err := m.ExtendedSignatures[len(m.ExtendedSignatures)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 6: + 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 *ExtendedCommitSig) 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: ExtendedCommitSig: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExtendedCommitSig: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockIdFlag", wireType) + } + m.BlockIdFlag = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockIdFlag |= BlockIDFlag(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType) } @@ -3753,11 +5730,11 @@ func (m *Vote) Unmarshal(dAtA []byte) error { m.ValidatorAddress = []byte{} } iNdEx = postIndex - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) } - m.ValidatorIndex = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -3767,12 +5744,26 @@ func (m *Vote) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ValidatorIndex |= int32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 8: + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) } @@ -3806,7 +5797,7 @@ func (m *Vote) Unmarshal(dAtA []byte) error { m.Signature = []byte{} } iNdEx = postIndex - case 9: + case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Extension", wireType) } @@ -3840,7 +5831,7 @@ func (m *Vote) Unmarshal(dAtA []byte) error { m.Extension = []byte{} } iNdEx = postIndex - case 10: + case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExtensionSignature", wireType) } @@ -3874,7 +5865,7 @@ func (m *Vote) Unmarshal(dAtA []byte) error { m.ExtensionSignature = []byte{} } iNdEx = postIndex - case 11: + case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field NonRpExtension", wireType) } @@ -3908,7 +5899,7 @@ func (m *Vote) Unmarshal(dAtA []byte) error { m.NonRpExtension = []byte{} } iNdEx = postIndex - case 12: + case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field NonRpExtensionSignature", wireType) } @@ -3963,7 +5954,7 @@ func (m *Vote) Unmarshal(dAtA []byte) error { } return nil } -func (m *Commit) Unmarshal(dAtA []byte) error { +func (m *Proposal) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3986,13 +5977,32 @@ func (m *Commit) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Commit: wiretype end group for non-group") + return fmt.Errorf("proto: Proposal: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Commit: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Proposal: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= SignedMsgType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) } @@ -4011,11 +6021,49 @@ func (m *Commit) Unmarshal(dAtA []byte) error { break } } - case 2: + case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType) } - m.Round = 0 + m.Round = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Round |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PolRound", wireType) + } + m.PolRound = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PolRound |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockID", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -4025,14 +6073,28 @@ func (m *Commit) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Round |= int32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 3: + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.BlockID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BlockID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4059,15 +6121,15 @@ func (m *Commit) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.BlockID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -4077,24 +6139,24 @@ func (m *Commit) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Signatures = append(m.Signatures, CommitSig{}) - if err := m.Signatures[len(m.Signatures)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []byte{} } iNdEx = postIndex default: @@ -4118,7 +6180,7 @@ func (m *Commit) Unmarshal(dAtA []byte) error { } return nil } -func (m *CommitSig) Unmarshal(dAtA []byte) error { +func (m *SignedHeader) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4141,68 +6203,15 @@ func (m *CommitSig) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: CommitSig: wiretype end group for non-group") + return fmt.Errorf("proto: SignedHeader: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: CommitSig: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SignedHeader: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BlockIdFlag", wireType) - } - m.BlockIdFlag = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.BlockIdFlag |= BlockIDFlag(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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.ValidatorAddress = append(m.ValidatorAddress[:0], dAtA[iNdEx:postIndex]...) - if m.ValidatorAddress == nil { - m.ValidatorAddress = []byte{} - } - iNdEx = postIndex - case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4229,15 +6238,18 @@ func (m *CommitSig) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { + if m.Header == nil { + m.Header = &Header{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -4247,24 +6259,26 @@ func (m *CommitSig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) - if m.Signature == nil { - m.Signature = []byte{} + if m.Commit == nil { + m.Commit = &Commit{} + } + if err := m.Commit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -4288,7 +6302,7 @@ func (m *CommitSig) Unmarshal(dAtA []byte) error { } return nil } -func (m *ExtendedCommit) Unmarshal(dAtA []byte) error { +func (m *LightBlock) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4311,53 +6325,15 @@ func (m *ExtendedCommit) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ExtendedCommit: wiretype end group for non-group") + return fmt.Errorf("proto: LightBlock: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ExtendedCommit: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: LightBlock: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) - } - m.Height = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Height |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType) - } - m.Round = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Round |= int32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BlockID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SignedHeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4384,13 +6360,16 @@ func (m *ExtendedCommit) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.BlockID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.SignedHeader == nil { + m.SignedHeader = &SignedHeader{} + } + if err := m.SignedHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ExtendedSignatures", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSet", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4417,8 +6396,10 @@ func (m *ExtendedCommit) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ExtendedSignatures = append(m.ExtendedSignatures, ExtendedCommitSig{}) - if err := m.ExtendedSignatures[len(m.ExtendedSignatures)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.ValidatorSet == nil { + m.ValidatorSet = &ValidatorSet{} + } + if err := m.ValidatorSet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -4443,7 +6424,7 @@ func (m *ExtendedCommit) Unmarshal(dAtA []byte) error { } return nil } -func (m *ExtendedCommitSig) Unmarshal(dAtA []byte) error { +func (m *BlockMeta) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4466,36 +6447,17 @@ func (m *ExtendedCommitSig) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ExtendedCommitSig: wiretype end group for non-group") + return fmt.Errorf("proto: BlockMeta: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ExtendedCommitSig: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: BlockMeta: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BlockIdFlag", wireType) - } - m.BlockIdFlag = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.BlockIdFlag |= BlockIDFlag(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BlockID", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -4505,31 +6467,30 @@ func (m *ExtendedCommitSig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.ValidatorAddress = append(m.ValidatorAddress[:0], dAtA[iNdEx:postIndex]...) - if m.ValidatorAddress == nil { - m.ValidatorAddress = []byte{} + if err := m.BlockID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockSize", wireType) } - var msglen int + m.BlockSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -4539,30 +6500,16 @@ func (m *ExtendedCommitSig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTypes - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { - return err + m.BlockSize |= int64(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex - case 4: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -4572,31 +6519,30 @@ func (m *ExtendedCommitSig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) - if m.Signature == nil { - m.Signature = []byte{} + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Extension", wireType) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NumTxs", wireType) } - var byteLen int + m.NumTxs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -4606,29 +6552,64 @@ func (m *ExtendedCommitSig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.NumTxs |= int64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthTypes + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + byteLen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthTypes } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.Extension = append(m.Extension[:0], dAtA[iNdEx:postIndex]...) - if m.Extension == nil { - m.Extension = []byte{} + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TxProof) 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 } - iNdEx = postIndex - case 6: + 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: TxProof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TxProof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ExtensionSignature", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -4655,14 +6636,14 @@ func (m *ExtendedCommitSig) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ExtensionSignature = append(m.ExtensionSignature[:0], dAtA[iNdEx:postIndex]...) - if m.ExtensionSignature == nil { - m.ExtensionSignature = []byte{} + m.RootHash = append(m.RootHash[:0], dAtA[iNdEx:postIndex]...) + if m.RootHash == nil { + m.RootHash = []byte{} } iNdEx = postIndex - case 7: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NonRpExtension", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -4689,16 +6670,16 @@ func (m *ExtendedCommitSig) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.NonRpExtension = append(m.NonRpExtension[:0], dAtA[iNdEx:postIndex]...) - if m.NonRpExtension == nil { - m.NonRpExtension = []byte{} + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} } iNdEx = postIndex - case 8: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NonRpExtensionSignature", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -4708,24 +6689,26 @@ func (m *ExtendedCommitSig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.NonRpExtensionSignature = append(m.NonRpExtensionSignature[:0], dAtA[iNdEx:postIndex]...) - if m.NonRpExtensionSignature == nil { - m.NonRpExtensionSignature = []byte{} + if m.Proof == nil { + m.Proof = &v1.Proof{} + } + if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -4749,7 +6732,7 @@ func (m *ExtendedCommitSig) Unmarshal(dAtA []byte) error { } return nil } -func (m *Proposal) Unmarshal(dAtA []byte) error { +func (m *IndexWrapper) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4772,17 +6755,17 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Proposal: wiretype end group for non-group") + return fmt.Errorf("proto: IndexWrapper: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Proposal: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: IndexWrapper: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType) } - m.Type = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -4792,35 +6775,107 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Type |= SignedMsgType(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + if byteLen < 0 { + return ErrInvalidLengthTypes } - m.Height = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Tx = append(m.Tx[:0], dAtA[iNdEx:postIndex]...) + if m.Tx == nil { + m.Tx = []byte{} + } + iNdEx = postIndex + case 2: + if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ShareIndexes = append(m.ShareIndexes, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - m.Height |= int64(b&0x7F) << shift - if b < 0x80 { - break - } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.ShareIndexes) == 0 { + m.ShareIndexes = make([]uint32, 0, elementCount) + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ShareIndexes = append(m.ShareIndexes, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field ShareIndexes", wireType) } case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TypeId", wireType) } - m.Round = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -4830,35 +6885,79 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Round |= int32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PolRound", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes } - m.PolRound = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.PolRound |= int32(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes } - case 5: + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TypeId = string(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 *BlobTx) 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: BlobTx: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BlobTx: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BlockID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -4868,28 +6967,29 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.BlockID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Tx = append(m.Tx[:0], dAtA[iNdEx:postIndex]...) + if m.Tx == nil { + m.Tx = []byte{} + } iNdEx = postIndex - case 6: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Blobs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -4916,15 +7016,16 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil { + m.Blobs = append(m.Blobs, &Blob{}) + if err := m.Blobs[len(m.Blobs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 7: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TypeId", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -4934,25 +7035,23 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) - if m.Signature == nil { - m.Signature = []byte{} - } + m.TypeId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -4975,7 +7074,7 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { } return nil } -func (m *SignedHeader) Unmarshal(dAtA []byte) error { +func (m *ShareProof) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4998,17 +7097,17 @@ func (m *SignedHeader) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SignedHeader: wiretype end group for non-group") + return fmt.Errorf("proto: ShareProof: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SignedHeader: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ShareProof: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -5018,31 +7117,27 @@ func (m *SignedHeader) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &Header{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Data = append(m.Data, make([]byte, postIndex-iNdEx)) + copy(m.Data[len(m.Data)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ShareProofs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -5069,68 +7164,16 @@ func (m *SignedHeader) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Commit == nil { - m.Commit = &Commit{} - } - if err := m.Commit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ShareProofs = append(m.ShareProofs, &NMTProof{}) + if err := m.ShareProofs[len(m.ShareProofs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } 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 *LightBlock) 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: LightBlock: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LightBlock: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SignedHeader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field NamespaceId", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -5140,31 +7183,29 @@ func (m *LightBlock) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - if m.SignedHeader == nil { - m.SignedHeader = &SignedHeader{} - } - if err := m.SignedHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.NamespaceId = append(m.NamespaceId[:0], dAtA[iNdEx:postIndex]...) + if m.NamespaceId == nil { + m.NamespaceId = []byte{} } iNdEx = postIndex - case 2: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSet", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RowProof", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -5191,13 +7232,32 @@ func (m *LightBlock) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ValidatorSet == nil { - m.ValidatorSet = &ValidatorSet{} + if m.RowProof == nil { + m.RowProof = &RowProof{} } - if err := m.ValidatorSet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.RowProof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NamespaceVersion", wireType) + } + m.NamespaceVersion = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NamespaceVersion |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) @@ -5219,7 +7279,7 @@ func (m *LightBlock) Unmarshal(dAtA []byte) error { } return nil } -func (m *BlockMeta) Unmarshal(dAtA []byte) error { +func (m *RowProof) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5242,17 +7302,17 @@ func (m *BlockMeta) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BlockMeta: wiretype end group for non-group") + return fmt.Errorf("proto: RowProof: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BlockMeta: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RowProof: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BlockID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RowRoots", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -5262,30 +7322,29 @@ func (m *BlockMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.BlockID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.RowRoots = append(m.RowRoots, make([]byte, postIndex-iNdEx)) + copy(m.RowRoots[len(m.RowRoots)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BlockSize", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proofs", wireType) } - m.BlockSize = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -5295,16 +7354,31 @@ func (m *BlockMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.BlockSize |= int64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Proofs = append(m.Proofs, &v1.Proof{}) + if err := m.Proofs[len(m.Proofs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Root", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -5314,30 +7388,31 @@ func (m *BlockMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Root = append(m.Root[:0], dAtA[iNdEx:postIndex]...) + if m.Root == nil { + m.Root = []byte{} } iNdEx = postIndex case 4: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field NumTxs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StartRow", wireType) } - m.NumTxs = 0 + m.StartRow = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -5347,7 +7422,26 @@ func (m *BlockMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.NumTxs |= int64(b&0x7F) << shift + m.StartRow |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndRow", wireType) + } + m.EndRow = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndRow |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -5373,7 +7467,7 @@ func (m *BlockMeta) Unmarshal(dAtA []byte) error { } return nil } -func (m *TxProof) Unmarshal(dAtA []byte) error { +func (m *NMTProof) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5396,17 +7490,17 @@ func (m *TxProof) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TxProof: wiretype end group for non-group") + return fmt.Errorf("proto: NMTProof: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TxProof: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: NMTProof: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType) } - var byteLen int + m.Start = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -5416,29 +7510,33 @@ func (m *TxProof) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.Start |= int32(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 + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field End", wireType) } - m.RootHash = append(m.RootHash[:0], dAtA[iNdEx:postIndex]...) - if m.RootHash == nil { - m.RootHash = []byte{} + m.End = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.End |= int32(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -5465,16 +7563,14 @@ func (m *TxProof) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} - } + m.Nodes = append(m.Nodes, make([]byte, postIndex-iNdEx)) + copy(m.Nodes[len(m.Nodes)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field LeafHash", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -5484,26 +7580,24 @@ func (m *TxProof) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Proof == nil { - m.Proof = &v1.Proof{} - } - if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.LeafHash = append(m.LeafHash[:0], dAtA[iNdEx:postIndex]...) + if m.LeafHash == nil { + m.LeafHash = []byte{} } iNdEx = postIndex default: diff --git a/proto/cometbft/rpc/grpc/v1beta3/types.proto b/proto/cometbft/rpc/grpc/v1beta3/types.proto index 5ce89075d53..7ebc9030b94 100644 --- a/proto/cometbft/rpc/grpc/v1beta3/types.proto +++ b/proto/cometbft/rpc/grpc/v1beta3/types.proto @@ -3,19 +3,19 @@ package cometbft.rpc.grpc.v1beta3; option go_package = "github.com/cometbft/cometbft/api/cometbft/rpc/grpc/v1beta3"; import "cometbft/rpc/grpc/v1beta1/types.proto"; -import "cometbft/abci/v2/types.proto"; +import "cometbft/abci/v1beta3/types.proto"; -import "cometbft/v2/types/types.proto"; -import "cometbft/v1/p2p/types.proto"; -import "cometbft/v1/crypto/keys.proto"; -import "cometbft/v2/types/validator.proto"; +import "cometbft/types/v2/types.proto"; +import "cometbft/p2p/v1/types.proto"; +import "cometbft/crypto/v1/keys.proto"; +import "cometbft/types/v2/validator.proto"; import "google/protobuf/timestamp.proto"; import "gogoproto/gogo.proto"; // ResponseBroadcastTx is a response of broadcasting the transaction. message ResponseBroadcastTx { - cometbft.abci.v2.ResponseCheckTx check_tx = 1; - cometbft.abci.v2.ExecTxResult tx_result = 2; + cometbft.abci.v1beta3.ResponseCheckTx check_tx = 1; + cometbft.abci.v1beta3.ExecTxResult tx_result = 2; } // BroadcastAPI is an API for broadcasting transactions. @@ -88,37 +88,37 @@ message BlockByHashRequest { // StreamedBlockByHashResponse is a response to a BlockByHashRequest. message StreamedBlockByHashResponse { - tendermint.types.Part block_part = 1; + cometbft.types.v2.Part block_part = 1; // Commit is only set in the first part, and // it stays nil in the remaining ones. - tendermint.types.Commit commit = 2; + cometbft.types.v2.Commit commit = 2; // ValidatorSet is only set in the first part, and // it stays nil in the remaining ones. - tendermint.types.ValidatorSet validator_set = 3; + cometbft.types.v2.ValidatorSet validator_set = 3; bool is_last = 4; } // StreamedBlockByHeightResponse is a response to a BlockByHeightRequest. message StreamedBlockByHeightResponse { - tendermint.types.Part block_part = 1; + cometbft.types.v2.Part block_part = 1; // Commit is only set in the first part, and // it stays nil in the remaining ones. - tendermint.types.Commit commit = 2; + cometbft.types.v2.Commit commit = 2; // ValidatorSet is only set in the first part, and // it stays nil in the remaining ones. - tendermint.types.ValidatorSet validator_set = 3; + cometbft.types.v2.ValidatorSet validator_set = 3; bool is_last = 4; } // CommitResponse is a response to a CommitRequest. message CommitResponse { - tendermint.types.Commit commit = 1; + cometbft.types.v2.Commit commit = 1; } // ValidatorSetResponse is a response to a ValidatorSetRequest. message ValidatorSetResponse { // ValidatorSet the requested validator set. - tendermint.types.ValidatorSet validator_set = 1; + cometbft.types.v2.ValidatorSet validator_set = 1; // Height the height corresponding to the returned // validator set. int64 height = 2; @@ -132,7 +132,7 @@ message BlockByHashRequest { // StatusResponse is a response to a StatusRequest. message StatusResponse { - tendermint.p2p.DefaultNodeInfo node_info = 1; + cometbft.p2p.v1.DefaultNodeInfo node_info = 1; SyncInfo sync_info = 2; ValidatorInfo validator_info = 3; } @@ -157,6 +157,6 @@ message BlockByHashRequest { // ValidatorInfo is information about a validator. message ValidatorInfo { bytes address = 1; - tendermint.crypto.PublicKey pub_key = 2; + cometbft.crypto.v1.PublicKey pub_key = 2; int64 voting_power = 3; } \ No newline at end of file From 2433b80a0fb88527101dc6e15fa6fa4c96995a0d Mon Sep 17 00:00:00 2001 From: Marko Baricevic Date: Wed, 22 Jan 2025 13:56:30 +0100 Subject: [PATCH 4/4] linting --- proto/cometbft/mempool/v2/types.proto | 1 + proto/cometbft/rpc/grpc/v1beta3/types.proto | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/proto/cometbft/mempool/v2/types.proto b/proto/cometbft/mempool/v2/types.proto index e58b61777dd..54a877c5d9b 100644 --- a/proto/cometbft/mempool/v2/types.proto +++ b/proto/cometbft/mempool/v2/types.proto @@ -14,6 +14,7 @@ message HaveTx { bytes tx_key = 1; } +// WantTx is sent by the CAT protocol to signal a peer that the sender wants a transaction. message WantTx { bytes tx_key = 1; } diff --git a/proto/cometbft/rpc/grpc/v1beta3/types.proto b/proto/cometbft/rpc/grpc/v1beta3/types.proto index 7ebc9030b94..23be5c56f0c 100644 --- a/proto/cometbft/rpc/grpc/v1beta3/types.proto +++ b/proto/cometbft/rpc/grpc/v1beta3/types.proto @@ -30,7 +30,6 @@ service BroadcastAPI { } // BlockAPI is an API for querying blocks. - service BlockAPI { // BlockByHash returns a block by its hash. rpc BlockByHash(BlockByHashRequest) returns (stream StreamedBlockByHashResponse);