Phase4

Cargo.toml

@@ -12,14 +12,13 @@ description = """
     use of tendermint-rs.
 """
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 bytes = "1.0.1"
 cosmrs = "0.3.0"
 flex-error = { version = "0.4.2", features = [ "eyre_tracer" ] }
-ibc = "0.8.0"
-ics23 = "0.6.0"
+ibc = "=0.8.0"
+ibc-proto = "=0.12.0"
+ics23 = "=0.6.7"
 prost = "0.9.0"
 prost-types = "0.9.0"
 serde = "1.0"
@@ -34,3 +33,7 @@ tracing = "0.1.26"
 tracing-subscriber = "0.2.18"
 tonic="0.6"
 tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }
+
+[patch.crates-io]
+ibc = { git = "https://github.com/informalsystems/ibc-rs.git", branch = "basecoin/phase-4-1" }
+ibc-proto = { git = "https://github.com/informalsystems/ibc-rs.git", branch = "basecoin/phase-4-1" }

docs/modules/ibc.md

@@ -11,14 +11,14 @@ This module has been tested with `hermes`.
 Edit your `genesis.json` file (default location `~/.tendermint/config/genesis.json`) to update the `chain_id`.
 ```json
 {
-  "chain_id": "basecoin"
+  "chain_id": "basecoin-0"
 }
 ```
 
 Edit the `config.toml` file (default location `~/.hermes/config.toml`) for `hermes` and add an entry for the basecoin chain:
 ```toml
 [[chains]]
-id = 'basecoin'
+id = 'basecoin-0'
 rpc_addr = 'http://127.0.0.1:26357'
 grpc_addr = 'http://127.0.0.1:9093'
 websocket_addr = 'ws://localhost:26357/websocket'
@@ -29,6 +29,62 @@ store_prefix = 'basecoin'
 gas_price = { price = 0.001, denom = 'stake' }
 clock_drift = '5s'
 trusting_period = '14days'
+proof_specs = '''
+[
+  {
+    "leaf_spec": {
+      "hash": 1,
+      "prehash_key": 0,
+      "prehash_value": 0,
+      "length": 0,
+      "prefix": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    },
+    "inner_spec": {
+      "child_order": [
+        0,
+        1,
+        2
+      ],
+      "child_size": 32,
+      "min_prefix_length": 0,
+      "max_prefix_length": 64,
+      "empty_child": [
+        0,
+        32
+      ],
+      "hash": 1
+    },
+    "max_depth": 0,
+    "min_depth": 0
+  },
+  {
+    "leaf_spec": {
+      "hash": 1,
+      "prehash_key": 0,
+      "prehash_value": 0,
+      "length": 0,
+      "prefix": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    },
+    "inner_spec": {
+      "child_order": [
+        0,
+        1,
+        2
+      ],
+      "child_size": 32,
+      "min_prefix_length": 0,
+      "max_prefix_length": 64,
+      "empty_child": [
+        0,
+        32
+      ],
+      "hash": 1
+    },
+    "max_depth": 0,
+    "min_depth": 0
+  }
+]
+'''
 ```
 **Note:** The above settings must match the corresponding settings in Tendermint's `config.toml`. 
 
