VP update using actions enum written by txs to a temp storage

crates/benches/native_vps.rs

@@ -1157,12 +1157,16 @@ fn ibc_vp_validate_action(c: &mut Criterion) {
                 shell.vp_wasm_cache.clone(),
             ),
         };
+        // Use an empty verifiers set placeholder for validation, this is only
+        // needed in actual txs to addresses whose VPs should be triggered
+        let verifiers = Rc::new(RefCell::new(BTreeSet::<Address>::new()));
+
         let exec_ctx = PseudoExecutionContext::new(ibc.ctx.pre());
         let ctx = Rc::new(RefCell::new(exec_ctx));
-        let mut actions = IbcActions::new(ctx.clone());
+        let mut actions = IbcActions::new(ctx.clone(), verifiers.clone());
         actions.set_validation_params(ibc.validation_params().unwrap());
 
-        let module = TransferModule::new(ctx);
+        let module = TransferModule::new(ctx, verifiers);
         actions.add_transfer_module(module.module_id(), module);
 
         group.bench_function(bench_name, |b| {
@@ -1255,12 +1259,17 @@ fn ibc_vp_execute_action(c: &mut Criterion) {
                 shell.vp_wasm_cache.clone(),
             ),
         };
+        // Use an empty verifiers set placeholder for validation, this is only
+        // needed in actual txs to addresses whose VPs should be triggered
+        let verifiers = Rc::new(RefCell::new(BTreeSet::<Address>::new()));
+
         let exec_ctx = PseudoExecutionContext::new(ibc.ctx.pre());
         let ctx = Rc::new(RefCell::new(exec_ctx));
-        let mut actions = IbcActions::new(ctx.clone());
+
+        let mut actions = IbcActions::new(ctx.clone(), verifiers.clone());
         actions.set_validation_params(ibc.validation_params().unwrap());
 
-        let module = TransferModule::new(ctx);
+        let module = TransferModule::new(ctx, verifiers);
         actions.add_transfer_module(module.module_id(), module);
 
         group.bench_function(bench_name, |b| {

crates/core/src/address.rs

@@ -66,6 +66,10 @@ pub const MASP: Address = Address::Internal(InternalAddress::Masp);
 pub const MULTITOKEN: Address = Address::Internal(InternalAddress::Multitoken);
 /// Internal Eth bridge address
 pub const ETH_BRIDGE: Address = Address::Internal(InternalAddress::EthBridge);
+/// Address with temporary storage is used to pass data from txs to VPs which is
+/// never committed to DB
+pub const TEMP_STORAGE: Address =
+    Address::Internal(InternalAddress::TempStorage);
 
 /// Error from decoding address from string
 pub type DecodeError = string_encoding::DecodeError;
@@ -135,6 +139,9 @@ impl From<raw::Address<'_, raw::Validated>> for Address {
                 InternalAddress::IbcToken(IbcTokenHash(*raw_addr.data())),
             ),
             raw::Discriminant::Masp => Address::Internal(InternalAddress::Masp),
+            raw::Discriminant::TempStorage => {
+                Address::Internal(InternalAddress::TempStorage)
+            }
         }
     }
 }
@@ -229,6 +236,11 @@ impl<'addr> From<&'addr Address> for raw::Address<'addr, raw::Validated> {
                     .validate()
                     .expect("This raw address is valid")
             }
+            Address::Internal(InternalAddress::TempStorage) => {
+                raw::Address::from_discriminant(raw::Discriminant::TempStorage)
+                    .validate()
+                    .expect("This raw address is valid")
+            }
         }
     }
 }
@@ -303,6 +315,11 @@ impl Address {
     pub fn is_implicit(&self) -> bool {
         matches!(self, Address::Implicit(_))
     }
+
+    /// If the address internal?
+    pub fn is_internal(&self) -> bool {
+        matches!(self, Address::Internal(_))
+    }
 }
 
 impl string_encoding::Format for Address {
@@ -557,6 +574,9 @@ pub enum InternalAddress {
     Pgf,
     /// Masp
     Masp,
+    /// Address with temporary storage is used to pass data from txs to VPs
+    /// which is never committed to DB
+    TempStorage,
 }
 
 impl Display for InternalAddress {
@@ -578,6 +598,7 @@ impl Display for InternalAddress {
                 Self::Multitoken => "Multitoken".to_string(),
                 Self::Pgf => "PublicGoodFundings".to_string(),
                 Self::Masp => "MASP".to_string(),
+                Self::TempStorage => "TempStorage".to_string(),
             }
         )
     }
