Merge branch 'yuji/1.7.1-namada' into luca_joss/run-tests-with-namada

config.toml

@@ -154,7 +154,7 @@ port = 5555
 # Specify the chain ID. Required
 id = 'ibc-0'
 
-# Specify the chain type, currently only `CosmosSdk` is supported.
+# Specify the chain type, currently `CosmosSdk` and `Namada` are supported.
 # Default: CosmosSdk
 type = "CosmosSdk"
 

crates/relayer/Cargo.toml

@@ -90,6 +90,9 @@ features = ["num-bigint", "serde"]
 version = "0.34.0"
 features = ["secp256k1"]
 
+[dependencies.tendermint-config]
+version = "0.34.0"
+
 [dependencies.tendermint-proto]
 version = "0.34.0"
 
@@ -110,10 +113,21 @@ default-features = false
 version = "0.34.0"
 default-features = false
 
+[dependencies.namada_ibc]
+git = "https://github.com/anoma/namada"
+version = "0.33.0"
+
+[dependencies.namada_parameters]
+git = "https://github.com/anoma/namada"
+version = "0.33.0"
+
 [dependencies.namada_sdk]
 git = "https://github.com/anoma/namada"
-tag = "v0.29.0"
-features = ["std"]
+version = "0.33.0"
+
+[dependencies.namada_trans_token]
+git = "https://github.com/anoma/namada"
+version = "0.33.0"
 
 [dev-dependencies]
 ibc-relayer-types = { version = "0.27.0", path = "../relayer-types", features = ["mocks"] }

crates/relayer/src/chain/namada.rs

@@ -32,23 +32,24 @@ use ibc_relayer_types::core::ics24_host::path::{
 use ibc_relayer_types::events::IbcEvent;
 use ibc_relayer_types::signer::Signer;
 use ibc_relayer_types::Height as ICSHeight;
+use namada_ibc::storage;
+use namada_parameters::{storage as param_storage, EpochDuration};
+use namada_sdk::address::{Address, InternalAddress};
 use namada_sdk::borsh::BorshDeserialize;
-use namada_sdk::core::ledger::ibc::storage;
-use namada_sdk::core::ledger::parameters::{storage as param_storage, EpochDuration};
-use namada_sdk::core::ledger::storage::ics23_specs::ibc_proof_specs;
-use namada_sdk::core::ledger::storage::Sha256Hasher;
-use namada_sdk::core::types::address::{Address, InternalAddress};
-use namada_sdk::core::types::storage::{Key, KeySeg, PrefixValue};
-use namada_sdk::core::types::token;
 use namada_sdk::io::NullIo;
 use namada_sdk::masp::fs::FsShieldedUtils;
-use namada_sdk::masp::ShieldedContext;
+use namada_sdk::masp::DefaultLogger;
 use namada_sdk::proof_of_stake::storage_key as pos_storage_key;
 use namada_sdk::proof_of_stake::OwnedPosParams;
 use namada_sdk::queries::Client as SdkClient;
+use namada_sdk::state::ics23_specs::ibc_proof_specs;
+use namada_sdk::state::Sha256Hasher;
+use namada_sdk::storage::{Key, KeySeg, PrefixValue};
 use namada_sdk::wallet::Store;
 use namada_sdk::wallet::Wallet;
 use namada_sdk::{rpc, Namada, NamadaImpl};
+use namada_trans_token::storage_key::{balance_key, denom_key, is_any_token_balance_key};
+use namada_trans_token::{Amount, DenominatedAmount, Denomination};
 use tendermint::block::Height as TmHeight;
 use tendermint::{node, Time};
 use tendermint_light_client::types::LightBlock as TMLightBlock;
@@ -165,6 +166,24 @@ impl NamadaChain {
             .parse()
             .unwrap())
     }
