Bridge Pool CLI tests

apps/src/lib/client/eth_bridge_pool.rs

@@ -1,6 +1,9 @@
+use std::collections::HashMap;
+
 use borsh::BorshSerialize;
 use namada::ledger::queries::RPC;
 use namada::proto::Tx;
+use namada::types::eth_abi::Encode;
 use namada::types::eth_bridge_pool::{
     GasFee, PendingTransfer, TransferToEthereum,
 };
@@ -67,11 +70,19 @@ pub async fn construct_bridge_pool_proof(args: args::BridgePoolProof) {
 /// Prints out a json payload.
 pub async fn query_bridge_pool(args: args::Query) {
     let client = HttpClient::new(args.ledger_address).unwrap();
-    let response = RPC
+    let response: Vec<PendingTransfer> = RPC
         .shell()
         .read_ethereum_bridge_pool(&client)
         .await
         .unwrap();
-
-    println!("{:#?}", serde_json::to_string_pretty(&response));
+    let pool_contents: HashMap<String, PendingTransfer> = response
+        .into_iter()
+        .map(|transfer| (transfer.keccak256().to_string(), transfer))
+        .collect();
+    if pool_contents.is_empty() {
+        println!("Bridge pool is empty.");
+    } else {
+        println!("Bridge pool contents: ");
+    }
+    println!("{}", serde_json::to_string_pretty(&pool_contents).unwrap());
 }

apps/src/lib/config/genesis.rs

@@ -6,13 +6,16 @@ use std::path::Path;
 
 use borsh::{BorshDeserialize, BorshSerialize};
 use derivative::Derivative;
-use namada::ledger::eth_bridge::parameters::EthereumBridgeConfig;
+use namada::ledger::eth_bridge::parameters::{
+    Contracts, EthereumBridgeConfig, UpgradeableContract,
+};
 use namada::ledger::governance::parameters::GovParams;
 use namada::ledger::parameters::Parameters;
 use namada::ledger::pos::{GenesisValidator, PosParams};
-use namada::types::address::Address;
+use namada::types::address::{wnam, Address};
 #[cfg(not(feature = "dev"))]
 use namada::types::chain::ChainId;
+use namada::types::ethereum_events::EthAddress;
 use namada::types::key::dkg_session_keys::DkgPublicKey;
 use namada::types::key::*;
 use namada::types::time::DateTimeUtc;
@@ -881,7 +884,20 @@ pub fn genesis() -> Genesis {
         parameters,
         pos_params: PosParams::default(),
         gov_params: GovParams::default(),
-        ethereum_bridge_params: None,
+        ethereum_bridge_params: Some(EthereumBridgeConfig {
+            min_confirmations: Default::default(),
+            contracts: Contracts {
+                native_erc20: wnam(),
+                bridge: UpgradeableContract {
+                    address: EthAddress([0; 20]),
+                    version: Default::default(),
+                },
+                governance: UpgradeableContract {
+                    address: EthAddress([1; 20]),
+                    version: Default::default(),
+                },
+            },
+        }),
     }
 }
 

apps/src/lib/node/ledger/shell/init_chain.rs

@@ -73,6 +73,7 @@ where
         genesis.gov_params.init_storage(&mut self.storage);
         // configure the Ethereum bridge if the configuration is set.
         if let Some(config) = genesis.ethereum_bridge_params {
+            tracing::debug!("Initializing Ethereum bridge storage.");
             config.init_storage(&mut self.storage);
         }
 

proof_of_stake/src/lib.rs

@@ -1046,8 +1046,6 @@ pub enum BondError<Address: Display + Debug> {
     InactiveValidator(Address),
     #[error("Voting power overflow: {0}")]
     VotingPowerOverflow(TryFromIntError),
-    #[error("Given zero amount to bond")]
-    ZeroAmount,
 }
 
 #[allow(missing_docs)]
