Merge pull request #4445 from anoma/murisi/generate-whitelisted-addresses

Adjusted test vector generator to also generate tokens in whitelist.

Author: mergify[bot]

.changelog/unreleased/improvements/4445-generate-whitelisted-addresses.md

@@ -0,0 +1,2 @@
+- Generate test vectors that use whitelisted tokens for the hardware wallet.
+  ([\#4445](https://github.com/anoma/namada/pull/4445))

.github/workflows/ci.yml

@@ -35,7 +35,7 @@ env:
   AWS_REGION: us-west-2
   NIGHTLY: nightly-2024-09-08
   NAMADA_MASP_PARAMS_DIR: /masp/.masp-params
-  LEDGER_APP_VERSION: "3.0.1"
+  LEDGER_APP_VERSION: "3.0.4"
   ROLE: arn:aws:iam::375643557360:role/github-runners-ci-shared
 
 jobs:

crates/core/src/address.rs

@@ -811,6 +811,7 @@ pub mod testing {
         prop_oneof![
             arb_established_address().prop_map(Address::Established),
             arb_implicit_address().prop_map(Address::Implicit),
+            arb_whitelisted_address(),
         ]
     }
 
@@ -820,9 +821,45 @@ pub mod testing {
             arb_established_address().prop_map(Address::Established),
             arb_implicit_address().prop_map(Address::Implicit),
             arb_internal_address().prop_map(Address::Internal),
+            arb_whitelisted_address(),
         ]
     }
 
+    /// A list of tokens whitelisted on hardware wallets
+    pub fn address_whitelist() -> HashMap<Address, &'static str> {
+        const EXPECT: &str = "The token address decoding shouldn't fail";
+        let nam =
+            Address::decode("tnam1q9gr66cvu4hrzm0sd5kmlnjje82gs3xlfg3v6nu7");
+        let osmo =
+            Address::decode("tnam1p5z8ruwyu7ha8urhq2l0dhpk2f5dv3ts7uyf2n75");
+        let atom =
+            Address::decode("tnam1pkg30gnt4q0zn7j00r6hms4ajrxn6f5ysyyl7w9m");
+        let tia =
+            Address::decode("tnam1pklj3kwp0cpsdvv56584rsajty974527qsp8n0nm");
+        let st_osmo =
+            Address::decode("tnam1p4px8sw3am4qvetj7eu77gftm4fz4hcw2ulpldc7");
+        let st_atom =
+            Address::decode("tnam1p5z5538v3kdk3wdx7r2hpqm4uq9926dz3ughcp7n");
+        let st_tia =
+            Address::decode("tnam1ph6xhf0defk65hm7l5ursscwqdj8ehrcdv300u4g");
+        let mut whitelist = HashMap::new();
+        whitelist.insert(nam.expect(EXPECT), "NAM");
+        whitelist.insert(osmo.expect(EXPECT), "uOSMO");
+        whitelist.insert(atom.expect(EXPECT), "uATOM");
+        whitelist.insert(tia.expect(EXPECT), "uTIA");
+        whitelist.insert(st_osmo.expect(EXPECT), "ustOSMO");
+        whitelist.insert(st_atom.expect(EXPECT), "ustATOM");
+        whitelist.insert(st_tia.expect(EXPECT), "ustTIA");
+        whitelist
+    }
+
+    /// Generate an arbitrary whitelisted address
+    pub fn arb_whitelisted_address() -> impl Strategy<Value = Address> {
+        any::<prop::sample::Selector>().prop_map(|selector| {
+            selector.select(address_whitelist().keys().cloned())
+        })
+    }
+
     /// Generate an arbitrary [`EstablishedAddress`].
     pub fn arb_established_address() -> impl Strategy<Value = EstablishedAddress>
     {

crates/sdk/src/lib.rs

@@ -857,9 +857,7 @@ pub mod testing {
     use governance::ProposalType;
     use masp_primitives::transaction::components::sapling::builder::StoredBuildParams;
     use namada_account::{InitAccount, UpdateAccount};
-    use namada_core::address::testing::{
-        arb_established_address, arb_non_internal_address,
-    };
+    use namada_core::address::testing::arb_non_internal_address;
     use namada_core::collections::{HashMap, HashSet};
     use namada_core::eth_bridge_pool::PendingTransfer;
     use namada_core::hash::testing::arb_hash;
@@ -1020,7 +1018,7 @@ pub mod testing {
         /// Generate an arbitrary fee
         pub fn arb_fee()(
             amount_per_gas_unit in arb_denominated_amount(),
-            token in arb_established_address().prop_map(Address::Established),
+            token in arb_non_internal_address(),
         ) -> Fee {
             Fee {
                 amount_per_gas_unit,

crates/sdk/src/signing.rs

@@ -50,7 +50,6 @@ use crate::error::{EncodingError, Error, TxSubmitError};
 use crate::eth_bridge_pool::PendingTransfer;
 use crate::governance::storage::proposal::{AddRemove, PGFAction, PGFTarget};
 use crate::rpc::validate_amount;
-use crate::token::Account;
 use crate::tx::{
     Commitment, TX_BECOME_VALIDATOR_WASM, TX_BOND_WASM, TX_BRIDGE_POOL_WASM,
     TX_CHANGE_COMMISSION_WASM, TX_CHANGE_CONSENSUS_KEY_WASM,
@@ -707,7 +706,7 @@ pub struct LedgerVector {
 
 /// Adds a Ledger output line describing a given transaction amount and address
 fn make_ledger_amount_addr(
-    tokens: &HashMap<Address, String>,
+    tokens: &HashMap<Address, &str>,
     output: &mut Vec<String>,
     amount: DenominatedAmount,
     token: &Address,
@@ -717,7 +716,7 @@ fn make_ledger_amount_addr(
         output.push(format!(
             "{}Amount : {} {}",
             prefix,
-            token.to_uppercase(),
+            token,
             to_ledger_decimal_variable_token(amount),
         ));
     } else {
@@ -735,7 +734,7 @@ fn make_ledger_amount_addr(
 /// Adds a Ledger output line describing a given transaction amount and asset
 /// type
 async fn make_ledger_amount_asset(
-    tokens: &HashMap<Address, String>,
+    tokens: &HashMap<Address, &str>,
     output: &mut Vec<String>,
     amount: u64,
     token: &AssetType,
@@ -752,7 +751,7 @@ async fn make_ledger_amount_asset(
             output.push(format!(
                 "{}Amount : {} {}",
                 prefix,
-                token.to_uppercase(),
+                token,
                 to_ledger_decimal_variable_token(amount),
             ));
         } else {
@@ -822,37 +821,26 @@ fn format_outputs(output: &mut Vec<String>) {
     }
 }
 
-/// Convert a map with key pairs into a nested structure
-fn nest_map<V>(
-    map: BTreeMap<Account, V>,
-) -> BTreeMap<Address, BTreeMap<Address, V>> {
-    let mut nested = BTreeMap::new();
-    for (account, v) in map {
-        let inner: &mut BTreeMap<_, _> =
-            nested.entry(account.owner).or_default();
-        inner.insert(account.token, v);
-    }
-    nested
-}
-
 /// Adds a Ledger output for the senders and destinations for transparent and
 /// MASP transactions
 async fn make_ledger_token_transfer_endpoints(
-    tokens: &HashMap<Address, String>,
+    tokens: &HashMap<Address, &str>,
     output: &mut Vec<String>,
     transfer: &token::Transfer,
     builder: Option<&MaspBuilder>,
     assets: &HashMap<AssetType, AssetData>,
 ) -> Result<(), Error> {
-    for (owner, changes) in nest_map(transfer.sources.clone()) {
+    for (owner, amount) in transfer.sources.clone() {
         // MASP inputs will be printed below
-        if owner != MASP {
-            output.push(format!("Sender : {}", owner));
-            for (token, amount) in changes {
-                make_ledger_amount_addr(
-                    tokens, output, amount, &token, "Sending ",
-                );
-            }
+        if owner.owner != MASP {
+            output.push(format!("Sender : {}", owner.owner));
+            make_ledger_amount_addr(
+                tokens,
+                output,
+                amount,
+                &owner.token,
+                "Sending ",
+            );
         }
     }
     if let Some(builder) = builder {
@@ -870,19 +858,17 @@ async fn make_ledger_token_transfer_endpoints(
             .await;
         }
     }
-    for (owner, changes) in nest_map(transfer.targets.clone()) {
+    for (owner, amount) in transfer.targets.clone() {
         // MASP outputs will be printed below
-        if owner != MASP {
-            output.push(format!("Destination : {}", owner));
-            for (token, amount) in changes {
-                make_ledger_amount_addr(
-                    tokens,
-                    output,
-                    amount,
-                    &token,
-                    "Receiving ",
-                );
-            }
+        if owner.owner != MASP {
+            output.push(format!("Destination : {}", owner.owner));
+            make_ledger_amount_addr(
+                tokens,
+                output,
+                amount,
+                &owner.token,
+                "Receiving ",
+            );
         }
     }
     if let Some(builder) = builder {
@@ -1156,16 +1142,9 @@ fn format_timeout_height(height: &TimeoutHeight) -> String {
 /// Converts the given transaction to the form that is displayed on the Ledger
 /// device
 pub async fn to_ledger_vector(
-    wallet: &Wallet<impl WalletIo>,
+    tokens: &HashMap<Address, &str>,
     tx: &Tx,
 ) -> Result<LedgerVector, Error> {
-    // To facilitate lookups of human-readable token names
-    let tokens: HashMap<Address, String> = wallet
-        .get_addresses()
-        .into_iter()
-        .map(|(alias, addr)| (addr, alias))
-        .collect();
-
     let mut tv = LedgerVector {
         blob: HEXLOWER.encode(&tx.serialize_to_vec()),
         index: 0,
@@ -1498,15 +1477,15 @@ pub async fn to_ledger_vector(
             )
             .map_err(|_| Error::Other("Invalid Data".to_string()))?;
             make_ledger_token_transfer_endpoints(
-                &tokens,
+                tokens,
                 &mut tv.output,
                 &transfer,
                 builder,
                 &asset_types,
             )
             .await?;
             make_ledger_token_transfer_endpoints(
-                &tokens,
+                tokens,
                 &mut tv.output_expert,
                 &transfer,
                 builder,
@@ -1596,15 +1575,15 @@ pub async fn to_ledger_vector(
                     )
                     .map_err(|_| Error::Other("Invalid Data".to_string()))?;
                     make_ledger_token_transfer_endpoints(
-                        &tokens,
+                        tokens,
                         &mut tv.output,
                         &transfer,
                         builder,
                         &asset_types,
                     )
                     .await?;
                     make_ledger_token_transfer_endpoints(
-                        &tokens,
+                        tokens,
                         &mut tv.output_expert,
                         &transfer,
                         builder,
@@ -1765,15 +1744,15 @@ pub async fn to_ledger_vector(
                     )
                     .map_err(|_| Error::Other("Invalid Data".to_string()))?;
                     make_ledger_token_transfer_endpoints(
-                        &tokens,
+                        tokens,
                         &mut tv.output,
                         &transfer,
                         builder,
                         &asset_types,
                     )
                     .await?;
                     make_ledger_token_transfer_endpoints(
-                        &tokens,
+                        tokens,
                         &mut tv.output_expert,
                         &transfer,
                         builder,
@@ -2218,15 +2197,10 @@ pub async fn to_ledger_vector(
                 format!("Gas limit : {}", u64::from(wrapper.gas_limit)),
             ]);
             if let Some(token) = tokens.get(&wrapper.fee.token) {
-                tv.output.push(format!(
-                    "Fee : {} {}",
-                    token.to_uppercase(),
-                    fee_limit
-                ));
+                tv.output.push(format!("Fee : {} {}", token, fee_limit));
                 tv.output_expert.push(format!(
                     "Fees/gas unit : {} {}",
-                    token.to_uppercase(),
-                    fee_amount_per_gas_unit,
+                    token, fee_amount_per_gas_unit,
                 ));
             } else {
                 tv.output.extend(vec![
@@ -2274,6 +2248,7 @@ mod test_signing {
     use crate::args::InputAmount;
     use crate::masp::fs::FsShieldedUtils;
     use crate::masp::{ShieldedContext, WalletMap};
+    use crate::token::Account;
 
     fn arbitrary_args() -> args::Tx {
         args::Tx {
@@ -2688,14 +2663,8 @@ mod test_signing {
             shielded_section_hash: None,
         };
         let tokens = HashMap::from([
-            (
-                Address::Internal(InternalAddress::Governance),
-                "SuperMoney".to_string(),
-            ),
-            (
-                Address::Internal(InternalAddress::Pgf),
-                "BloodMoney".to_string(),
-            ),
+            (Address::Internal(InternalAddress::Governance), "SuperMoney"),
+            (Address::Internal(InternalAddress::Pgf), "BloodMoney"),
         ]);
 
         let mut output = vec![];
@@ -2714,12 +2683,12 @@ mod test_signing {
                 "Sender : {}",
                 Address::Internal(InternalAddress::Governance)
             ),
-            "Sending Amount : SUPERMONEY 1".to_string(),
+            "Sending Amount : SuperMoney 1".to_string(),
             format!(
                 "Destination : {}",
                 Address::Internal(InternalAddress::Pgf)
             ),
-            "Receiving Amount : BLOODMONEY 2".to_string(),
+            "Receiving Amount : BloodMoney 2".to_string(),
         ];
         assert_eq!(output, expected);
         output.clear();
@@ -2761,8 +2730,7 @@ mod test_signing {
     /// extracts and validates the presence of a code section
     #[tokio::test]
     async fn test_to_ledger_vector_code_sections() {
-        let wallet =
-            Wallet::<TestWalletUtils>::new(TestWalletUtils, Default::default());
+        let wallet = HashMap::new();
         let mut tx = Tx::new(ChainId::default(), None);
         // an empty tx should work correctly
         to_ledger_vector(&wallet, &tx).await.expect("Test failed");

crates/token/src/lib.rs

@@ -338,9 +338,7 @@ pub mod testing {
     use masp_primitives::transaction::components::{TxOut, U64Sum};
     use masp_primitives::transaction::fees::fixed::FeeRule;
     use masp_primitives::zip32::PseudoExtendedKey;
-    use namada_core::address::testing::{
-        arb_established_address, arb_non_internal_address,
-    };
+    use namada_core::address::testing::arb_non_internal_address;
     use namada_core::address::{Address, MASP};
     use namada_core::collections::HashMap;
     use namada_core::masp::{encode_asset_type, AssetData, TAddrData};
@@ -367,7 +365,7 @@ pub mod testing {
         fn arb_single_transparent_transfer()(
             source in arb_non_internal_address(),
             target in arb_non_internal_address(),
-            token in arb_established_address().prop_map(Address::Established),
+            token in arb_non_internal_address(),
             amount in arb_denominated_amount(),
         ) -> (Address, Address, Address, DenominatedAmount) {
             (