+
+    async fn shielded_sync(&self) -> Result<(), Error> {
+        let mut shielded = self.ctx.shielded_mut().await;
+        let _ = shielded.load().await;
+        shielded
+            .fetch(
+                self.ctx.client(),
+                &DefaultLogger::new(self.ctx.io()),
+                None,
+                None,
+                1,
+                &[],
+                &[],
+            )
+            .await
+            .map_err(NamadaError::namada)?;
+        shielded.save().await.map_err(Error::io)
+    }
 }
 
 impl ChainEndpoint for NamadaChain {
@@ -180,7 +199,7 @@ impl ChainEndpoint for NamadaChain {
     }
 
     fn config(&self) -> ChainConfig {
-        ChainConfig::CosmosSdk(self.config.clone())
+        ChainConfig::Namada(self.config.clone())
     }
 
     fn bootstrap(config: ChainConfig, rt: Arc<TokioRuntime>) -> Result<Self, Error> {
@@ -201,7 +220,12 @@ impl ChainEndpoint for NamadaChain {
             KeyRing::new_namada(config.key_store_type, &config.id, &config.key_store_folder)
                 .map_err(Error::key_base)?;
 
-        let shielded_ctx = ShieldedContext::<FsShieldedUtils>::default();
+        let shielded_dir = dirs_next::home_dir()
+            .expect("No home directory")
+            .join(".hermes/shielded")
+            .join(config.id.to_string());
+        std::fs::create_dir_all(&shielded_dir).map_err(Error::io)?;
+        let shielded_ctx = FsShieldedUtils::new(shielded_dir);
 
         let mut store = Store::default();
         let key = keybase
@@ -409,24 +433,23 @@ impl ChainEndpoint for NamadaChain {
         let token =
             Address::decode(denom).map_err(|_| NamadaError::address_decode(denom.to_string()))?;
 
-        let balance_key = token::balance_key(&token, &owner);
+        let balance_key = balance_key(&token, &owner);
         let (value, _) = self.query(balance_key, QueryHeight::Latest, IncludeProof::No)?;
         if value.is_empty() {
             return Ok(Balance {
                 amount: "0".to_string(),
                 denom: denom.to_string(),
             });
         }
-        let amount =
-            token::Amount::try_from_slice(&value[..]).map_err(NamadaError::borsh_decode)?;
-        let denom_key = token::denom_key(&token);
+        let amount = Amount::try_from_slice(&value[..]).map_err(NamadaError::borsh_decode)?;
+        let denom_key = denom_key(&token);
         let (value, _) = self.query(denom_key, QueryHeight::Latest, IncludeProof::No)?;
         let denominated_amount = if value.is_empty() {
-            token::DenominatedAmount::new(amount, 0.into())
+            DenominatedAmount::new(amount, 0.into())
         } else {
-            let token_denom = token::Denomination::try_from_slice(&value[..])
-                .map_err(NamadaError::borsh_decode)?;
-            token::DenominatedAmount::new(amount, token_denom)
+            let token_denom =
+                Denomination::try_from_slice(&value[..]).map_err(NamadaError::borsh_decode)?;
+            DenominatedAmount::new(amount, token_denom)
         };
 
         Ok(Balance {
@@ -444,19 +467,19 @@ impl ChainEndpoint for NamadaChain {
         let mut balances = vec![];
         let prefix = Key::from(Address::Internal(InternalAddress::Multitoken).to_db_key());
         for PrefixValue { key, value } in self.query_prefix(prefix)? {
-            if let Some([token, bal_owner]) = token::is_any_token_balance_key(&key) {
+            if let Some([token, bal_owner]) = is_any_token_balance_key(&key) {
                 if owner == *bal_owner {
-                    let amount = token::Amount::try_from_slice(&value[..])
-                        .map_err(NamadaError::borsh_decode)?;
-                    let denom_key = token::denom_key(token);
+                    let amount =
+                        Amount::try_from_slice(&value[..]).map_err(NamadaError::borsh_decode)?;
+                    let denom_key = denom_key(token);
                     let (value, _) =
                         self.query(denom_key, QueryHeight::Latest, IncludeProof::No)?;
                     let denominated_amount = if value.is_empty() {
-                        token::DenominatedAmount::new(amount, 0.into())
+                        DenominatedAmount::new(amount, 0.into())
                     } else {
-                        let namada_denom = token::Denomination::try_from_slice(&value[..])
+                        let namada_denom = Denomination::try_from_slice(&value[..])
                             .map_err(NamadaError::borsh_decode)?;
-                        token::DenominatedAmount::new(amount, namada_denom)
+                        DenominatedAmount::new(amount, namada_denom)
                     };
                     let balance = Balance {
                         amount: denominated_amount.to_string(),

crates/relayer/src/chain/namada/key.rs

@@ -1,7 +1,7 @@
 use core::any::Any;
 
-use namada_sdk::core::types::address::Address;
-use namada_sdk::core::types::key::common::SecretKey;
+use namada_sdk::address::Address;
+use namada_sdk::key::common::SecretKey;
 
 use crate::config::AddressType;
 use crate::keyring::errors::Error;

crates/relayer/src/chain/namada/query.rs

@@ -3,12 +3,12 @@ use ibc_relayer_types::core::ics23_commitment::merkle::convert_tm_to_ics_merkle_
 use ibc_relayer_types::core::ics23_commitment::merkle::MerkleProof;
 use ibc_relayer_types::events::IbcEvent;
 use ibc_relayer_types::Height as ICSHeight;
+use namada_ibc::storage::{ibc_trace_key_prefix, is_ibc_trace_key};
+use namada_sdk::address::{Address, InternalAddress};
 use namada_sdk::borsh::BorshDeserialize;
-use namada_sdk::core::ledger::ibc::storage::{ibc_denom_key_prefix, is_ibc_denom_key};
-use namada_sdk::core::types::address::{Address, InternalAddress};
-use namada_sdk::core::types::storage::{BlockHeight, Epoch, Key, PrefixValue};
 use namada_sdk::queries::{Client as SdkClient, RPC};
 use namada_sdk::rpc;
+use namada_sdk::storage::{BlockHeight, Epoch, Key, PrefixValue};
 use namada_sdk::Namada;
 use tendermint::block::Height as TmHeight;
 
@@ -275,12 +275,12 @@ impl NamadaChain {
             _ => return Err(NamadaError::denom_not_found(raw_addr).into()),
         };
 
-        let prefix = ibc_denom_key_prefix(None);
+        let prefix = ibc_trace_key_prefix(None);
         let pairs = self.query_prefix(prefix)?;
         let pair = pairs
             .iter()
             .find(|PrefixValue { key, value: _ }| {
-                if let Some((_, token_hash)) = is_ibc_denom_key(key) {
+                if let Some((_, token_hash)) = is_ibc_trace_key(key) {
                     token_hash == *hash
                 } else {
                     false