@@ -802,8 +823,9 @@ pub mod testing {
             InternalAddress::Nut(_) => {}
             InternalAddress::Pgf => {}
             InternalAddress::Masp => {}
-            InternalAddress::Multitoken => {} /* Add new addresses in the
-                                               * `prop_oneof` below. */
+            InternalAddress::Multitoken => {}
+            InternalAddress::TempStorage => {} /* Add new addresses in the
+                                                * `prop_oneof` below. */
         };
         prop_oneof![
             Just(InternalAddress::PoS),
@@ -819,6 +841,7 @@ pub mod testing {
             Just(InternalAddress::Multitoken),
             Just(InternalAddress::Pgf),
             Just(InternalAddress::Masp),
+            Just(InternalAddress::TempStorage),
         ]
     }
 

crates/core/src/address/raw.rs

@@ -65,6 +65,8 @@ pub enum Discriminant {
     IbcToken = 13,
     /// MASP raw address.
     Masp = 14,
+    /// Temporary storage address.
+    TempStorage = 15,
 }
 
 /// Raw address representation.

crates/ibc/src/actions.rs

@@ -1,6 +1,7 @@
 //! Implementation of `IbcActions` with the protocol storage
 
 use std::cell::RefCell;
+use std::collections::BTreeSet;
 use std::rc::Rc;
 
 use namada_core::address::{Address, InternalAddress};
@@ -306,6 +307,9 @@ where
     prost::Message::encode(&any_msg, &mut data).into_storage_result()?;
 
     let ctx = IbcProtocolContext { state };
-    let mut actions = IbcActions::new(Rc::new(RefCell::new(ctx)));
+    // Use an empty verifiers set placeholder for validation, this is only
+    // needed in txs and not protocol
+    let verifiers = Rc::new(RefCell::new(BTreeSet::<Address>::new()));
+    let mut actions = IbcActions::new(Rc::new(RefCell::new(ctx)), verifiers);
     actions.execute(&data).into_storage_result()
 }

crates/ibc/src/context/token_transfer.rs

@@ -1,6 +1,7 @@
 //! IBC token transfer context
 
 use std::cell::RefCell;
+use std::collections::BTreeSet;
 use std::rc::Rc;
 
 use namada_core::address::{Address, InternalAddress};
