The MASP conversions query now requires a MASP epoch to be specified.

Author: murisi

crates/apps_lib/src/client/rpc.rs

@@ -2123,55 +2123,67 @@ pub async fn query_conversions(
         .wallet()
         .await
         .get_addresses_with_vp_type(AddressVpType::Token);
-    let conversions = rpc::query_conversions(context.client())
-        .await
-        .expect("Conversions should be defined");
-
-    if args.dump_tree {
-        display_line!(context.io(), "Conversions: {conversions:?}");
-    }
-
+    // Determine the range of relevant MASP epochs
+    let epoch_range = if let Some(target_epoch) = &args.epoch {
+        MaspEpoch::iter_bounds_inclusive(*target_epoch, *target_epoch)
+    } else {
+        let from = MaspEpoch::zero();
+        let to = rpc::query_masp_epoch(context.client())
+            .await
+            .expect("Unable to query current MASP epoch");
+        MaspEpoch::iter_bounds_inclusive(from, to)
+    };
     // Track whether any non-sentinel conversions are found
     let mut conversions_found = false;
-    for (addr, _denom, digit, epoch, amt) in conversions.values() {
-        // If the user has specified any targets, then meet them
-        // If we have a sentinel conversion, then skip printing
-        if matches!(&target_token, Some(target) if target != addr)
-            || matches!(&args.epoch, Some(target) if target != epoch)
-            || amt.is_zero()
-        {
-            continue;
+    // Query the conversions for each relevant epoch
+    for epoch in epoch_range {
+        let conversions = rpc::query_conversions(context.client(), &epoch)
+            .await
+            .expect("Conversions should be defined");
+
+        if args.dump_tree {
+            display_line!(context.io(), "Conversions: {conversions:?}");
         }
-        conversions_found = true;
-        // Print the asset to which the conversion applies
-        display!(
-            context.io(),
-            "{}*2^{}[{}]: ",
-            tokens.get(addr).cloned().unwrap_or_else(|| addr.clone()),
-            *digit as u8 * 64,
-            epoch,
-        );
-        // Now print out the components of the allowed conversion
-        let mut prefix = "";
-        for (asset_type, val) in amt.components() {
-            // Look up the address and epoch of asset to facilitate pretty
-            // printing
-            let (addr, _denom, digit, epoch, _) = &conversions[asset_type];
-            // Now print out this component of the conversion
+
+        for (addr, _denom, digit, amt) in conversions.values() {
+            // If the user has specified any targets, then meet them
+            // If we have a sentinel conversion, then skip printing
+            if matches!(&target_token, Some(target) if target != addr)
+                || amt.is_zero()
+            {
+                continue;
+            }
+            conversions_found = true;
+            // Print the asset to which the conversion applies
             display!(
                 context.io(),
-                "{}{} {}*2^{}[{}]",
-                prefix,
-                val,
+                "{}*2^{}[{}]: ",
                 tokens.get(addr).cloned().unwrap_or_else(|| addr.clone()),
                 *digit as u8 * 64,
-                epoch
+                epoch,
             );
-            // Future iterations need to be prefixed with +
-            prefix = " + ";
+            // Now print out the components of the allowed conversion
+            let mut prefix = "";
+            for (asset_type, val) in amt.components() {
+                // Look up the address and epoch of asset to facilitate pretty
+                // printing
+                let (addr, _denom, digit, _) = &conversions[asset_type];
+                // Now print out this component of the conversion
+                display!(
+                    context.io(),
+                    "{}{} {}*2^{}[{}]",
+                    prefix,
+                    val,
+                    tokens.get(addr).cloned().unwrap_or_else(|| addr.clone()),
+                    *digit as u8 * 64,
+                    epoch
+                );
+                // Future iterations need to be prefixed with +
+                prefix = " + ";
+            }
+            // Allowed conversions are always implicit equations
+            display_line!(context.io(), " = 0");
         }
-        // Allowed conversions are always implicit equations
-        display_line!(context.io(), " = 0");
     }
     if !conversions_found {
         display_line!(

crates/sdk/src/queries/shell.rs

@@ -42,7 +42,6 @@ type ConversionWithoutPath = (
     Address,
     Denomination,
     MaspDigitPos,
-    MaspEpoch,
     masp_primitives::transaction::components::I128Sum,
 );
 
@@ -98,7 +97,7 @@ router! {SHELL,
     ( "conv" / [asset_type: AssetType] ) -> Option<Conversion> = read_conversion,
 
     // Conversion state access - read conversion
-    ( "conversions" ) -> BTreeMap<AssetType, ConversionWithoutPath> = read_conversions,
+    ( "conversions" / [masp_epoch: MaspEpoch] ) -> BTreeMap<AssetType, ConversionWithoutPath> = read_conversions,
 
     // Conversion state access - read conversion
     ( "masp_reward_tokens" ) -> Vec<MaspTokenRewardData> = masp_reward_tokens,
@@ -211,6 +210,7 @@ where
 /// Query to read the conversion state
 fn read_conversions<D, H, V, T>(
     ctx: RequestCtx<'_, D, H, V, T>,
+    masp_epoch: MaspEpoch,
 ) -> namada_storage::Result<BTreeMap<AssetType, ConversionWithoutPath>>
 where
     D: 'static + DB + for<'iter> DBIter<'iter> + Sync,
@@ -222,14 +222,14 @@ where
         .conversion_state
         .assets
         .iter()
+        .filter(|&(_, asset)| (asset.epoch == masp_epoch))
         .map(|(&asset_type, asset)| {
             (
                 asset_type,
                 (
                     asset.token.clone(),
                     asset.denom,
                     asset.digit_pos,
-                    asset.epoch,
                     asset.conversion.clone().into(),
                 ),
             )

crates/sdk/src/rpc.rs

@@ -390,20 +390,22 @@ pub async fn query_conversion<C: namada_io::Client + Sync>(
 /// Query conversions
 pub async fn query_conversions<C: namada_io::Client + Sync>(
     client: &C,
+    masp_epoch: &MaspEpoch,
 ) -> Result<
     BTreeMap<
         AssetType,
         (
             Address,
             Denomination,
             MaspDigitPos,
-            MaspEpoch,
             masp_primitives::transaction::components::I128Sum,
         ),
     >,
     error::Error,
 > {
-    convert_response::<C, _>(RPC.shell().read_conversions(client).await)
+    convert_response::<C, _>(
+        RPC.shell().read_conversions(client, masp_epoch).await,
+    )
 }
 
 /// Query the total rewards minted by MASP