@@ -1065,8 +1063,6 @@ pub enum UnbondError<Address: Display + Debug, TokenAmount: Display + Debug> {
     ValidatorHasNoVotingPower(Address),
     #[error("Voting power overflow: {0}")]
     VotingPowerOverflow(TryFromIntError),
-    #[error("Given zero amount to unbond")]
-    ZeroAmount,
 }
 
 #[allow(missing_docs)]
@@ -1611,9 +1607,6 @@ where
         + BorshSerialize
         + BorshSchema,
 {
-    if amount == TokenAmount::default() {
-        return Err(BondError::ZeroAmount);
-    }
     // Check the validator state
     match validator_state {
         None => {
@@ -1791,9 +1784,6 @@ where
         + BorshSerialize
         + BorshSchema,
 {
-    if amount == TokenAmount::default() {
-        return Err(UnbondError::ZeroAmount);
-    }
     // We can unbond tokens that are bonded for a future epoch (not yet
     // active), hence we check the total at the pipeline offset
     let unbondable_amount = bond

shared/src/ledger/queries/shell.rs

@@ -250,11 +250,7 @@ where
             let proof = if request.prove {
                 let proof = ctx
                     .storage
-                    .get_existence_proof(
-                        &storage_key,
-                        value.clone(),
-                        request.height,
-                    )
+                    .get_existence_proof(&storage_key, &value, request.height)
                     .into_storage_result()?;
                 Some(proof)
             } else {
@@ -309,7 +305,7 @@ where
         for PrefixValue { key, value } in &data {
             let mut proof = ctx
                 .storage
-                .get_existence_proof(key, value.clone(), request.height)
+                .get_existence_proof(key, value, request.height)
                 .into_storage_result()?;
             ops.append(&mut proof.ops);
         }
@@ -477,7 +473,10 @@ where
             )));
         }
         // get the membership proof
-        match tree.get_sub_tree_existence_proof(&keys, values) {
+        match tree.get_sub_tree_existence_proof(
+            &keys,
+            values.iter().map(|v| v.as_slice()).collect(),
+        ) {
             Ok(BridgePool(proof)) => {
                 let data = EncodeCell::new(&RelayProof {
                     // TODO: use actual validators

shared/src/ledger/storage/merkle_tree.rs

@@ -56,7 +56,7 @@ pub enum Error {
 type Result<T> = std::result::Result<T, Error>;
 
 /// Type alias for bytes to be put into the Merkle storage
-pub(super) type StorageBytes = Vec<u8>;
+pub(super) type StorageBytes<'a> = &'a [u8];
 
 /// Type aliases for the different merkle trees and backing stores
 pub type SmtStore = DefaultStore<SmtHash, Hash, 32>;
@@ -733,7 +733,7 @@ mod test {
         let proof = match tree
             .get_sub_tree_existence_proof(
                 std::array::from_ref(&ibc_key),
-                vec![ibc_val.clone()],
+                vec![&ibc_val],
             )
             .unwrap()
         {
@@ -792,7 +792,7 @@ mod test {
         let proof = match tree
             .get_sub_tree_existence_proof(
                 std::array::from_ref(&pos_key),
-                vec![pos_val.clone()],
+                vec![&pos_val],
             )
             .unwrap()
         {

shared/src/ledger/storage/mod.rs

@@ -36,7 +36,7 @@ use crate::ledger::pos::namada_proof_of_stake::PosBase;
 use crate::ledger::pos::types::WeightedValidator;
 use crate::ledger::pos::PosParams;
 use crate::ledger::storage::merkle_tree::{
-    Error as MerkleTreeError, MerkleRoot,
+    Error as MerkleTreeError, MerkleRoot, StorageBytes,
 };
 pub use crate::ledger::storage::merkle_tree::{
     MerkleTree, MerkleTreeStoresRead, MerkleTreeStoresWrite, StoreRef,
@@ -619,7 +619,7 @@ where
     pub fn get_existence_proof(
         &self,
         key: &Key,
-        value: Vec<u8>,
+        value: StorageBytes,
         height: BlockHeight,
     ) -> Result<Proof> {
         if height >= self.get_block_height().0 {

shared/src/ledger/storage/traits.rs

@@ -38,7 +38,7 @@ pub trait SubTreeWrite {
     fn subtree_update(
         &mut self,
         key: &Key,
-        value: &[u8],
+        value: StorageBytes,
     ) -> Result<Hash, Error>;
     /// Delete a key from the sub-tree
     fn subtree_delete(&mut self, key: &Key) -> Result<Hash, Error>;
@@ -68,7 +68,7 @@ impl<'a, H: StorageHasher + Default> SubTreeRead for &'a Smt<H> {
             Ics23Proof::Exist(ep) => Ok(CommitmentProof {
                 proof: Some(Ics23Proof::Exist(ExistenceProof {
                     key: key.to_string().as_bytes().to_vec(),
-                    value,
+                    value: value.to_vec(),
                     leaf: Some(ics23_specs::leaf_spec::<H>()),
                     ..ep
                 })),
@@ -84,7 +84,7 @@ impl<'a, H: StorageHasher + Default> SubTreeWrite for &'a mut Smt<H> {
     fn subtree_update(
         &mut self,
         key: &Key,
-        value: &[u8],
+        value: StorageBytes,
     ) -> Result<Hash, Error> {
         let value = H::hash(value);
         self.update(H::hash(key.to_string()).into(), value.into())
@@ -139,7 +139,7 @@ impl<'a, H: StorageHasher + Default> SubTreeWrite for &'a mut Amt<H> {
     fn subtree_update(
         &mut self,
         key: &Key,
-        value: &[u8],
+        value: StorageBytes,
     ) -> Result<Hash, Error> {
         let key = StringKey::try_from_bytes(key.to_string().as_bytes())?;
         let value = TreeBytes::from(value.as_ref().to_owned());
@@ -170,9 +170,7 @@ impl<'a> SubTreeRead for &'a BridgePoolTree {
     ) -> Result<MembershipProof, Error> {
         let values = values
             .iter()
-            .filter_map(|val| {
-                PendingTransfer::try_from_slice(val.as_slice()).ok()
-            })
+            .filter_map(|val| PendingTransfer::try_from_slice(val).ok())
             .collect();
         self.get_membership_proof(values)
             .map(Into::into)
@@ -181,7 +179,11 @@ impl<'a> SubTreeRead for &'a BridgePoolTree {
 }
 
 impl<'a> SubTreeWrite for &'a mut BridgePoolTree {
-    fn subtree_update(&mut self, key: &Key, _: &[u8]) -> Result<Hash, Error> {
+    fn subtree_update(
+        &mut self,
+        key: &Key,
+        _: StorageBytes,
+    ) -> Result<Hash, Error> {
         self.insert_key(key)
             .map_err(|err| Error::MerkleTree(err.to_string()))
     }

shared/src/types/token.rs

@@ -234,7 +234,7 @@ impl FromStr for Amount {
         match rust_decimal::Decimal::from_str(s) {
             Ok(decimal) => {
                 let scale = decimal.scale();
-                if scale > 6 {
+                if scale > MAX_DECIMAL_PLACES {
                     return Err(AmountParseError::ScaleTooLarge(scale));
                 }
                 let whole =
@@ -518,4 +518,12 @@ pub mod testing {
     pub fn arb_amount_ceiled(max: u64) -> impl Strategy<Value = Amount> {
         (0..=max).prop_map(Amount::from)
     }
+
+    /// Generate an arbitrary non-zero token amount up to and including given
+    /// `max` value
+    pub fn arb_amount_non_zero_ceiled(
+        max: u64,
+    ) -> impl Strategy<Value = Amount> {
+        (1..=max).prop_map(Amount::from)
+    }
 }