RPC support for CometBFT 0.38

.changelog/unreleased/breaking-changes/1317-cometbft-rpc-0.38.md

@@ -0,0 +1,24 @@
+- `[tendermint-rpc]`  Changes to support the RPC protocol in CometBFT 0.38
+  ([\#1317](https://github.com/informalsystems/tendermint-rs/pull/1317)):
+  * Add `finalize_block_results` and `app_hash` fields to
+    `endpoint::block_results::Response`.
+  * The `deliver_tx` field is renamed to `tx_result` in
+    `endpoint::broadcast::tx_commit::Response`.
+  * The `tx_result` field type changed to `ExecTxResult` in
+    `endpoint::tx::Response`.
+  * The `event::EventData::NewBlock` variant is renamed to `LegacyNewBlock`.
+    The new `NewBlock` variant only carries fields relevant since CometBFT 0.38.
+  * Removed `event::DialectEvent`, replaced with non-generic serialization
+    helpers in `event::{v0_34, v0_37, v0_38}`. The `Deserialize` helpers in
+    the latter two modules are aliased from common types that can support both
+    fields added in CometBFT 0.38, `block_id` and `result_finalize_block`,
+    as well as the fields present 0.37. Likewise for `DialectEventData`
+    and other event data structure types.
+  * Changed some of the serialization dialect helpers to only be
+    used by the 0.34 dialect and remove generics. The current dialect's
+    seralization is switched to the serde impls on the domain types in
+    `tendermint`.
+- `[tendermint]` Changes to support the RPC protocol in CometBFT 0.38
+  ([\#1317](https://github.com/informalsystems/tendermint-rs/pull/1317)):
+  * Due to some attribute changes, the format emitted by `Serialize` is
+    changed for `abci::response` types `CheckTx` and `FinalizeBlock`.

.changelog/unreleased/improvements/1317-cometbft-rpc-0.38.md

@@ -0,0 +1,9 @@
+- `[tendermint-rpc]` Support for CometBFT 0.38
+  ([\#1317](https://github.com/informalsystems/tendermint-rs/pull/1317)):
+  * `Deserialize` implementations on `abci::Event`, `abci::EventAttribute`
+    that correspond to the current RPC serialization.
+  * Domain types under `abci::response` also get `Deserialize` implementations
+    corresponding to the current RPC serialization.
+  * `Serialize`, `Deserialize` implementations on `abci::types::ExecTxResult`
+    corresponding to the current RPC serialization.
+  * Added the `apphash_base64` serializer module.

rpc/src/client/bin/main.rs

@@ -7,8 +7,7 @@ use structopt::StructOpt;
 use tendermint::Hash;
 use tendermint_rpc::{
     client::CompatMode,
-    dialect::{Dialect, LatestDialect},
-    event::DialectEvent,
+    event::{self, Event, EventData},
     query::Query,
     Client, Error, HttpClient, Order, Paging, Scheme, Subscription, SubscriptionClient, Url,
     WebSocketClient,
@@ -377,6 +376,8 @@ where
                 .map_err(Error::serde)?
         },
         ClientRequest::BroadcastTxCommit { tx } => {
+            // NOTE: this prints out the response in the 0.38+ format,
+            // regardless of the actual protocol version.
             serde_json::to_string_pretty(&client.broadcast_tx_commit(tx).await?)
                 .map_err(Error::serde)?
         },
@@ -504,8 +505,7 @@ async fn recv_events_with_timeout(
                     }
                 };
                 let event = result?;
-                let event: DialectEvent<<LatestDialect as Dialect>::Event> = event.into();
-                println!("{}", serde_json::to_string_pretty(&event).map_err(Error::serde)?);
+                print_event(event)?;
                 event_count += 1;
                 if let Some(me) = max_events {
                     if event_count >= (me as u64) {
@@ -526,11 +526,7 @@ async fn recv_events(mut subs: Subscription, max_events: Option<u32>) -> Result<
     let mut event_count = 0u64;
     while let Some(result) = subs.next().await {
         let event = result?;
-        let event: DialectEvent<<LatestDialect as Dialect>::Event> = event.into();
-        println!(
-            "{}",
-            serde_json::to_string_pretty(&event).map_err(Error::serde)?
-        );
+        print_event(event)?;
         event_count += 1;
         if let Some(me) = max_events {
             if event_count >= (me as u64) {
@@ -542,3 +538,21 @@ async fn recv_events(mut subs: Subscription, max_events: Option<u32>) -> Result<
     info!("The server terminated the subscription");
     Ok(())
 }
+
+fn print_event(event: Event) -> Result<(), Error> {
+    let json = match &event.data {
+        EventData::LegacyNewBlock { .. } => {
+            // Print the old field structure in case the event was received
+            // from a pre-0.38 node. This is the only instance where the
+            // structure of the dumped event data currently differs.
+            let ser_event: event::v0_37::SerEvent = event.into();
+            serde_json::to_string_pretty(&ser_event).map_err(Error::serde)?
+        },
+        _ => {
+            let ser_event: event::v0_38::SerEvent = event.into();
+            serde_json::to_string_pretty(&ser_event).map_err(Error::serde)?
+        },
+    };
+    println!("{}", json);
+    Ok(())
+}

rpc/src/client/compat.rs

@@ -49,6 +49,7 @@ impl CompatMode {
         match (version.major, version.minor) {
             (0, 34) => Ok(CompatMode::V0_34),
             (0, 37) => Ok(CompatMode::V0_37),
+            (0, 38) => Ok(CompatMode::V0_37),
             _ => Err(Error::unsupported_tendermint_version(version.to_string())),
         }
     }
@@ -88,7 +89,11 @@ mod tests {
             CompatMode::from_version(parse_version("v0.37.0")).unwrap(),
             CompatMode::V0_37
         );
-        let res = CompatMode::from_version(parse_version("v0.38.0"));
+        assert_eq!(
+            CompatMode::from_version(parse_version("v0.38.0")).unwrap(),
+            CompatMode::V0_37
+        );
+        let res = CompatMode::from_version(parse_version("v0.39.0"));
         assert!(res.is_err());
         let res = CompatMode::from_version(parse_version("v1.0.0"));
         assert!(res.is_err());

rpc/src/client/transport/mock.rs

@@ -264,12 +264,10 @@ mod test {
 
     mod v0_34 {
         use super::*;
-        use crate::dialect::v0_34::Event as RpcEvent;
-        use crate::event::DialectEvent;
+        use crate::event::v0_34::DeEvent;
 
         async fn read_event(name: &str) -> Event {
-            let msg = DialectEvent::<RpcEvent>::from_string(read_json_fixture("v0_34", name).await)
-                .unwrap();
+            let msg = DeEvent::from_string(read_json_fixture("v0_34", name).await).unwrap();
             msg.into()
         }
 
@@ -334,12 +332,10 @@ mod test {
 
     mod v0_37 {
         use super::*;
-        use crate::dialect::v0_37::Event as RpcEvent;
-        use crate::event::DialectEvent;
+        use crate::event::v0_37::DeEvent;
 
         async fn read_event(name: &str) -> Event {
-            let msg = DialectEvent::<RpcEvent>::from_string(read_json_fixture("v0_37", name).await)
-                .unwrap();
+            let msg = DeEvent::from_string(read_json_fixture("v0_37", name).await).unwrap();
             msg.into()
         }
 

rpc/src/client/transport/router.rs

@@ -144,7 +144,7 @@ mod test {
     use super::*;
     use crate::{
         client::sync::{unbounded, ChannelRx},
-        event::{Event, WrappedEvent},
+        event::Event,
         utils::uuid_str,
     };
 
@@ -180,16 +180,15 @@ mod test {
 
     mod v0_34 {
         use super::*;
-        use crate::dialect::v0_34::Event as RpcEvent;
+
+        type WrappedEvent = crate::response::Wrapper<crate::event::v0_34::DialectEvent>;
 
         async fn read_event(name: &str) -> Event {
-            serde_json::from_str::<WrappedEvent<RpcEvent>>(
-                read_json_fixture("v0_34", name).await.as_str(),
-            )
-            .unwrap()
-            .into_result()
-            .unwrap()
-            .into()
+            serde_json::from_str::<WrappedEvent>(read_json_fixture("v0_34", name).await.as_str())
+                .unwrap()
+                .into_result()
+                .unwrap()
+                .into()
         }
 
         #[tokio::test]
@@ -229,16 +228,15 @@ mod test {
 
     mod v0_37 {
         use super::*;
-        use crate::dialect::v0_37::Event as RpcEvent;
+
+        type WrappedEvent = crate::response::Wrapper<crate::event::v0_37::DeEvent>;
 
         async fn read_event(name: &str) -> Event {
-            serde_json::from_str::<WrappedEvent<RpcEvent>>(
-                read_json_fixture("v0_37", name).await.as_str(),
-            )
-            .unwrap()
-            .into_result()
-            .unwrap()
-            .into()
+            serde_json::from_str::<WrappedEvent>(read_json_fixture("v0_37", name).await.as_str())
+                .unwrap()
+                .into_result()
+                .unwrap()
+                .into()
         }
 
         #[tokio::test]