Added new flow for shielding over ibc

Author: batconjurer

Cargo.lock

@@ -22,13 +22,15 @@ use namada_sdk::collections::HashMap;
 use namada_sdk::governance::cli::onchain::{
     DefaultProposal, PgfFundingProposal, PgfStewardProposal,
 };
-use namada_sdk::ibc::convert_masp_tx_to_ibc_memo;
 use namada_sdk::io::{Io, display_line, edisplay_line};
 use namada_sdk::key::*;
 use namada_sdk::rpc::{InnerTxResult, TxBroadcastData, TxResponse};
 use namada_sdk::state::EPOCH_SWITCH_BLOCKS_DELAY;
 use namada_sdk::tx::data::compute_inner_tx_hash;
-use namada_sdk::tx::{CompressedAuthorization, Section, Signer, Tx};
+use namada_sdk::tx::{
+    CompressedAuthorization, Section, Signer, Tx,
+    convert_masp_tx_to_ibc_memo_data,
+};
 use namada_sdk::wallet::alias::{validator_address, validator_consensus_key};
 use namada_sdk::wallet::{Wallet, WalletIo};
 use namada_sdk::{ExtendedViewingKey, Namada, error, signing, tx};
@@ -2024,10 +2026,14 @@ pub async fn gen_ibc_shielding_transfer(
         };
         let mut out = File::create(&output_path)
             .expect("Creating a new file for IBC MASP transaction failed.");
-        let bytes = convert_masp_tx_to_ibc_memo(
-            &masp_tx,
-            shielding_fee_payer,
-            shielding_fee_token,
+        let bytes = String::from(
+            convert_masp_tx_to_ibc_memo_data(
+                context,
+                &masp_tx,
+                shielding_fee_payer,
+                shielding_fee_token,
+            )
+            .await?,
         );
         out.write_all(bytes.as_bytes())
             .expect("Writing IBC MASP transaction file failed.");

crates/apps_lib/src/client/tx.rs

@@ -23,6 +23,7 @@ use sha2::Sha256;
 use crate::address::{Address, DecodeError, HASH_HEX_LEN, IBC, MASP};
 use crate::borsh::BorshSerializeExt;
 use crate::chain::Epoch;
+use crate::hash::Hash;
 use crate::impl_display_and_from_str_via_format;
 use crate::string_encoding::{
     self, MASP_EXT_FULL_VIEWING_KEY_HRP, MASP_EXT_SPENDING_KEY_HRP,
@@ -79,6 +80,18 @@ impl From<TxIdInner> for MaspTxId {
     }
 }
 
+impl From<Hash> for MaspTxId {
+    fn from(hash: Hash) -> Self {
+        MaspTxId(TxIdInner::from_bytes(hash.0))
+    }
+}
+
+impl From<MaspTxId> for Hash {
+    fn from(tx_id: MaspTxId) -> Self {
+        Hash(*tx_id.0.as_ref())
+    }
+}
+
 impl Display for MaspTxId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.0)

crates/core/src/masp.rs

@@ -83,7 +83,6 @@ use ibc::core::router::types::error::RouterError;
 use ibc::primitives::proto::Any;
 pub use ibc::*;
 use ibc_middleware_packet_forward::PacketMetadata;
-use masp_primitives::transaction::Transaction as MaspTransaction;
 pub use msg::*;
 use namada_core::address::{self, Address};
 use namada_core::arith::{CheckedAdd, CheckedSub, checked};
@@ -101,6 +100,7 @@ use namada_state::{
     State, StorageHasher, StorageRead, StorageWrite, WlState,
 };
 use namada_systems::ibc::ChangedBalances;
+pub use namada_systems::ibc::IbcShieldingData;
 use namada_systems::trans_token;
 pub use nft::*;
 use prost::Message;
