Merge pull request #19 from namada-net/feat/notes-amounts-estimations

feat: notes amounts estimations

Author: mateuszjasiuk

crate/src/sdk/mod.rs

@@ -30,7 +30,7 @@ use namada_sdk::ibc::core::host::types::identifiers::{ChannelId, PortId};
 use namada_sdk::io::{Client, NamadaIo};
 use namada_sdk::key::{common, ed25519, RefTo, SigScheme};
 use namada_sdk::masp::shielded_wallet::ShieldedApi;
-use namada_sdk::masp::ShieldedContext;
+use namada_sdk::masp::{Conversions, ShieldedContext, SpentNotesTracker};
 use namada_sdk::masp_primitives::sapling::ViewingKey;
 use namada_sdk::masp_primitives::transaction::components::amount::I128Sum;
 use namada_sdk::masp_primitives::transaction::TxId;
@@ -691,9 +691,21 @@ impl Sdk {
             }
         };
 
+        let masp_section = tx
+            .sections
+            .iter()
+            .find_map(|section| section.masp_tx())
+            .ok_or_err_msg("Could not find masp_tx section")?;
+
+        self.namada
+            .shielded_mut()
+            .await
+            .pre_cache_transaction(&masp_section)
+            .await
+            .map_err(|e| JsError::new(&e.to_string()))?;
+
         self.serialize_tx_result(tx, wrapper_tx_msg, signing_data, Some(masp_signing_data))
     }
-
     pub async fn build_unshielding_transfer(
         &self,
         unshielding_transfer_msg: &[u8],
@@ -1165,6 +1177,95 @@ impl Sdk {
         to_js_result(reward)
     }
 
+    pub async fn query_notes_to_spend(
+        &self,
+        owner: String,
+        chain_id: String,
+    ) -> Result<JsValue, JsError> {
+        let xvk = ExtendedViewingKey::from_str(&owner)?;
+        let viewing_key = ExtendedFullViewingKey::from(xvk).fvk.vk;
+
+        let mut shielded: ShieldedContext<masp::JSShieldedUtils> = ShieldedContext::default();
+        shielded.utils.chain_id = chain_id.clone();
+        // TODO: pass handler
+        shielded.try_load(async |_| {}).await;
+
+        let res = shielded
+            .exchange_notes(
+                &self.namada,
+                &mut SpentNotesTracker::new(),
+                &viewing_key,
+                &mut Conversions::new(),
+            )
+            .await
+            .map_err(|e| JsError::new(&e.to_string()))?;
+
+        let values = res.values().collect::<Vec<_>>();
+
+        let mut final_res: HashMap<Address, Vec<(Amount, Option<Amount>)>> = HashMap::new();
+
+        for (_, _, _, value) in values.iter() {
+            let mut res: HashMap<Address, Amount> = HashMap::new();
+
+            for ((digit, address), val) in value.components() {
+                if res.contains_key(address) {
+                    let existing = res
+                        .get(address)
+                        .ok_or(JsError::new("Expected to find map entry"))?;
+                    let new_amount =
+                        existing
+                            .checked_add(Amount::from_masp_denominated_i128(*val, *digit).ok_or(
+                                JsError::new("Cannot create amount from masp denominated"),
+                            )?)
+                            .ok_or(JsError::new("Overflow when summing amounts"))?;
+
+                    res.insert(address.clone(), new_amount);
+                } else {
+                    res.insert(
+                        address.clone(),
+                        Amount::from_masp_denominated_i128(*val, *digit).unwrap(),
+                    );
+                }
+            }
+
+            let note = res
+                .get_index(0)
+                .ok_or(JsError::new("Expected to find at least one component"))?;
+            let conv = res.get_index(1);
+
+            let note_addr = note.0.clone();
+            if final_res.contains_key(&note_addr) {
+                let mut existing = final_res
+                    .get(&note_addr)
+                    .ok_or(JsError::new("Expected to find an entry"))?
+                    .clone();
+                existing.push((*note.1, None));
+
+                final_res.insert(note_addr, existing);
+            } else {
+                final_res.insert(note_addr, vec![(*note.1, None)]);
+            }
+
+            if let Some(conv) = conv {
+                let conv_addr = conv.0.clone();
+                if final_res.contains_key(&conv_addr) {
+                    let mut existing = final_res
+                        .get(&conv_addr)
+                        .ok_or(JsError::new("Expected to find an entry"))?
+                        .clone();
+                    existing.push((*note.1, Some(*conv.1)));
+
+                    final_res.insert(conv_addr, existing);
+                } else {
+                    final_res.insert(conv_addr, vec![(*note.1, Some(*conv.1))]);
+                }
+            }
+        }
+
+        to_js_result(final_res)
+    }
+
+
     pub fn masp_address(&self) -> String {
         MASP.to_string()
     }

packages/lib/src/index.ts

@@ -58,7 +58,7 @@ export {
   ProofGenerationKey,
   PseudoExtendedKey,
 } from "./masp";
-export type { Masp } from "./masp";
+export type { Masp, NotesAndConversions } from "./masp";
 export { PhraseSize } from "./mnemonic";
 export type { Mnemonic } from "./mnemonic";
 export type { Signing } from "./signing";

packages/lib/src/masp/masp.ts

@@ -1,4 +1,5 @@
 import { Sdk as SdkWasm } from "@namada/wasm";
+import { NotesAndConversions } from "./types";
 
 /**
  * Class representing utilities related to MASP
@@ -103,4 +104,19 @@ export class Masp {
   clearShieldedContext(chainId: string): Promise<void> {
     return SdkWasm.clear_shielded_context(chainId);
   }
+
+  /**
+   * Returns all the notes and conversions connected to the given viewing key
+   *
+   * @async
+   * @param viewingKey - Viewing key to get notes and conversions for
+   * @param chainId - Chain ID to load correct shielded context
+   * @returns Promise resolving to a map of addresses to arrays of notes and conversions tuple
+   */
+  async getNotesAndConversions(
+    viewingKey: string,
+    chainId: string,
+  ): Promise<NotesAndConversions> {
+    return await this.sdk.query_notes_to_spend(viewingKey, chainId);
+  }
 }

packages/lib/src/masp/types.ts

@@ -3,3 +3,9 @@ export {
   ProofGenerationKey,
   PseudoExtendedKey,
 } from "@namada/wasm";
+
+type Address = string;
+type NoteVal = string;
+type AmountVal = string;
+type NoteAndConv = [NoteVal, AmountVal?];
+export type NotesAndConversions = Record<Address, NoteAndConv[]>;