WIP fetches masp txs from blocks

apps/src/lib/client/rpc.rs

@@ -44,7 +44,9 @@ use namada::types::ibc::{is_ibc_denom, IbcTokenHash};
 use namada::types::io::Io;
 use namada::types::key::*;
 use namada::types::masp::{BalanceOwner, ExtendedViewingKey, PaymentAddress};
-use namada::types::storage::{BlockHeight, BlockResults, Epoch, Key, KeySeg};
+use namada::types::storage::{
+    BlockHeight, BlockResults, Epoch, IndexedTx, Key, KeySeg,
+};
 use namada::types::token::{Change, MaspDenom};
 use namada::types::{storage, token};
 use namada_sdk::error::{is_pinned_error, Error, PinnedBalanceError};
@@ -145,7 +147,9 @@ pub async fn query_transfers(
         .map(|fvk| (ExtendedFullViewingKey::from(*fvk).fvk.vk, fvk))
         .collect();
     // Now display historical shielded and transparent transactions
-    for ((height, idx), (epoch, tfer_delta, tx_delta)) in transfers {
+    for (IndexedTx { height, index: idx }, (epoch, tfer_delta, tx_delta)) in
+        transfers
+    {
         // Check if this transfer pertains to the supplied owner
         let mut relevant = match &query_owner {
             Either::Left(BalanceOwner::FullViewingKey(fvk)) => tx_delta

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

@@ -470,6 +470,16 @@ where
                                     let mut event = Event::from(ibc_event);
                                     // Add the height for IBC event query
                                     event["height"] = height.to_string();
+                                    if tx_event
+                                        .attributes
+                                        .contains_key("is_valid_masp_tx")
+                                    {
+                                        // Add the tx index for masp txs clients
+                                        // queries
+                                        // FIXME: review this
+                                        event["is_valid_masp_tx"] =
+                                            tx_index.to_string();
+                                    }
                                     event
                                 })
                                 // eth bridge events

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

@@ -287,6 +287,7 @@ where
             &mut shell.vp_wasm_cache,
             &mut shell.tx_wasm_cache,
             None,
+            &mut false,
         );
         shell
             .wl_storage

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

@@ -761,10 +761,12 @@ impl<'a> Client for &'a MockNode {
         height: H,
     ) -> Result<tendermint_rpc::endpoint::block_results::Response, RpcError>
     where
-        H: Into<namada::tendermint::block::Height> + Send,
+        H: TryInto<namada::tendermint::block::Height> + Send,
     {
         self.drive_mock_services_bg().await;
-        let height = height.into();
+        let height = height.try_into().map_err(|_| {
+            RpcError::parse("Could not parse block height".to_string())
+        })?;
         let encoded_event = EncodedEvent(height.value());
         let locked = self.shell.lock().unwrap();
         let events: Vec<_> = locked

core/src/ledger/ibc/context/storage.rs

@@ -28,9 +28,11 @@ pub trait IbcStorageContext: StorageRead + StorageWrite {
     ) -> Result<(), Error>;
 
     /// Handle masp tx
+    // FIXME: try again to remove tx_index from some places
     fn handle_masp_tx(
         &mut self,
         shielded: &masp_primitives::transaction::Transaction,
+        pin_key: Option<&str>,
     ) -> Result<(), Error>;
 
     /// Mint token

core/src/ledger/ibc/mod.rs

@@ -102,6 +102,7 @@ where
     pub fn execute(&mut self, tx_data: &[u8]) -> Result<(), Error> {
         let message = decode_message(tx_data)?;
         match &message {
+            // FIXME: look here for MASP on IBC
             IbcMessage::Transfer(msg) => {
                 let mut token_transfer_ctx =
                     TokenTransferContext::new(self.ctx.inner.clone());
@@ -282,7 +283,10 @@ where
             self.ctx
                 .inner
                 .borrow_mut()
-                .handle_masp_tx(&shielded_transfer.masp_tx)
+                .handle_masp_tx(
+                    &shielded_transfer.masp_tx,
+                    shielded_transfer.transfer.key.as_deref(),
+                )
                 .map_err(|_| {
                     Error::MaspTx("Writing MASP components failed".to_string())
                 })?;

core/src/ledger/masp_utils.rs

@@ -6,7 +6,11 @@ use masp_primitives::transaction::Transaction;
 
 use super::storage_api::{StorageRead, StorageWrite};
 use crate::ledger::storage_api::{Error, Result};
-use crate::types::token::{masp_commitment_tree_key, masp_nullifier_key};
+use crate::types::address::MASP;
+use crate::types::storage::{IndexedTx, Key, KeySeg};
+use crate::types::token::{
+    masp_commitment_tree_key, masp_nullifier_key, PIN_KEY_PREFIX,
+};
 
 // Writes the nullifiers of the provided masp transaction to storage
 fn reveal_nullifiers(
@@ -59,12 +63,27 @@ pub fn update_note_commitment_tree(
 pub fn handle_masp_tx(
     ctx: &mut (impl StorageRead + StorageWrite),
     shielded: &Transaction,
+    pin_key: Option<&str>,
 ) -> Result<()> {
     // TODO: temporarily disabled because of the node aggregation issue in WASM.
     // Using the host env tx_update_masp_note_commitment_tree or directly the
     // update_note_commitment_tree function as a  workaround instead
     // update_note_commitment_tree(ctx, shielded)?;
     reveal_nullifiers(ctx, shielded)?;
 
+    // If storage key has been supplied, then pin this transaction to it
+    if let Some(key) = pin_key {
+        let pin_key = Key::from(MASP.to_db_key())
+            .push(&(PIN_KEY_PREFIX.to_owned() + key))
+            .expect("Cannot obtain a storage key");
+        ctx.write(
+            &pin_key,
+            IndexedTx {
+                height: ctx.get_block_height()?,
+                index: ctx.get_tx_index()?,
+            },
+        )?;
+    }
+
     Ok(())
 }

core/src/ledger/vp_env.rs

@@ -110,6 +110,7 @@ where
 
     /// Get the shielded action including the transfer and the masp tx
     fn get_shielded_action(
+        // FIXME: I need this
         &self,
         tx_data: &Tx,
     ) -> Result<(Transfer, Transaction), storage_api::Error> {

core/src/types/ibc.rs

@@ -239,6 +239,8 @@ pub fn get_shielded_transfer(
         return Ok(None);
     }
 
+    // FIXME: I should place the is_masp_tx attribute directly on the ibc event
+    // not in finalize block FIXME: maybe it's not possible
     event
         .attributes
         .get("memo")

core/src/types/storage.rs

@@ -1433,6 +1433,27 @@ impl<E> GetEventNonce for InnerEthEventsQueue<E> {
     }
 }
 
+/// Represents the pointers of an indexed tx, which are the block height and the
+/// index inside that block
+#[derive(
+    Default,
+    Debug,
+    Copy,
+    Clone,
+    BorshSerialize,
+    BorshDeserialize,
+    Eq,
+    PartialEq,
+    Ord,
+    PartialOrd,
+)]
+pub struct IndexedTx {
+    /// The block height of the indexed tx
+    pub height: BlockHeight,
+    /// The index in the block of the tx
+    pub index: TxIndex,
+}
+
 #[cfg(test)]
 /// Tests and strategies for storage
 pub mod tests {

core/src/types/token.rs

@@ -978,6 +978,8 @@ pub const DENOM_STORAGE_KEY: &str = "denomination";
 pub const MINTER_STORAGE_KEY: &str = "minter";
 /// Key segment for minted balance
 pub const MINTED_STORAGE_KEY: &str = "minted";
+/// Key segment prefix for pinned shielded transactions
+pub const PIN_KEY_PREFIX: &str = "pin-";
 /// Key segment prefix for the nullifiers
 pub const MASP_NULLIFIERS_KEY: &str = "nullifiers";
 /// Key segment prefix for the note commitment merkle tree
@@ -1217,7 +1219,10 @@ pub fn is_masp_key(key: &Key) -> bool {
 pub fn is_masp_allowed_key(key: &Key) -> bool {
     match &key.segments[..] {
         [DbKeySeg::AddressSeg(addr), DbKeySeg::StringSeg(key)]
-            if *addr == MASP && key == MASP_NOTE_COMMITMENT_TREE_KEY =>
+            if *addr == MASP
+            //FIXME: place the check back in the masp vp if needed
+                && (key.starts_with(PIN_KEY_PREFIX)
+                    || key == MASP_NOTE_COMMITMENT_TREE_KEY) =>
         {
             true
         }
@@ -1258,6 +1263,13 @@ pub fn masp_last_inflation_key(token_address: &Address) -> Key {
     )
 }
 
+/// Get a key for a masp pin
+pub fn masp_pin_tx_key(key: &str) -> Key {
+    Key::from(MASP.to_db_key())
+        .push(&(PIN_KEY_PREFIX.to_owned() + key))
+        .expect("Cannot obtain a storage key")
+}
+
 /// Get a key for a masp nullifier
 pub fn masp_nullifier_key(nullifier: &Nullifier) -> Key {
     Key::from(MASP.to_db_key())