@@ -47,6 +103,6 @@ $ hermes keys add basecoin-0 -f user_seed.json
 ### Step 4: Create and Update a client
 Assuming the `basecoin-0` chain and tendermint are running (see instructions on [README.md#run-the-basecoin-app-and-tendermint](../../README.md#step-4-run-the-basecoin-app-and-tendermint)). 
 ```shell
-$ hermes tx raw create-client basecoin ibc-0
-$ hermes tx raw update-client basecoin 07-tendermint-0
+$ hermes tx raw create-client basecoin-0 ibc-0
+$ hermes tx raw update-client basecoin-0 07-tendermint-0
 ```

src/app/mod.rs

@@ -2,12 +2,13 @@
 
 pub(crate) mod modules;
 mod response;
-
 pub(crate) mod store;
 
 use crate::app::modules::{prefix, Bank, Error, ErrorDetail, Ibc, Identifiable, Module};
 use crate::app::response::ResponseFromErrorExt;
-use crate::app::store::{Height, Path, ProvableStore, SharedStore, Store, SubStore, WalStore};
+use crate::app::store::{
+    Height, Identifier, Path, ProvableStore, RevertibleStore, SharedStore, Store, SubStore,
+};
 use crate::prostgen::cosmos::auth::v1beta1::{
     query_server::Query as AuthQuery, BaseAccount, QueryAccountRequest, QueryAccountResponse,
     QueryAccountsRequest, QueryAccountsResponse, QueryParamsRequest as AuthQueryParamsRequest,
@@ -34,6 +35,11 @@ use crate::prostgen::cosmos::staking::v1beta1::{
     QueryValidatorUnbondingDelegationsRequest, QueryValidatorUnbondingDelegationsResponse,
     QueryValidatorsRequest, QueryValidatorsResponse,
 };
+use crate::prostgen::cosmos::tx::v1beta1::service_server::Service as TxService;
+use crate::prostgen::cosmos::tx::v1beta1::{
+    BroadcastTxRequest, BroadcastTxResponse, GetTxRequest, GetTxResponse, GetTxsEventRequest,
+    GetTxsEventResponse, SimulateRequest, SimulateResponse,
+};
 
 use std::convert::TryInto;
 use std::sync::{Arc, RwLock};
@@ -47,48 +53,56 @@ use tendermint_proto::abci::{
     Event, RequestDeliverTx, RequestInfo, RequestInitChain, RequestQuery, ResponseCommit,
     ResponseDeliverTx, ResponseInfo, ResponseInitChain, ResponseQuery,
 };
+use tendermint_proto::crypto::ProofOp;
+use tendermint_proto::crypto::ProofOps;
 use tendermint_proto::p2p::DefaultNodeInfo;
 use tonic::{Request, Response, Status};
 use tracing::{debug, info};
 
+type MainStore<S> = SharedStore<RevertibleStore<S>>;
+type ModuleStore<S> = SubStore<MainStore<S>>;
+type Shared<T> = Arc<RwLock<T>>;
+
 /// BaseCoin ABCI application.
 ///
 /// Can be safely cloned and sent across threads, but not shared.
 #[derive(Clone)]
 pub(crate) struct BaseCoinApp<S> {
-    store: SharedStore<WalStore<S>>,
-    modules: Arc<RwLock<Vec<Box<dyn Module + Send + Sync>>>>,
+    store: MainStore<S>,
+    pub modules: Shared<Vec<Box<dyn Module<ModuleStore<S>> + Send + Sync>>>,
+    account: Shared<BaseAccount>, // TODO(hu55a1n1): get from user and move to provable store
 }
 
-impl<S: ProvableStore + 'static> BaseCoinApp<S> {
+impl<S: Default + ProvableStore + 'static> BaseCoinApp<S> {
     /// Constructor.
-    pub(crate) fn new(store: S) -> Self {
-        let store = SharedStore::new(WalStore::new(store));
+    pub(crate) fn new(store: S) -> Result<Self, S::Error> {
+        let store = SharedStore::new(RevertibleStore::new(store));
         // `SubStore` guarantees modules exclusive access to all paths in the store key-space.
-        let modules: Vec<Box<dyn Module + Send + Sync>> = vec![
-            Box::new(Bank {
-                store: SubStore::new(store.clone(), prefix::Bank),
-            }),
-            Box::new(Ibc {
-                store: SubStore::new(store.clone(), prefix::Ibc),
-                client_counter: 0,
-            }),
+        let modules: Vec<Box<dyn Module<ModuleStore<S>> + Send + Sync>> = vec![
+            Box::new(Bank::new(SubStore::new(
+                store.clone(),
+                prefix::Bank {}.identifier(),
+            )?)),
+            Box::new(Ibc::new(SubStore::new(
+                store.clone(),
+                prefix::Ibc {}.identifier(),
+            )?)),
         ];
-        Self {
+        Ok(Self {
             store,
             modules: Arc::new(RwLock::new(modules)),
-        }
+            account: Default::default(),
+        })
     }
+}
 
-    pub(crate) fn sub_store<I: Identifiable>(
-        &self,
-        prefix: I,
-    ) -> SubStore<SharedStore<WalStore<S>>, I> {
-        SubStore::new(self.store.clone(), prefix)
+impl<S: Default + ProvableStore> BaseCoinApp<S> {
+    pub(crate) fn get_store(&self, prefix: Identifier) -> Option<ModuleStore<S>> {
+        let modules = self.modules.read().unwrap();
+        let module = modules.iter().find(|m| m.store().prefix() == prefix);
+        module.map(|m| m.store())
     }
-}
 
-impl<S> BaseCoinApp<S> {
     // try to deliver the message to all registered modules
     // if `module.deliver()` returns `Error::not_handled()`, try next module
     // Return:
@@ -120,7 +134,7 @@ impl<S> BaseCoinApp<S> {
     }
 }
 
-impl<S: ProvableStore + 'static> Application for BaseCoinApp<S> {
+impl<S: Default + ProvableStore + 'static> Application for BaseCoinApp<S> {
     fn info(&self, request: RequestInfo) -> ResponseInfo {
         let (last_block_height, last_block_app_hash) = {
             let state = self.store.read().unwrap();
@@ -171,16 +185,44 @@ impl<S: ProvableStore + 'static> Application for BaseCoinApp<S> {
                 &request.data,
                 path.as_ref(),
                 Height::from(request.height as u64),
+                request.prove,
             ) {
                 // success - implies query was handled by this module, so return response
                 Ok(result) => {
+                    let store = self.store.read().unwrap();
+                    let proof_ops = if request.prove {
+                        let proof = store
+                            .get_proof(
+                                Height::from(request.height as u64),
+                                &"ibc".to_owned().try_into().unwrap(),
+                            )
+                            .unwrap();
+                        let mut buffer = Vec::new();
+                        proof.encode(&mut buffer).unwrap(); // safety - cannot fail since buf is a vector
+
+                        let mut ops = vec![];
+                        if let Some(mut proofs) = result.proof {
+                            ops.append(&mut proofs);
+                        }
+                        ops.push(ProofOp {
+                            r#type: "".to_string(),
+                            // FIXME(hu55a1n1)
+                            key: "ibc".to_string().into_bytes(),
+                            data: buffer,
+                        });
+                        Some(ProofOps { ops })
+                    } else {
+                        None
+                    };
+
                     return ResponseQuery {
                         code: 0,
                         log: "exists".to_string(),
                         key: request.data,
-                        value: result,
-                        height: self.store.read().unwrap().current_height() as i64,
-                        ..ResponseQuery::default()
+                        value: result.data,
+                        proof_ops,
+                        height: store.current_height() as i64,
+                        ..Default::default()
                     };
                 }
                 // `Error::not_handled()` - implies query isn't known or was intercepted but not
@@ -240,9 +282,20 @@ impl<S: ProvableStore + 'static> Application for BaseCoinApp<S> {
     }
 
     fn commit(&self) -> ResponseCommit {
+        let mut modules = self.modules.write().unwrap();
+        for m in modules.iter_mut() {
+            m.commit().expect("failed to commit to state");
+        }
+
         let mut state = self.store.write().unwrap();
         let data = state.commit().expect("failed to commit to state");
-        info!("Committed height {}", state.current_height() - 1);
+        info!(
+            "Committed height {} with hash({})",
+            state.current_height() - 1,
+            data.iter()
+                .map(|b| format!("{:02X}", b))
+                .collect::<String>()
+        );
         ResponseCommit {
             data,
             retain_height: 0,
@@ -327,9 +380,10 @@ impl<S: ProvableStore + 'static> AuthQuery for BaseCoinApp<S> {
     ) -> Result<Response<QueryAccountResponse>, Status> {
         debug!("Got auth account request");
 
-        let account = BaseAccount::default();
+        let mut account = self.account.write().unwrap();
         let mut buf = Vec::new();
         account.encode(&mut buf).unwrap(); // safety - cannot fail since buf is a vector
+        account.sequence += 1;
 
         Ok(Response::new(QueryAccountResponse {
             account: Some(Any {
@@ -457,3 +511,44 @@ impl<S: ProvableStore + 'static> StakingQuery for BaseCoinApp<S> {
         }))
     }
 }
+
+#[tonic::async_trait]
+impl<S: ProvableStore + 'static> TxService for BaseCoinApp<S> {
+    async fn simulate(
+        &self,
+        request: Request<SimulateRequest>,
+    ) -> Result<Response<SimulateResponse>, Status> {
+        // TODO(hu55a1n1): implement tx based simulate
+        let _: Tx = request
+            .into_inner()
+            .tx_bytes
+            .as_slice()
+            .try_into()
+            .map_err(|_| Status::invalid_argument("failed to deserialize tx"))?;
+        Ok(Response::new(SimulateResponse {
+            gas_info: None,
+            result: None,
+        }))
+    }
+
+    async fn get_tx(
+        &self,
+        _request: Request<GetTxRequest>,
+    ) -> Result<Response<GetTxResponse>, Status> {
+        unimplemented!()
+    }
+
+    async fn broadcast_tx(
+        &self,
+        _request: Request<BroadcastTxRequest>,
+    ) -> Result<Response<BroadcastTxResponse>, Status> {
+        unimplemented!()
+    }
+
+    async fn get_txs_event(
+        &self,
+        _request: Request<GetTxsEventRequest>,
+    ) -> Result<Response<GetTxsEventResponse>, Status> {
+        unimplemented!()
+    }
+}