@@ -26,15 +27,24 @@ where
     C: IbcCommonContext,
 {
     inner: Rc<RefCell<C>>,
+    verifiers: Rc<RefCell<BTreeSet<Address>>>,
 }
 
 impl<C> TokenTransferContext<C>
 where
     C: IbcCommonContext,
 {
     /// Make new token transfer context
-    pub fn new(inner: Rc<RefCell<C>>) -> Self {
-        Self { inner }
+    pub fn new(
+        inner: Rc<RefCell<C>>,
+        verifiers: Rc<RefCell<BTreeSet<Address>>>,
+    ) -> Self {
+        Self { inner, verifiers }
+    }
+
+    /// Insert a verifier address whose VP will verify the tx.
+    fn insert_verifier(&mut self, addr: &Address) {
+        self.verifiers.borrow_mut().insert(addr.clone());
     }
 
     /// Get the token address and the amount from PrefixedCoin. If the base
@@ -143,6 +153,13 @@ where
         // has no prefix
         let (ibc_token, amount) = self.get_token_amount(coin)?;
 
+        // A transfer of NUT tokens must be verified by their VP
+        if ibc_token.is_internal()
+            && matches!(ibc_token, Address::Internal(InternalAddress::Nut(_)))
+        {
+            self.insert_verifier(&ibc_token);
+        }
+
         self.inner
             .borrow_mut()
             .transfer_token(from, to, &ibc_token, amount)
@@ -157,6 +174,13 @@ where
         // The trace path of the denom is already updated if receiving the token
         let (ibc_token, amount) = self.get_token_amount(coin)?;
 
+        // A transfer of NUT tokens must be verified by their VP
+        if ibc_token.is_internal()
+            && matches!(ibc_token, Address::Internal(InternalAddress::Nut(_)))
+        {
+            self.insert_verifier(&ibc_token);
+        }
+
         self.inner
             .borrow_mut()
             .mint_token(account, &ibc_token, amount)
@@ -170,6 +194,13 @@ where
     ) -> Result<(), TokenTransferError> {
         let (ibc_token, amount) = self.get_token_amount(coin)?;
 
+        // A transfer of NUT tokens must be verified by their VP
+        if ibc_token.is_internal()
+            && matches!(ibc_token, Address::Internal(InternalAddress::Nut(_)))
+        {
+            self.insert_verifier(&ibc_token);
+        }
+
         // The burn is "unminting" from the minted balance
         self.inner
             .borrow_mut()

crates/ibc/src/context/transfer_mod.rs

@@ -1,9 +1,11 @@
 //! IBC module for token transfer
 
 use std::cell::RefCell;
+use std::collections::BTreeSet;
 use std::fmt::Debug;
 use std::rc::Rc;
 
+use namada_core::address::Address;
 use namada_core::ibc::apps::transfer::module::{
     on_acknowledgement_packet_execute, on_acknowledgement_packet_validate,
     on_chan_close_confirm_execute, on_chan_close_confirm_validate,
@@ -58,9 +60,12 @@ where
     C: IbcCommonContext,
 {
     /// Make a new module
-    pub fn new(ctx: Rc<RefCell<C>>) -> Self {
+    pub fn new(
+        ctx: Rc<RefCell<C>>,
+        verifiers: Rc<RefCell<BTreeSet<Address>>>,
+    ) -> Self {
         Self {
-            ctx: TokenTransferContext::new(ctx),
+            ctx: TokenTransferContext::new(ctx, verifiers),
         }
     }
 

crates/ibc/src/lib.rs

@@ -5,6 +5,7 @@ pub mod context;
 pub mod storage;
 
 use std::cell::RefCell;
+use std::collections::BTreeSet;
 use std::fmt::Debug;
 use std::rc::Rc;
 use std::str::FromStr;
@@ -68,17 +69,22 @@ where
 {
     ctx: IbcContext<C>,
     router: IbcRouter<'a>,
+    verifiers: Rc<RefCell<BTreeSet<Address>>>,
 }
 
 impl<'a, C> IbcActions<'a, C>
 where
     C: IbcCommonContext + Debug,
 {
     /// Make new IBC actions
-    pub fn new(ctx: Rc<RefCell<C>>) -> Self {
+    pub fn new(
+        ctx: Rc<RefCell<C>>,
+        verifiers: Rc<RefCell<BTreeSet<Address>>>,
+    ) -> Self {
         Self {
             ctx: IbcContext::new(ctx),
             router: IbcRouter::new(),
+            verifiers,
         }
     }
 
@@ -101,8 +107,10 @@ where
         let message = decode_message(tx_data)?;
         match &message {
             IbcMessage::Transfer(msg) => {
-                let mut token_transfer_ctx =
-                    TokenTransferContext::new(self.ctx.inner.clone());
+                let mut token_transfer_ctx = TokenTransferContext::new(
+                    self.ctx.inner.clone(),
+                    self.verifiers.clone(),
+                );
                 send_transfer_execute(
                     &mut self.ctx,
                     &mut token_transfer_ctx,
@@ -111,8 +119,10 @@ where
                 .map_err(Error::TokenTransfer)
             }
             IbcMessage::ShieldedTransfer(msg) => {
-                let mut token_transfer_ctx =
-                    TokenTransferContext::new(self.ctx.inner.clone());
+                let mut token_transfer_ctx = TokenTransferContext::new(
+                    self.ctx.inner.clone(),
+                    self.verifiers.clone(),
+                );
                 send_transfer_execute(
                     &mut self.ctx,
                     &mut token_transfer_ctx,
@@ -226,17 +236,25 @@ where
 
     /// Validate according to the message in IBC VP
     pub fn validate(&self, tx_data: &[u8]) -> Result<(), Error> {
+        // Use an empty verifiers set placeholder for validation, this is only
+        // needed in actual txs to addresses whose VPs should be triggered
+        let verifiers = Rc::new(RefCell::new(BTreeSet::<Address>::new()));
+
         let message = decode_message(tx_data)?;
         match message {
             IbcMessage::Transfer(msg) => {
-                let token_transfer_ctx =
-                    TokenTransferContext::new(self.ctx.inner.clone());
+                let token_transfer_ctx = TokenTransferContext::new(
+                    self.ctx.inner.clone(),
+                    verifiers.clone(),
+                );
                 send_transfer_validate(&self.ctx, &token_transfer_ctx, msg)
                     .map_err(Error::TokenTransfer)
             }
             IbcMessage::ShieldedTransfer(msg) => {
-                let token_transfer_ctx =
-                    TokenTransferContext::new(self.ctx.inner.clone());
+                let token_transfer_ctx = TokenTransferContext::new(
+                    self.ctx.inner.clone(),
+                    verifiers.clone(),
+                );
                 send_transfer_validate(
                     &self.ctx,
                     &token_transfer_ctx,