abci: Add domain types

abci/src/application.rs

@@ -9,11 +9,11 @@ use tendermint_proto::abci::request::Value;
 use tendermint_proto::abci::{
     response, Request, RequestApplySnapshotChunk, RequestBeginBlock, RequestCheckTx,
     RequestDeliverTx, RequestEcho, RequestEndBlock, RequestInfo, RequestInitChain,
-    RequestLoadSnapshotChunk, RequestOfferSnapshot, RequestQuery, RequestSetOption, Response,
+    RequestLoadSnapshotChunk, RequestOfferSnapshot, RequestQuery, Response,
     ResponseApplySnapshotChunk, ResponseBeginBlock, ResponseCheckTx, ResponseCommit,
     ResponseDeliverTx, ResponseEcho, ResponseEndBlock, ResponseFlush, ResponseInfo,
     ResponseInitChain, ResponseListSnapshots, ResponseLoadSnapshotChunk, ResponseOfferSnapshot,
-    ResponseQuery, ResponseSetOption,
+    ResponseQuery,
 };
 
 /// An ABCI application.
@@ -77,12 +77,6 @@ pub trait Application: Send + Clone + 'static {
         Default::default()
     }
 
-    /// Allows the Tendermint node to request that the application set an
-    /// option to a particular value.
-    fn set_option(&self, _request: RequestSetOption) -> ResponseSetOption {
-        Default::default()
-    }
-
     /// Used during state sync to discover available snapshots on peers.
     fn list_snapshots(&self) -> ResponseListSnapshots {
         Default::default()
@@ -124,7 +118,6 @@ impl<A: Application> RequestDispatcher for A {
                 Value::Echo(req) => response::Value::Echo(self.echo(req)),
                 Value::Flush(_) => response::Value::Flush(self.flush()),
                 Value::Info(req) => response::Value::Info(self.info(req)),
-                Value::SetOption(req) => response::Value::SetOption(self.set_option(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)),

abci/src/application/kvstore.rs

@@ -123,25 +123,25 @@ impl Application for KeyValueStoreApp {
             version: "0.1.0".to_string(),
             app_version: 1,
             last_block_height,
-            last_block_app_hash,
+            last_block_app_hash: last_block_app_hash.into(),
         }
     }
 
     fn query(&self, request: RequestQuery) -> ResponseQuery {
-        let key = match String::from_utf8(request.data.clone()) {
+        let key = match std::str::from_utf8(&request.data) {
             Ok(s) => s,
             Err(e) => panic!("Failed to intepret key as UTF-8: {}", e),
         };
         debug!("Attempting to get key: {}", key);
-        match self.get(key.clone()) {
+        match self.get(key) {
             Ok((height, value_opt)) => match value_opt {
                 Some(value) => ResponseQuery {
                     code: 0,
                     log: "exists".to_string(),
                     info: "".to_string(),
                     index: 0,
                     key: request.data,
-                    value: value.into_bytes(),
+                    value: value.into_bytes().into(),
                     proof_ops: None,
                     height,
                     codespace: "".to_string(),
@@ -152,7 +152,7 @@ impl Application for KeyValueStoreApp {
                     info: "".to_string(),
                     index: 0,
                     key: request.data,
-                    value: vec![],
+                    value: Default::default(),
                     proof_ops: None,
                     height,
                     codespace: "".to_string(),
@@ -165,18 +165,21 @@ impl Application for KeyValueStoreApp {
     fn check_tx(&self, _request: RequestCheckTx) -> ResponseCheckTx {
         ResponseCheckTx {
             code: 0,
-            data: vec![],
+            data: Default::default(),
             log: "".to_string(),
             info: "".to_string(),
             gas_wanted: 1,
             gas_used: 0,
             events: vec![],
             codespace: "".to_string(),
+            mempool_error: "".to_string(),
+            priority: 0,
+            sender: "".to_string(),
         }
     }
 
     fn deliver_tx(&self, request: RequestDeliverTx) -> ResponseDeliverTx {
-        let tx = String::from_utf8(request.tx).unwrap();
+        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])
@@ -186,7 +189,7 @@ impl Application for KeyValueStoreApp {
         let _ = self.set(key, value).unwrap();
         ResponseDeliverTx {
             code: 0,
-            data: vec![],
+            data: Default::default(),
             log: "".to_string(),
             info: "".to_string(),
             gas_wanted: 0,
@@ -195,18 +198,18 @@ impl Application for KeyValueStoreApp {
                 r#type: "app".to_string(),
                 attributes: vec![
                     EventAttribute {
-                        key: "key".as_bytes().to_owned(),
-                        value: key.as_bytes().to_owned(),
+                        key: "key".to_string(),
+                        value: key.to_string(),
                         index: true,
                     },
                     EventAttribute {
-                        key: "index_key".as_bytes().to_owned(),
-                        value: "index is working".as_bytes().to_owned(),
+                        key: "index_key".to_string(),
+                        value: "index is working".to_string(),
                         index: true,
                     },
                     EventAttribute {
-                        key: "noindex_key".as_bytes().to_owned(),
-                        value: "index is working".as_bytes().to_owned(),
+                        key: "noindex_key".to_string(),
+                        value: "index is working".to_string(),
                         index: false,
                     },
                 ],
@@ -221,7 +224,7 @@ impl Application for KeyValueStoreApp {
         let (height, app_hash) = channel_recv(&result_rx).unwrap();
         info!("Committed height {}", height);
         ResponseCommit {
-            data: app_hash,
+            data: app_hash.into(),
             retain_height: height - 1,
         }
     }

abci/src/client.rs

@@ -7,10 +7,9 @@ use tendermint_proto::abci::{
     request, response, RequestApplySnapshotChunk, RequestBeginBlock, RequestCheckTx, RequestCommit,
     RequestDeliverTx, RequestEndBlock, RequestFlush, RequestInfo, RequestInitChain,
     RequestListSnapshots, RequestLoadSnapshotChunk, RequestOfferSnapshot, RequestQuery,
-    RequestSetOption, ResponseApplySnapshotChunk, ResponseBeginBlock, ResponseCheckTx,
-    ResponseCommit, ResponseDeliverTx, ResponseEndBlock, ResponseFlush, ResponseInfo,
-    ResponseInitChain, ResponseListSnapshots, ResponseLoadSnapshotChunk, ResponseOfferSnapshot,
-    ResponseQuery, ResponseSetOption,
+    ResponseApplySnapshotChunk, ResponseBeginBlock, ResponseCheckTx, ResponseCommit,
+    ResponseDeliverTx, ResponseEndBlock, ResponseFlush, ResponseInfo, ResponseInitChain,
+    ResponseListSnapshots, ResponseLoadSnapshotChunk, ResponseOfferSnapshot, ResponseQuery,
 };
 use tendermint_proto::abci::{Request, RequestEcho, ResponseEcho};
 
@@ -113,11 +112,6 @@ impl Client {
         perform!(self, Commit, RequestCommit {})
     }
 
-    /// Request that the application set an option to a particular value.
-    pub fn set_option(&mut self, req: RequestSetOption) -> Result<ResponseSetOption, Error> {
-        perform!(self, SetOption, req)
-    }
-
     /// Used during state sync to discover available snapshots on peers.
     pub fn list_snapshots(&mut self) -> Result<ResponseListSnapshots, Error> {
         perform!(self, ListSnapshots, RequestListSnapshots {})

abci/tests/kvstore_app.rs

@@ -24,19 +24,19 @@ mod kvstore_app_integration {
 
         client
             .deliver_tx(RequestDeliverTx {
-                tx: "test-key=test-value".as_bytes().to_owned(),
+                tx: "test-key=test-value".as_bytes().into(),
             })
             .unwrap();
         client.commit().unwrap();
 
         let res = client
             .query(RequestQuery {
-                data: "test-key".as_bytes().to_owned(),
+                data: "test-key".as_bytes().into(),
                 path: "".to_string(),
                 height: 0,
                 prove: false,
             })
             .unwrap();
-        assert_eq!(res.value, "test-value".as_bytes().to_owned());
+        assert_eq!(res.value, "test-value".as_bytes());
     }
 }

light-client/src/evidence.rs

@@ -2,7 +2,7 @@
 
 use crate::{components::io::IoError, types::PeerId};
 
-use tendermint::abci::transaction::Hash;
+use tendermint_rpc::abci::transaction::Hash;
 
 use contracts::contract_trait;
 

light-client/src/tests.rs

@@ -3,8 +3,8 @@
 use crate::types::{Height, LightBlock, PeerId, SignedHeader, Time, TrustThreshold, ValidatorSet};
 
 use serde::{Deserialize, Serialize};
-use tendermint::abci::transaction::Hash;
 use tendermint_rpc as rpc;
+use tendermint_rpc::abci::transaction::Hash;
 
 use crate::components::clock::Clock;
 use crate::components::io::{AtHeight, Io, IoError};

p2p/src/secret_connection.rs

@@ -185,7 +185,7 @@ impl Handshake<AwaitingAuthSig> {
             proto::crypto::public_key::Sum::Ed25519(ref bytes) => {
                 ed25519::PublicKey::from_bytes(bytes).map_err(Error::signature)
             }
-            proto::crypto::public_key::Sum::Secp256k1(_) => Err(Error::unsupported_key()),
+            _ => Err(Error::unsupported_key()),
         }?;
 
         let remote_sig =

proto/Cargo.toml

@@ -19,7 +19,7 @@ all-features = true
 [dependencies]
 prost = { version = "0.9", default-features = false }
 prost-types = { version = "0.9", default-features = false }
-bytes = { version = "1.0", default-features = false }
+bytes = { version = "1.0", default-features = false, features = ["serde"] }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 serde_bytes = { version = "0.11", default-features = false, features = ["alloc"] }
 subtle-encoding = { version = "0.5", default-features = false, features = ["hex", "base64", "alloc"] }

proto/src/chrono.rs

@@ -0,0 +1,53 @@
+use core::convert::TryInto;
+
+use chrono::{DateTime, Duration, TimeZone, Utc};
+
+use crate::google::protobuf as pb;
+
+impl From<DateTime<Utc>> for pb::Timestamp {
+    fn from(dt: DateTime<Utc>) -> pb::Timestamp {
+        pb::Timestamp {
+            seconds: dt.timestamp(),
+            // This can exceed 1_000_000_000 in the case of a leap second, but
+            // even with a leap second it should be under 2_147_483_647.
+            nanos: dt
+                .timestamp_subsec_nanos()
+                .try_into()
+                .expect("timestamp_subsec_nanos bigger than i32::MAX"),
+        }
+    }
+}
+
+impl From<pb::Timestamp> for DateTime<Utc> {
+    fn from(ts: pb::Timestamp) -> DateTime<Utc> {
+        Utc.timestamp(ts.seconds, ts.nanos as u32)
+    }
+}
+
+// Note: we convert a protobuf::Duration into a chrono::Duration, not a
+// std::time::Duration, because std::time::Durations are unsigned, but the
+// protobuf duration is signed.
+
+impl From<Duration> for pb::Duration {
+    fn from(d: Duration) -> pb::Duration {
+        // chrono's Duration stores the fractional part as `nanos: i32`
+        // internally but doesn't provide a way to access it, only a way to get
+        // the *total* number of nanoseconds. so we have to do this cool and fun
+        // hoop-jumping maneuver
+        let seconds = d.num_seconds();
+        let nanos = (d - Duration::seconds(seconds))
+            .num_nanoseconds()
+            .expect("we computed the fractional part, so there's no overflow")
+            .try_into()
+            .expect("the fractional part fits in i32");
+
+        pb::Duration { seconds, nanos }
+    }
+}
+
+impl From<pb::Duration> for Duration {
+    fn from(d: pb::Duration) -> Duration {
+        // there's no constructor that supplies both at once
+        Duration::seconds(d.seconds) + Duration::nanoseconds(d.nanos as i64)
+    }
+}

proto/src/lib.rs

@@ -20,6 +20,7 @@ pub mod google {
     }
 }
 
+mod chrono;
 mod error;
 #[allow(warnings)]
 mod tendermint;