Early sapling balance check

.changelog/unreleased/features/3356-vectorize-transfers.md

@@ -0,0 +1,2 @@
+- Reworked transparent and masp transfers to allow for multiple sources, targets,
+  tokens and amounts. ([\#3356](https://github.com/anoma/namada/pull/3356))

.changelog/unreleased/features/3393-masp-fee-payment.md

@@ -0,0 +1,2 @@
+- Added support for fee payment directly from the MASP pool.
+  ([\#3393](https://github.com/anoma/namada/pull/3393))

.changelog/unreleased/improvements/2721-early-sapling-balance-check.md

@@ -0,0 +1,2 @@
+- Moved up the check on the sapling value balance in the masp vp.
+  ([\#2721](https://github.com/anoma/namada/issues/2721))

crates/apps_lib/src/cli.rs

@@ -3221,6 +3221,8 @@ pub mod args {
         "gas-limit",
         DefaultFn(|| GasLimit::from(DEFAULT_GAS_LIMIT)),
     );
+    pub const GAS_SPENDING_KEY: ArgOpt<WalletSpendingKey> =
+        arg_opt("gas-spending-key");
     pub const FEE_TOKEN: ArgDefaultFromCtx<WalletAddrOrNativeToken> =
         arg_default_from_ctx("gas-token", DefaultFn(|| "".parse().unwrap()));
     pub const FEE_PAYER: Arg<WalletAddress> = arg("fee-payer");
@@ -4338,14 +4340,21 @@ pub mod args {
             ctx: &mut Context,
         ) -> Result<TxTransparentTransfer<SdkTypes>, Self::Error> {
             let tx = self.tx.to_sdk(ctx)?;
+            let mut data = vec![];
             let chain_ctx = ctx.borrow_mut_chain_or_exit();
 
+            for transfer_data in self.data {
+                data.push(TxTransparentTransferData {
+                    source: chain_ctx.get(&transfer_data.source),
+                    target: chain_ctx.get(&transfer_data.target),
+                    token: chain_ctx.get(&transfer_data.token),
+                    amount: transfer_data.amount,
+                });
+            }
+
             Ok(TxTransparentTransfer::<SdkTypes> {
                 tx,
-                source: chain_ctx.get(&self.source),
-                target: chain_ctx.get(&self.target),
-                token: chain_ctx.get(&self.token),
-                amount: self.amount,
+                data,
                 tx_code_path: self.tx_code_path.to_path_buf(),
             })
         }
@@ -4359,12 +4368,16 @@ pub mod args {
             let token = TOKEN.parse(matches);
             let amount = InputAmount::Unvalidated(AMOUNT.parse(matches));
             let tx_code_path = PathBuf::from(TX_TRANSPARENT_TRANSFER_WASM);
-            Self {
-                tx,
+            let data = vec![TxTransparentTransferData {
                 source,
                 target,
                 token,
                 amount,
+            }];
+
+            Self {
+                tx,
+                data,
                 tx_code_path,
             }
         }
@@ -4393,14 +4406,28 @@ pub mod args {
             ctx: &mut Context,
         ) -> Result<TxShieldedTransfer<SdkTypes>, Self::Error> {
             let tx = self.tx.to_sdk(ctx)?;
+            let mut data = vec![];
             let chain_ctx = ctx.borrow_mut_chain_or_exit();
 
+            for transfer_data in self.data {
+                data.push(TxShieldedTransferData {
+                    source: chain_ctx.get_cached(&transfer_data.source),
+                    target: chain_ctx.get(&transfer_data.target),
+                    token: chain_ctx.get(&transfer_data.token),
+                    amount: transfer_data.amount,
+                });
+            }
+
+            let gas_spending_keys = self
+                .gas_spending_keys
+                .iter()
+                .map(|key| chain_ctx.get_cached(key))
+                .collect();
+
             Ok(TxShieldedTransfer::<SdkTypes> {
                 tx,
-                source: chain_ctx.get_cached(&self.source),
-                target: chain_ctx.get(&self.target),
-                token: chain_ctx.get(&self.token),
-                amount: self.amount,
+                data,
+                gas_spending_keys,
                 tx_code_path: self.tx_code_path.to_path_buf(),
             })
         }
@@ -4414,12 +4441,21 @@ pub mod args {
             let token = TOKEN.parse(matches);
             let amount = InputAmount::Unvalidated(AMOUNT.parse(matches));
             let tx_code_path = PathBuf::from(TX_SHIELDED_TRANSFER_WASM);
-            Self {
-                tx,
+            let data = vec![TxShieldedTransferData {
                 source,
                 target,
                 token,
                 amount,
+            }];
+            let mut gas_spending_keys = vec![];
+            if let Some(key) = GAS_SPENDING_KEY.parse(matches) {
+                gas_spending_keys.push(key);
+            }
+
+            Self {
+                tx,
+                data,
+                gas_spending_keys,
                 tx_code_path,
             }
         }
@@ -4442,6 +4478,10 @@ pub mod args {
                         .def()
                         .help(wrap!("The amount to transfer in decimal.")),
                 )
+                .arg(GAS_SPENDING_KEY.def().help(wrap!(
+                    "The optional spending key that will be used in addition \
+                     to the source for gas payment."
+                )))
         }
     }
 
@@ -4453,14 +4493,21 @@ pub mod args {
             ctx: &mut Context,
         ) -> Result<TxShieldingTransfer<SdkTypes>, Self::Error> {
             let tx = self.tx.to_sdk(ctx)?;
+            let mut data = vec![];
             let chain_ctx = ctx.borrow_mut_chain_or_exit();
 
+            for transfer_data in self.data {
+                data.push(TxShieldingTransferData {
+                    source: chain_ctx.get(&transfer_data.source),
+                    token: chain_ctx.get(&transfer_data.token),
+                    amount: transfer_data.amount,
+                });
+            }
+
             Ok(TxShieldingTransfer::<SdkTypes> {
                 tx,
-                source: chain_ctx.get(&self.source),
+                data,
                 target: chain_ctx.get(&self.target),
-                token: chain_ctx.get(&self.token),
-                amount: self.amount,
                 tx_code_path: self.tx_code_path.to_path_buf(),
             })
         }
@@ -4474,12 +4521,16 @@ pub mod args {
             let token = TOKEN.parse(matches);
             let amount = InputAmount::Unvalidated(AMOUNT.parse(matches));
             let tx_code_path = PathBuf::from(TX_SHIELDING_TRANSFER_WASM);
-            Self {
-                tx,
+            let data = vec![TxShieldingTransferData {
                 source,
-                target,
                 token,
                 amount,
+            }];
+
+            Self {
+                tx,
+                data,
+                target,
                 tx_code_path,
             }
         }
@@ -4514,14 +4565,27 @@ pub mod args {
             ctx: &mut Context,
         ) -> Result<TxUnshieldingTransfer<SdkTypes>, Self::Error> {
             let tx = self.tx.to_sdk(ctx)?;
+            let mut data = vec![];
             let chain_ctx = ctx.borrow_mut_chain_or_exit();
 
+            for transfer_data in self.data {
+                data.push(TxUnshieldingTransferData {
+                    target: chain_ctx.get(&transfer_data.target),
+                    token: chain_ctx.get(&transfer_data.token),
+                    amount: transfer_data.amount,
+                });
+            }
+            let gas_spending_keys = self
+                .gas_spending_keys
+                .iter()
+                .map(|key| chain_ctx.get_cached(key))
+                .collect();
+
             Ok(TxUnshieldingTransfer::<SdkTypes> {
                 tx,
+                data,
+                gas_spending_keys,
                 source: chain_ctx.get_cached(&self.source),
-                target: chain_ctx.get(&self.target),
-                token: chain_ctx.get(&self.token),
-                amount: self.amount,
                 tx_code_path: self.tx_code_path.to_path_buf(),
             })
         }
@@ -4535,12 +4599,21 @@ pub mod args {
             let token = TOKEN.parse(matches);
             let amount = InputAmount::Unvalidated(AMOUNT.parse(matches));
             let tx_code_path = PathBuf::from(TX_UNSHIELDING_TRANSFER_WASM);
-            Self {
-                tx,
-                source,
+            let data = vec![TxUnshieldingTransferData {
                 target,
                 token,
                 amount,
+            }];
+            let mut gas_spending_keys = vec![];
+            if let Some(key) = GAS_SPENDING_KEY.parse(matches) {
+                gas_spending_keys.push(key);
+            }
+
+            Self {
+                tx,
+                source,
+                data,
+                gas_spending_keys,
                 tx_code_path,
             }
         }
@@ -4563,6 +4636,10 @@ pub mod args {
                         .def()
                         .help(wrap!("The amount to transfer in decimal.")),
                 )
+                .arg(GAS_SPENDING_KEY.def().help(wrap!(
+                    "The optional spending key that will be used in addition \
+                     to the source for gas payment."
+                )))
         }
     }
 
@@ -4575,6 +4652,11 @@ pub mod args {
         ) -> Result<TxIbcTransfer<SdkTypes>, Self::Error> {
             let tx = self.tx.to_sdk(ctx)?;
             let chain_ctx = ctx.borrow_mut_chain_or_exit();
+            let gas_spending_keys = self
+                .gas_spending_keys
+                .iter()
+                .map(|key| chain_ctx.get_cached(key))
+                .collect();
 
             Ok(TxIbcTransfer::<SdkTypes> {
                 tx,
@@ -4588,6 +4670,7 @@ pub mod args {
                 timeout_sec_offset: self.timeout_sec_offset,
                 refund_target: chain_ctx.get_opt(&self.refund_target),
                 memo: self.memo,
+                gas_spending_keys,
                 tx_code_path: self.tx_code_path.to_path_buf(),
             })
         }
@@ -4609,6 +4692,10 @@ pub mod args {
                 std::fs::read_to_string(path)
                     .expect("Expected a file at given path")
             });
+            let mut gas_spending_keys = vec![];
+            if let Some(key) = GAS_SPENDING_KEY.parse(matches) {
+                gas_spending_keys.push(key);
+            }
             let tx_code_path = PathBuf::from(TX_IBC_WASM);
             Self {
                 tx,
@@ -4622,6 +4709,7 @@ pub mod args {
                 timeout_sec_offset,
                 refund_target,
                 memo,
+                gas_spending_keys,
                 tx_code_path,
             }
         }
@@ -4658,6 +4746,11 @@ pub mod args {
                 .arg(IBC_TRANSFER_MEMO_PATH.def().help(wrap!(
                     "The path for the memo field of ICS20 transfer."
                 )))
+                .arg(GAS_SPENDING_KEY.def().help(wrap!(
+                    "The optional spending key that will be used in addition \
+                     to the source for gas payment (if this is a shielded \
+                     action)."
+                )))
         }
     }
 

crates/apps_lib/src/client/rpc.rs

@@ -660,16 +660,16 @@ pub async fn query_protocol_parameters(
         .expect("Parameter should be defined.");
     display_line!(context.io(), "{:4}Max block gas: {:?}", "", max_block_gas);
 
-    let key = param_storage::get_fee_unshielding_gas_limit_key();
-    let fee_unshielding_gas_limit: u64 =
+    let key = param_storage::get_masp_fee_payment_gas_limit_key();
+    let masp_fee_payment_gas_limit: u64 =
         query_storage_value(context.client(), &key)
             .await
             .expect("Parameter should be defined.");
     display_line!(
         context.io(),
-        "{:4}Fee unshielding gas limit: {:?}",
+        "{:4}Masp fee payment gas limit: {:?}",
         "",
-        fee_unshielding_gas_limit
+        masp_fee_payment_gas_limit
     );
 
     let key = param_storage::get_gas_cost_key();

crates/apps_lib/src/client/tx.rs

@@ -743,7 +743,26 @@ pub async fn submit_transparent_transfer(
     namada: &impl Namada,
     args: args::TxTransparentTransfer,
 ) -> Result<(), error::Error> {
-    submit_reveal_aux(namada, args.tx.clone(), &args.source).await?;
+    if args.data.len() > 1 {
+        // TODO(namada#3379): Vectorized transfers are not yet supported in the
+        // CLI
+        return Err(error::Error::Other(
+            "Unexpected vectorized transparent transfer".to_string(),
+        ));
+    }
+
+    submit_reveal_aux(
+        namada,
+        args.tx.clone(),
+        &args
+            .data
+            .first()
+            .ok_or_else(|| {
+                error::Error::Other("Missing transfer data".to_string())
+            })?
+            .source,
+    )
+    .await?;
 
     let (mut tx, signing_data) = args.clone().build(namada).await?;
 

crates/apps_lib/src/config/genesis.rs

@@ -313,8 +313,8 @@ pub struct Parameters {
     pub masp_epoch_multiplier: u64,
     /// Maximum amount of signatures per transaction
     pub max_signatures_per_transaction: u8,
-    /// Fee unshielding gas limit
-    pub fee_unshielding_gas_limit: u64,
+    /// The gas limit for a masp transaction paying fees
+    pub masp_fee_payment_gas_limit: u64,
     /// Map of the cost per gas unit for every token allowed for fee payment
     pub minimum_gas_price: BTreeMap<Address, token::Amount>,
 }

crates/apps_lib/src/config/genesis/chain.rs

@@ -304,7 +304,7 @@ impl Finalized {
             epochs_per_year,
             masp_epoch_multiplier,
             max_signatures_per_transaction,
-            fee_unshielding_gas_limit,
+            masp_fee_payment_gas_limit,
             max_block_gas,
             minimum_gas_price,
             max_tx_bytes,
@@ -350,7 +350,7 @@ impl Finalized {
             masp_epoch_multiplier,
             max_proposal_bytes,
             max_signatures_per_transaction,
-            fee_unshielding_gas_limit,
+            masp_fee_payment_gas_limit,
             max_block_gas,
             minimum_gas_price: minimum_gas_price
                 .iter()