@@ -239,7 +239,7 @@ where
 {
     fn try_extract_masp_tx_from_envelope<Transfer: BorshDeserialize>(
         tx_data: &[u8],
-    ) -> StorageResult<Option<masp_primitives::transaction::Transaction>> {
+    ) -> StorageResult<Option<IbcShieldingData>> {
         let msg = decode_message::<Transfer>(tx_data)
             .into_storage_result()
             .ok();
@@ -578,7 +578,7 @@ pub struct InternalData<Transfer> {
     /// The transparent transfer that happens in parallel to IBC processes
     pub transparent: Option<Transfer>,
     /// The shielded transaction that happens in parallel to IBC processes
-    pub shielded: Option<MaspTransaction>,
+    pub shielded: Option<IbcShieldingData>,
     /// IBC tokens that are credited/debited to internal accounts
     pub ibc_tokens: BTreeSet<Address>,
 }

crates/ibc/src/lib.rs

@@ -1,10 +1,7 @@
 use std::collections::BTreeMap;
-use std::fmt;
-use std::str::FromStr;
 
 use borsh::schema::{Declaration, Definition, Fields};
 use borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
-use data_encoding::HEXUPPER;
 use ibc::apps::nft_transfer::types::PORT_ID_STR as NFT_PORT_ID_STR;
 use ibc::apps::nft_transfer::types::msgs::transfer::MsgTransfer as IbcMsgNftTransfer;
 use ibc::apps::nft_transfer::types::packet::PacketData as NftPacketData;
@@ -18,13 +15,9 @@ use ibc::core::channel::types::packet::Packet;
 use ibc::core::handler::types::msgs::MsgEnvelope;
 use ibc::core::host::types::identifiers::PortId;
 use ibc::primitives::proto::Protobuf;
-use masp_primitives::transaction::Transaction as MaspTransaction;
-use namada_core::address::Address;
-use namada_core::borsh::BorshSerializeExt;
-use namada_core::key::common::PublicKey;
-use namada_core::string_encoding::StringEncoded;
 use serde::{Deserialize, Serialize};
-
+use namada_core::string_encoding::StringEncoded;
+use namada_systems::ibc::IbcShieldingData;
 use crate::trace;
 
 trait Sealed {}
@@ -238,50 +231,11 @@ impl<Transfer: BorshSchema> BorshSchema for MsgNftTransfer<Transfer> {
     }
 }
 
-/// Shielding data in IBC packet memo
-#[derive(Debug, Clone, BorshDeserialize, BorshSerialize)]
-pub struct IbcShieldingData {
-    /// The MASP transaction that does the shielding
-    pub masp_tx: MaspTransaction,
-    /// The account that will pay the shielding fee
-    pub shielding_fee_payer: PublicKey,
-    /// The token that the shielding fee will be paid in
-    pub shielding_fee_token: Address,
-}
-
-impl From<&IbcShieldingData> for String {
-    fn from(data: &IbcShieldingData) -> Self {
-        HEXUPPER.encode(&data.serialize_to_vec())
-    }
-}
-
-impl From<IbcShieldingData> for String {
-    fn from(data: IbcShieldingData) -> Self {
-        (&data).into()
-    }
-}
-
-impl fmt::Display for IbcShieldingData {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", String::from(self))
-    }
-}
-
-impl FromStr for IbcShieldingData {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let bytes = HEXUPPER
-            .decode(s.as_bytes())
-            .map_err(|err| err.to_string())?;
-        IbcShieldingData::try_from_slice(&bytes).map_err(|err| err.to_string())
-    }
-}
 
 /// Extract MASP transaction from IBC envelope
 pub fn extract_masp_tx_from_envelope(
     envelope: &MsgEnvelope,
-) -> Option<MaspTransaction> {
+) -> Option<IbcShieldingData> {
     match envelope {
         MsgEnvelope::Packet(PacketMsg::Recv(msg)) => {
             extract_masp_tx_from_packet(&msg.packet)
@@ -308,9 +262,11 @@ pub fn decode_ibc_shielding_data(
 }
 
 /// Extract MASP transaction from IBC packet memo
-pub fn extract_masp_tx_from_packet(packet: &Packet) -> Option<MaspTransaction> {
+pub fn extract_masp_tx_from_packet(
+    packet: &Packet,
+) -> Option<IbcShieldingData> {
     let memo = extract_memo_from_packet(packet, &packet.port_id_on_b)?;
-    decode_ibc_shielding_data(memo).map(|data| data.masp_tx)
+    decode_ibc_shielding_data(memo)
 }
 
 fn extract_memo_from_packet(
@@ -373,17 +329,3 @@ pub fn extract_traces_from_recv_msg(
         _ => Ok(vec![]),
     }
 }
-
-/// Get IBC memo string from MASP transaction for receiving
-pub fn convert_masp_tx_to_ibc_memo(
-    transaction: &MaspTransaction,
-    shielding_fee_payer: PublicKey,
-    shielding_fee_token: Address,
-) -> String {
-    IbcShieldingData {
-        masp_tx: transaction.clone(),
-        shielding_fee_payer,
-        shielding_fee_token,
-    }
-    .into()
-}

crates/ibc/src/msg.rs

@@ -40,6 +40,7 @@ use crate::rpc::{
     query_ibc_denom, query_osmosis_pool_routes,
 };
 use crate::signing::{SigningTxData, gen_disposable_signing_key};
+use crate::tx::convert_masp_tx_to_ibc_memo_data;
 use crate::wallet::{DatedSpendingKey, DatedViewingKey};
 use crate::{Namada, rpc, tx};
 
@@ -745,19 +746,17 @@ impl TxOsmosisSwap<SdkTypes> {
                         "Failed to generate IBC shielding transfer".to_owned(),
                     )
                 })?;
-
+                let ibc_memo_data = convert_masp_tx_to_ibc_memo_data(
+                    ctx,
+                    &shielding_tx,
+                    shielded_recipient.shielding_fee_payer,
+                    shielded_recipient.shielding_fee_token,
+                )
+                .await?;
                 let memo = assert_json_obj(
                     serde_json::to_value(&NamadaMemo {
                         namada: NamadaMemoData::OsmosisSwap {
-                            shielding_data: StringEncoded::new(
-                                IbcShieldingData {
-                                    masp_tx: shielding_tx,
-                                    shielding_fee_payer: shielded_recipient
-                                        .shielding_fee_payer,
-                                    shielding_fee_token: shielded_recipient
-                                        .shielding_fee_token,
-                                },
-                            ),
+                            shielding_data: StringEncoded::new(ibc_memo_data),
                             shielded_amount: amount_to_shield,
                             overflow_receiver,
                         },

crates/sdk/src/args.rs

@@ -81,7 +81,7 @@ fn extract_masp_tx(
 
             if let Some(transaction) = extract_masp_tx_from_envelope(&envelope)
             {
-                Ok(transaction)
+                Ok(transaction.masp_tx)
             } else {
                 Err(Error::Other(
                     "Failed to retrieve MASP over IBC transaction".to_string(),

crates/sdk/src/masp.rs

@@ -92,7 +92,7 @@ use crate::signing::{
 use crate::tendermint_rpc::endpoint::broadcast::tx_sync::Response;
 use crate::tendermint_rpc::error::Error as RpcError;
 use crate::wallet::WalletIo;
-use crate::{Namada, args, events};
+use crate::{Namada, args, error, events};
 
 /// Initialize account transaction WASM
 pub const TX_INIT_ACCOUNT_WASM: &str = "tx_init_account.wasm";
@@ -2747,9 +2747,12 @@ pub async fn build_ibc_transfer(
         Some(source.clone()),
         Some(source.clone()),
         vec![],
-        args.ibc_shielding_data
-            .as_ref()
-            .map(|shielding_data| shielding_data.shielding_fee_payer.clone()),
+        args.ibc_shielding_data.as_ref().map(|shielding_data| {
+            shielding_data
+                .get_signer()
+                .cloned()
+                .expect("A MASP fee payer should have been provided")
+        }),
         args.source.spending_key().is_some(),
         vec![],
         None,
@@ -2767,17 +2770,15 @@ pub async fn build_ibc_transfer(
             // check that if there is a shielding fee payer, they have enough
             // balance to cover the fee
 
-            let shielding_fee_payer = if let Some(IbcShieldingData {
-                shielding_fee_payer: payer,
-                shielding_fee_token,
-                ..
-            }) = &args.ibc_shielding_data
+            let shielding_fee_payer = if let Some(data) =
+                &args.ibc_shielding_data
             {
                 validate_shielding_fee(
                     context,
                     Some(&mut updated_balance),
-                    payer,
-                    shielding_fee_token,
+                    data.get_signer()
+                        .expect("A MASP fee payer should have been provided"),
+                    &data.shielding_fee_token,
                     args.tx.force,
                 )
                 .await?
@@ -2920,16 +2921,14 @@ pub async fn build_ibc_transfer(
     if let Some(memo) = &args.tx.memo {
         tx.add_memo(memo);
     }
-    if let Some(IbcShieldingData {
-        shielding_fee_payer: payer,
-        shielding_fee_token: token,
-        masp_tx,
-    }) = &args.ibc_shielding_data
-    {
+    if let Some(data) = &args.ibc_shielding_data {
         tx.add_section(Section::ShieldingFee {
-            payer: payer.clone(),
-            token: token.clone(),
-            cmt: MaspTxId::from(masp_tx.txid()),
+            payer: data
+                .get_signer()
+                .cloned()
+                .expect("A MASP fee payer should have been provided"),
+            token: data.shielding_fee_token.clone(),
+            cmt: MaspTxId::from(data.masp_tx.txid()),
         });
     }
 
@@ -4634,3 +4633,34 @@ fn proposal_to_vec(proposal: OnChainProposal) -> Result<Vec<u8>> {
     borsh::to_vec(&proposal.content)
         .map_err(|e| Error::from(EncodingError::Conversion(e.to_string())))
 }
+
+/// Get IBC memo string from MASP transaction for receiving
+pub async fn convert_masp_tx_to_ibc_memo_data(
+    context: &impl Namada,
+    transaction: &MaspTransaction,
+    shielding_fee_payer: common::PublicKey,
+    shielding_fee_token: Address,
+) -> std::result::Result<IbcShieldingData, error::Error> {
+    let mut wallet = context.wallet_lock().write().await;
+    let secret_key = wallet
+        .find_key_by_pk(&shielding_fee_payer, None)
+        .map_err(|err| {
+            Error::Other(format!(
+                "Unable to load the keypair from the wallet for public key \
+                 {}. Failed with: {}",
+                shielding_fee_payer, err
+            ))
+        })?;
+
+    let target = MaspTxId::from(transaction.txid());
+    let authorization = Authorization::new(
+        vec![target.into()],
+        BTreeMap::from([(0, secret_key)]),
+        None,
+    );
+    Ok(IbcShieldingData {
+        masp_tx: transaction.clone(),
+        shielding_fee_authorization: authorization,
+        shielding_fee_token,
+    })
+}

crates/sdk/src/tx.rs

@@ -78,4 +78,4 @@ impl Default for ShieldedParams {
             locked_amount_target: 10_000_u64,
         }
     }
-}
+}