Support for CometBFT proto 0.38

.changelog/unreleased/breaking-changes/1312-cometbft-0.38.md

@@ -0,0 +1,19 @@
+- [`tendermint`] Adaptations for CometFBT 0.38
+  ([\#1312](https://github.com/informalsystems/tendermint-rs/pull/1312)):
+  * Define `consensus::params::AbciParams` struct, add the `abci` field of this
+    type to `consensus::Params` to represent the protobuf additions.
+  * Represent vote extensions in the `Vote` domain type.
+  * Remove the fields from the `CheckTx` and `Commit` domain types that are
+    no longer present in CometBFT 0.38.
+- [`tendermint`] Define version-specific categorized request/response enums:
+  `ConsensusRequest`, `MempoolRequest`, `InfoRequest`, `ShapshotRequest`,
+  `ConsensusResponse`, `MempoolResponse`, `InfoResponse`, `ShapshotResponse`,
+  in each of the `v0_*::abci` modules, so that the variants are trimmed to the
+  requests/responses used by the respective protocol version.
+  Reexport the types from `v0_38::abci` as continuation for these names in the
+  `abci` module
+  ([\#1312](https://github.com/informalsystems/tendermint-rs/pull/1312)).
+- [`tendermint`] Rename `Signature::to_bytes` to `Signature::into_bytes`
+  ([\#1312](https://github.com/informalsystems/tendermint-rs/pull/1312)).
+- [`tendermint-abci`] Update the `Application` interface to CometBFT 0.38
+  ([\#1312](https://github.com/informalsystems/tendermint-rs/pull/1312))

.changelog/unreleased/improvements/1312-cometbft-0.38.md

@@ -0,0 +1,12 @@
+- [`tendermint-proto`] Generate prost bindings for CometBFT 0.38
+  under the `tendermint::v0_38` module
+  ([\#1312](https://github.com/informalsystems/tendermint-rs/pull/1312))
+- [`tendermint`] Support for CometBFT 0.38:
+  ([\#1312](https://github.com/informalsystems/tendermint-rs/pull/1312)):
+  * Add conversions to and from `tendermint::v0_38` protobuf
+    types generated in [`tendermint-proto`].
+  * Add request and response enums under `v0_38::abci` to enumerate all requests
+    and responses appropriate for CometBFT version 0.38.
+  * Add request and response types under `abci` to represent the requests
+    and responses new to ABCI++ 2.0 in CometBFT version 0.38. The names are
+    `ExtendVote`, `FinalizeBlock`, `VerifyVoteExtension`.

.github/workflows/build.yml

@@ -69,18 +69,20 @@ jobs:
           override: true
       - name: Install protoc
         run: |
-          curl -Lo /tmp/protoc.zip https://github.com/protocolbuffers/protobuf/releases/download/v21.4/protoc-21.4-linux-x86_64.zip
+          curl -Lo /tmp/protoc.zip https://github.com/protocolbuffers/protobuf/releases/download/v22.3/protoc-22.3-linux-x86_64.zip
           unzip /tmp/protoc.zip -d ${HOME}/.local
           echo "PROTOC=${HOME}/.local/bin/protoc" >> $GITHUB_ENV
           export PATH="${PATH}:${HOME}/.local/bin"
       - name: Install buf
         run: |
-          curl -sSL https://github.com/bufbuild/buf/releases/download/v1.15.1/buf-Linux-x86_64 \
+          curl -sSL https://github.com/bufbuild/buf/releases/download/v1.17.0/buf-Linux-x86_64 \
             -o /usr/local/bin/buf
           chmod +x /usr/local/bin/buf
       - name: Regenerate proto definitions
         working-directory: ./tools/proto-compiler/
         run: cargo run
+      - name: Show the differences with checked-in files
+        run: git diff -- proto/src/prost
       - name: Ensure that generated proto definitions compile
         uses: actions-rs/cargo@v1
         with:

abci/Cargo.toml

@@ -18,7 +18,7 @@ description = """
 [[bin]]
 name = "kvstore-rs"
 path = "src/application/kvstore/main.rs"
-required-features = [ "binary", "kvstore-app" ]
+required-features = [ "binary", "client", "kvstore-app" ]
 
 [features]
 default = ["flex-error/std", "flex-error/eyre_tracer"]

abci/src/application.rs

@@ -5,15 +5,16 @@ pub mod echo;
 #[cfg(feature = "kvstore-app")]
 pub mod kvstore;
 
-use tendermint_proto::v0_37::abci::{
-    request::Value, response, response_process_proposal, Request, RequestApplySnapshotChunk,
-    RequestBeginBlock, RequestCheckTx, RequestDeliverTx, RequestEcho, RequestEndBlock, RequestInfo,
-    RequestInitChain, RequestLoadSnapshotChunk, RequestOfferSnapshot, RequestPrepareProposal,
-    RequestProcessProposal, RequestQuery, Response, ResponseApplySnapshotChunk, ResponseBeginBlock,
-    ResponseCheckTx, ResponseCommit, ResponseDeliverTx, ResponseEcho, ResponseEndBlock,
-    ResponseFlush, ResponseInfo, ResponseInitChain, ResponseListSnapshots,
-    ResponseLoadSnapshotChunk, ResponseOfferSnapshot, ResponsePrepareProposal,
-    ResponseProcessProposal, ResponseQuery,
+use tendermint_proto::v0_38::abci::{
+    request::Value, response, response_process_proposal, response_verify_vote_extension, Request,
+    RequestApplySnapshotChunk, RequestCheckTx, RequestEcho, RequestExtendVote,
+    RequestFinalizeBlock, RequestInfo, RequestInitChain, RequestLoadSnapshotChunk,
+    RequestOfferSnapshot, RequestPrepareProposal, RequestProcessProposal, RequestQuery,
+    RequestVerifyVoteExtension, Response, ResponseApplySnapshotChunk, ResponseCheckTx,
+    ResponseCommit, ResponseEcho, ResponseExtendVote, ResponseFinalizeBlock, ResponseFlush,
+    ResponseInfo, ResponseInitChain, ResponseListSnapshots, ResponseLoadSnapshotChunk,
+    ResponseOfferSnapshot, ResponsePrepareProposal, ResponseProcessProposal, ResponseQuery,
+    ResponseVerifyVoteExtension,
 };
 
 /// An ABCI application.
@@ -52,21 +53,6 @@ pub trait Application: Send + Clone + 'static {
         Default::default()
     }
 
-    /// Signals the beginning of a new block, prior to any `DeliverTx` calls.
-    fn begin_block(&self, _request: RequestBeginBlock) -> ResponseBeginBlock {
-        Default::default()
-    }
-
-    /// Apply a transaction to the application's state.
-    fn deliver_tx(&self, _request: RequestDeliverTx) -> ResponseDeliverTx {
-        Default::default()
-    }
-
-    /// Signals the end of a block.
-    fn end_block(&self, _request: RequestEndBlock) -> ResponseEndBlock {
-        Default::default()
-    }
-
     /// Signals that messages queued on the client should be flushed to the server.
     fn flush(&self) -> ResponseFlush {
         ResponseFlush {}
@@ -147,6 +133,23 @@ pub trait Application: Send + Clone + 'static {
             status: response_process_proposal::ProposalStatus::Accept as i32,
         }
     }
+
+    fn extend_vote(&self, _request: RequestExtendVote) -> ResponseExtendVote {
+        Default::default()
+    }
+
+    fn verify_vote_extension(
+        &self,
+        _request: RequestVerifyVoteExtension,
+    ) -> ResponseVerifyVoteExtension {
+        ResponseVerifyVoteExtension {
+            status: response_verify_vote_extension::VerifyStatus::Accept as i32,
+        }
+    }
+
+    fn finalize_block(&self, _request: RequestFinalizeBlock) -> ResponseFinalizeBlock {
+        Default::default()
+    }
 }
 
 /// Provides a mechanism for the [`Server`] to execute incoming requests while
@@ -168,10 +171,7 @@ impl<A: Application> RequestDispatcher for A {
                 Value::Info(req) => response::Value::Info(self.info(req)),
                 Value::InitChain(req) => response::Value::InitChain(self.init_chain(req)),
                 Value::Query(req) => response::Value::Query(self.query(req)),
-                Value::BeginBlock(req) => response::Value::BeginBlock(self.begin_block(req)),
                 Value::CheckTx(req) => response::Value::CheckTx(self.check_tx(req)),
-                Value::DeliverTx(req) => response::Value::DeliverTx(self.deliver_tx(req)),
-                Value::EndBlock(req) => response::Value::EndBlock(self.end_block(req)),
                 Value::Commit(_) => response::Value::Commit(self.commit()),
                 Value::ListSnapshots(_) => response::Value::ListSnapshots(self.list_snapshots()),
                 Value::OfferSnapshot(req) => {
@@ -189,6 +189,13 @@ impl<A: Application> RequestDispatcher for A {
                 Value::ProcessProposal(req) => {
                     response::Value::ProcessProposal(self.process_proposal(req))
                 },
+                Value::ExtendVote(req) => response::Value::ExtendVote(self.extend_vote(req)),
+                Value::VerifyVoteExtension(req) => {
+                    response::Value::VerifyVoteExtension(self.verify_vote_extension(req))
+                },
+                Value::FinalizeBlock(req) => {
+                    response::Value::FinalizeBlock(self.finalize_block(req))
+                },
             }),
         }
     }

abci/src/application/kvstore.rs

@@ -6,9 +6,9 @@ use std::{
 };
 
 use bytes::BytesMut;
-use tendermint_proto::v0_37::abci::{
-    Event, EventAttribute, RequestCheckTx, RequestDeliverTx, RequestInfo, RequestQuery,
-    ResponseCheckTx, ResponseCommit, ResponseDeliverTx, ResponseInfo, ResponseQuery,
+use tendermint_proto::v0_38::abci::{
+    Event, EventAttribute, RequestCheckTx, RequestFinalizeBlock, RequestInfo, RequestQuery,
+    ResponseCheckTx, ResponseCommit, ResponseFinalizeBlock, ResponseInfo, ResponseQuery,
 };
 use tracing::{debug, info};
 
@@ -20,9 +20,10 @@ use crate::{codec::MAX_VARINT_LENGTH, Application, Error};
 /// store - the [`KeyValueStoreDriver`].
 ///
 /// ## Example
-/// ```rust
+///
+/// ```
 /// use tendermint_abci::{KeyValueStoreApp, ServerBuilder, ClientBuilder};
-/// use tendermint_proto::abci::{RequestEcho, RequestDeliverTx, RequestQuery};
+/// use tendermint_proto::abci::{RequestEcho, RequestFinalizeBlock, RequestQuery};
 ///
 /// // Create our key/value store application
 /// let (app, driver) = KeyValueStoreApp::new();
@@ -46,8 +47,9 @@ use crate::{codec::MAX_VARINT_LENGTH, Application, Error};
 ///
 /// // Deliver a transaction and then commit the transaction
 /// client
-///     .deliver_tx(RequestDeliverTx {
-///         tx: "test-key=test-value".into(),
+///     .finalize_block(RequestFinalizeBlock {
+///         txs: vec!["test-key=test-value".into()],
+///         ..Default::default()
 ///     })
 ///     .unwrap();
 /// client.commit().unwrap();
@@ -175,27 +177,31 @@ impl Application for KeyValueStoreApp {
             gas_used: 0,
             events: vec![],
             codespace: "".to_string(),
-            ..Default::default()
         }
     }
 
-    fn deliver_tx(&self, request: RequestDeliverTx) -> ResponseDeliverTx {
-        let tx = std::str::from_utf8(&request.tx).unwrap();
-        let tx_parts = tx.split('=').collect::<Vec<&str>>();
-        let (key, value) = if tx_parts.len() == 2 {
-            (tx_parts[0], tx_parts[1])
-        } else {
-            (tx, tx)
-        };
-        let _ = self.set(key, value).unwrap();
-        ResponseDeliverTx {
-            code: 0,
-            data: Default::default(),
-            log: "".to_string(),
-            info: "".to_string(),
-            gas_wanted: 0,
-            gas_used: 0,
-            events: vec![Event {
+    fn commit(&self) -> ResponseCommit {
+        let (result_tx, result_rx) = channel();
+        channel_send(&self.cmd_tx, Command::Commit { result_tx }).unwrap();
+        let height = channel_recv(&result_rx).unwrap();
+        info!("Committed height {}", height);
+        ResponseCommit {
+            retain_height: height - 1,
+        }
+    }
+
+    fn finalize_block(&self, request: RequestFinalizeBlock) -> ResponseFinalizeBlock {
+        let mut events = Vec::new();
+        for tx in request.txs {
+            let tx = std::str::from_utf8(&tx).unwrap();
+            let tx_parts = tx.split('=').collect::<Vec<&str>>();
+            let (key, value) = if tx_parts.len() == 2 {
+                (tx_parts[0], tx_parts[1])
+            } else {
+                (tx, tx)
+            };
+            let _ = self.set(key, value).unwrap();
+            events.push(Event {
                 r#type: "app".to_string(),
                 attributes: vec![
                     EventAttribute {
@@ -214,19 +220,11 @@ impl Application for KeyValueStoreApp {
                         index: false,
                     },
                 ],
-            }],
-            codespace: "".to_string(),
+            });
         }
-    }
-
-    fn commit(&self) -> ResponseCommit {
-        let (result_tx, result_rx) = channel();
-        channel_send(&self.cmd_tx, Command::Commit { result_tx }).unwrap();
-        let (height, app_hash) = channel_recv(&result_rx).unwrap();
-        info!("Committed height {}", height);
-        ResponseCommit {
-            data: app_hash.into(),
-            retain_height: height - 1,
+        ResponseFinalizeBlock {
+            events,
+            ..Default::default()
         }
     }
 }
@@ -278,14 +276,14 @@ impl KeyValueStoreDriver {
         }
     }
 
-    fn commit(&mut self, result_tx: Sender<(i64, Vec<u8>)>) -> Result<(), Error> {
+    fn commit(&mut self, result_tx: Sender<i64>) -> Result<(), Error> {
         // As in the Go-based key/value store, simply encode the number of
         // items as the "app hash"
         let mut app_hash = BytesMut::with_capacity(MAX_VARINT_LENGTH);
         prost::encoding::encode_varint(self.store.len() as u64, &mut app_hash);
         self.app_hash = app_hash.to_vec();
         self.height += 1;
-        channel_send(&result_tx, (self.height, self.app_hash.clone()))
+        channel_send(&result_tx, self.height)
     }
 }
 
@@ -305,8 +303,8 @@ enum Command {
         result_tx: Sender<Option<String>>,
     },
     /// Commit the current state of the application, which involves recomputing
-    /// the application's hash.
-    Commit { result_tx: Sender<(i64, Vec<u8>)> },
+    /// the application's hash, and return the new height.
+    Commit { result_tx: Sender<i64> },
 }
 
 fn channel_send<T>(tx: &Sender<T>, value: T) -> Result<(), Error> {

abci/src/client.rs

@@ -2,14 +2,14 @@
 
 use std::net::{TcpStream, ToSocketAddrs};
 
-use tendermint_proto::v0_37::abci::{
-    request, response, Request, RequestApplySnapshotChunk, RequestBeginBlock, RequestCheckTx,
-    RequestCommit, RequestDeliverTx, RequestEcho, RequestEndBlock, RequestFlush, RequestInfo,
+use tendermint_proto::v0_38::abci::{
+    request, response, Request, RequestApplySnapshotChunk, RequestCheckTx, RequestCommit,
+    RequestEcho, RequestExtendVote, RequestFinalizeBlock, RequestFlush, RequestInfo,
     RequestInitChain, RequestListSnapshots, RequestLoadSnapshotChunk, RequestOfferSnapshot,
-    RequestQuery, ResponseApplySnapshotChunk, ResponseBeginBlock, ResponseCheckTx, ResponseCommit,
-    ResponseDeliverTx, ResponseEcho, ResponseEndBlock, ResponseFlush, ResponseInfo,
-    ResponseInitChain, ResponseListSnapshots, ResponseLoadSnapshotChunk, ResponseOfferSnapshot,
-    ResponseQuery,
+    RequestQuery, RequestVerifyVoteExtension, ResponseApplySnapshotChunk, ResponseCheckTx,
+    ResponseCommit, ResponseEcho, ResponseExtendVote, ResponseFinalizeBlock, ResponseFlush,
+    ResponseInfo, ResponseInitChain, ResponseListSnapshots, ResponseLoadSnapshotChunk,
+    ResponseOfferSnapshot, ResponseQuery, ResponseVerifyVoteExtension,
 };
 
 use crate::{codec::ClientCodec, Error};
@@ -89,21 +89,6 @@ impl Client {
         perform!(self, CheckTx, req)
     }
 
-    /// Signal the beginning of a new block, prior to any `DeliverTx` calls.
-    pub fn begin_block(&mut self, req: RequestBeginBlock) -> Result<ResponseBeginBlock, Error> {
-        perform!(self, BeginBlock, req)
-    }
-
-    /// Apply a transaction to the application's state.
-    pub fn deliver_tx(&mut self, req: RequestDeliverTx) -> Result<ResponseDeliverTx, Error> {
-        perform!(self, DeliverTx, req)
-    }
-
-    /// Signal the end of a block.
-    pub fn end_block(&mut self, req: RequestEndBlock) -> Result<ResponseEndBlock, Error> {
-        perform!(self, EndBlock, req)
-    }
-
     pub fn flush(&mut self) -> Result<ResponseFlush, Error> {
         perform!(self, Flush, RequestFlush {})
     }
@@ -142,6 +127,24 @@ impl Client {
         perform!(self, ApplySnapshotChunk, req)
     }
 
+    pub fn extend_vote(&mut self, req: RequestExtendVote) -> Result<ResponseExtendVote, Error> {
+        perform!(self, ExtendVote, req)
+    }
+
+    pub fn verify_vote_extension(
+        &mut self,
+        req: RequestVerifyVoteExtension,
+    ) -> Result<ResponseVerifyVoteExtension, Error> {
+        perform!(self, VerifyVoteExtension, req)
+    }
+
+    pub fn finalize_block(
+        &mut self,
+        req: RequestFinalizeBlock,
+    ) -> Result<ResponseFinalizeBlock, Error> {
+        perform!(self, FinalizeBlock, req)
+    }
+
     fn perform(&mut self, req: request::Value) -> Result<response::Value, Error> {
         self.codec.send(Request { value: Some(req) })?;
         let res = self

abci/src/codec.rs

@@ -11,7 +11,7 @@ use std::{
 
 use bytes::{Buf, BufMut, BytesMut};
 use prost::Message;
-use tendermint_proto::v0_37::abci::{Request, Response};
+use tendermint_proto::v0_38::abci::{Request, Response};
 
 use crate::error::Error;
 

abci/src/error.rs

@@ -1,7 +1,7 @@
 //! tendermint-abci errors
 
 use flex_error::{define_error, DisplayError};
-use tendermint_proto::v0_37::abci::response::Value;
+use tendermint_proto::v0_38::abci::response::Value;
 
 define_error! {
     Error {

abci/tests/echo_app.rs

@@ -3,7 +3,7 @@
 #[cfg(all(feature = "client", feature = "echo-app"))]
 mod echo_app_integration {
     use tendermint_abci::{ClientBuilder, EchoApp, ServerBuilder};
-    use tendermint_proto::v0_37::abci::RequestEcho;
+    use tendermint_proto::v0_38::abci::RequestEcho;
 
     #[test]
     fn echo() {