Tx batching

.changelog/unreleased/features/1356-tx-batch.md

@@ -0,0 +1,2 @@
+- Introduced transaction batches.
+  ([\#1356](https://github.com/anoma/namada/pull/1356))

crates/apps/src/lib/bench_utils.rs

@@ -72,8 +72,12 @@ use namada::ledger::queries::{
 };
 use namada::state::StorageRead;
 use namada::tx::data::pos::Bond;
-use namada::tx::data::{Fee, TxResult, VpsResult};
-use namada::tx::{Authorization, Code, Data, Section, Tx};
+use namada::tx::data::{
+    BatchResults, BatchedTxResult, Fee, TxResult, VpsResult,
+};
+use namada::tx::{
+    Authorization, BatchedTx, BatchedTxRef, Code, Data, Section, Tx,
+};
 use namada::vm::wasm::run;
 use namada::{proof_of_stake, tendermint};
 use namada_sdk::masp::{
@@ -237,7 +241,7 @@ impl Default for BenchShell {
             vec![&defaults::albert_keypair()],
         );
 
-        bench_shell.execute_tx(&signed_tx);
+        bench_shell.execute_tx(&signed_tx.to_ref());
         bench_shell.state.commit_tx();
 
         // Initialize governance proposal
@@ -262,7 +266,7 @@ impl Default for BenchShell {
             vec![&defaults::albert_keypair()],
         );
 
-        bench_shell.execute_tx(&signed_tx);
+        bench_shell.execute_tx(&signed_tx.to_ref());
         bench_shell.state.commit_tx();
         bench_shell.commit_block();
 
@@ -288,7 +292,7 @@ impl BenchShell {
         shielded: Option<Transaction>,
         extra_sections: Option<Vec<Section>>,
         signers: Vec<&SecretKey>,
-    ) -> Tx {
+    ) -> BatchedTx {
         let mut tx = Tx::from_type(namada::tx::data::TxType::Raw);
 
         // NOTE: here we use the code hash to avoid including the cost for the
@@ -324,10 +328,15 @@ impl BenchShell {
             )));
         }
 
-        tx
+        let cmt = tx.first_commitments().unwrap().clone();
+        tx.batch_tx(cmt)
     }
 
-    pub fn generate_ibc_tx(&self, wasm_code_path: &str, data: Vec<u8>) -> Tx {
+    pub fn generate_ibc_tx(
+        &self,
+        wasm_code_path: &str,
+        data: Vec<u8>,
+    ) -> BatchedTx {
         // This function avoid serializaing the tx data with Borsh
         let mut tx = Tx::from_type(namada::tx::data::TxType::Raw);
         let code_hash = self
@@ -340,10 +349,11 @@ impl BenchShell {
 
         tx.set_data(Data::new(data));
         // NOTE: the Ibc VP doesn't actually check the signature
-        tx
+        let cmt = tx.first_commitments().unwrap().clone();
+        tx.batch_tx(cmt)
     }
 
-    pub fn generate_ibc_transfer_tx(&self) -> Tx {
+    pub fn generate_ibc_transfer_tx(&self) -> BatchedTx {
         let token = PrefixedCoin {
             denom: address::testing::nam().to_string().parse().unwrap(),
             amount: Amount::native_whole(1000)
@@ -387,14 +397,18 @@ impl BenchShell {
     }
 
     /// Execute the tx and return a set of verifiers inserted by the tx.
-    pub fn execute_tx(&mut self, tx: &Tx) -> BTreeSet<Address> {
+    pub fn execute_tx(
+        &mut self,
+        batched_tx: &BatchedTxRef,
+    ) -> BTreeSet<Address> {
         let gas_meter =
             RefCell::new(TxGasMeter::new_from_sub_limit(u64::MAX.into()));
         run::tx(
             &mut self.inner.state,
             &gas_meter,
             &TxIndex(0),
-            tx,
+            batched_tx.tx,
+            batched_tx.cmt,
             &mut self.inner.vp_wasm_cache,
             &mut self.inner.tx_wasm_cache,
         )
@@ -601,7 +615,7 @@ impl BenchShell {
     }
 }
 
-pub fn generate_foreign_key_tx(signer: &SecretKey) -> Tx {
+pub fn generate_foreign_key_tx(signer: &SecretKey) -> BatchedTx {
     let wasm_code =
         std::fs::read("../../wasm_for_tests/tx_write.wasm").unwrap();
 
@@ -620,7 +634,8 @@ pub fn generate_foreign_key_tx(signer: &SecretKey) -> Tx {
         None,
     )));
 
-    tx
+    let cmt = tx.first_commitments().unwrap().clone();
+    tx.batch_tx(cmt)
 }
 
 pub struct BenchShieldedCtx {
@@ -882,27 +897,41 @@ impl Client for BenchShell {
                 self.last_block_masp_txs
                     .iter()
                     .enumerate()
-                    .map(|(idx, (_tx, changed_keys))| {
-                        let tx_result = TxResult {
+                    .map(|(idx, (tx, changed_keys))| {
+                        let tx_result = TxResult::<String> {
                             gas_used: 0.into(),
                             wrapper_changed_keys: Default::default(),
-                            changed_keys: changed_keys.to_owned(),
-                            vps_result: VpsResult::default(),
-                            initialized_accounts: vec![],
-                            ibc_events: BTreeSet::default(),
-                            eth_bridge_events: BTreeSet::default(),
+                            batch_results: BatchResults(
+                                [(
+                                    tx.first_commitments().unwrap().get_hash(),
+                                    Ok(BatchedTxResult {
+                                        changed_keys: changed_keys.to_owned(),
+                                        vps_result: VpsResult::default(),
+                                        initialized_accounts: vec![],
+                                        ibc_events: BTreeSet::default(),
+                                        eth_bridge_events: BTreeSet::default(),
+                                    }),
+                                )]
+                                .into_iter()
+                                .collect(),
+                            ),
                         };
                         namada::tendermint::abci::Event {
                             kind: "applied".to_string(),
                             // Mock the masp and tx attributes
                             attributes: vec![
                                 namada::tendermint::abci::EventAttribute {
-                                    key: "is_valid_masp_tx".to_string(),
+                                    key: format!(
+                                        "cmt/{}/is_valid_masp_tx",
+                                        tx.first_commitments()
+                                            .unwrap()
+                                            .get_hash()
+                                    ),
                                     value: format!("{}", idx),
                                     index: true,
                                 },
                                 namada::tendermint::abci::EventAttribute {
-                                    key: "inner_tx".to_string(),
+                                    key: "batch".to_string(),
                                     value: tx_result.to_string(),
                                     index: true,
                                 },
@@ -1015,7 +1044,7 @@ impl BenchShieldedCtx {
         amount: Amount,
         source: TransferSource,
         target: TransferTarget,
-    ) -> (Self, Tx) {
+    ) -> (Self, BatchedTx) {
         let denominated_amount = DenominatedAmount::native(amount);
         let async_runtime = tokio::runtime::Runtime::new().unwrap();
         let spending_key = self
@@ -1027,7 +1056,6 @@ impl BenchShieldedCtx {
                 self.shielded,
                 &self.shell,
                 &StdIo,
-                1,
                 None,
                 None,
                 &[spending_key.into()],
@@ -1112,7 +1140,7 @@ impl BenchShieldedCtx {
         amount: Amount,
         source: TransferSource,
         target: TransferTarget,
-    ) -> (Self, Tx) {
+    ) -> (Self, BatchedTx) {
         let (ctx, tx) = self.generate_masp_tx(
             amount,
             source.clone(),
@@ -1152,8 +1180,10 @@ impl BenchShieldedCtx {
         };
 
         let transfer =
-            Transfer::deserialize(&mut tx.data().unwrap().as_slice()).unwrap();
+            Transfer::deserialize(&mut tx.tx.data(&tx.cmt).unwrap().as_slice())
+                .unwrap();
         let masp_tx = tx
+            .tx
             .get_section(&transfer.shielded.unwrap())
             .unwrap()
             .masp_tx()
@@ -1166,7 +1196,7 @@ impl BenchShieldedCtx {
         let mut ibc_tx = ctx
             .shell
             .generate_ibc_tx(TX_IBC_WASM, msg.serialize_to_vec());
-        ibc_tx.add_masp_tx_section(masp_tx);
+        ibc_tx.tx.add_masp_tx_section(masp_tx);
 
         (ctx, ibc_tx)
     }

crates/apps/src/lib/cli/client.rs

@@ -327,7 +327,6 @@ impl CliApi {
                             chain_ctx.shielded,
                             &client,
                             &io,
-                            args.batch_size,
                             args.start_query_height,
                             args.last_query_height,
                             &sks,

crates/apps/src/lib/client/masp.rs

@@ -22,7 +22,6 @@ pub async fn syncing<
     mut shielded: ShieldedContext<U>,
     client: &C,
     io: &IO,
-    batch_size: u64,
     start_query_height: Option<BlockHeight>,
     last_query_height: Option<BlockHeight>,
     sks: &[ExtendedSpendingKey],
@@ -44,7 +43,6 @@ pub async fn syncing<
                 &logger,
                 start_query_height,
                 last_query_height,
-                batch_size,
                 sks,
                 fvks,
             )

crates/apps/src/lib/client/rpc.rs

@@ -48,7 +48,7 @@ use namada_sdk::rpc::{
     self, enriched_bonds_and_unbonds, query_epoch, TxResponse,
 };
 use namada_sdk::tendermint_rpc::endpoint::status;
-use namada_sdk::tx::display_inner_resp;
+use namada_sdk::tx::display_batch_resp;
 use namada_sdk::wallet::AddressVpType;
 use namada_sdk::{display, display_line, edisplay_line, error, prompt, Namada};
 use tokio::time::Instant;
@@ -2591,7 +2591,7 @@ pub async fn query_result(context: &impl Namada, args: args::QueryResult) {
     .await;
     match inner_resp {
         Ok(resp) => {
-            display_inner_resp(context, &resp);
+            display_batch_resp(context, &resp);
         }
         Err(err) => {
             // Print the errors that caused the lookups to fail

crates/apps/src/lib/client/tx.rs

@@ -299,8 +299,9 @@ where
     } else {
         sign(namada, &mut tx, &args.tx, signing_data).await?;
 
+        let cmt = tx.first_commitments().unwrap().to_owned();
         let response = namada.submit(tx, &args.tx).await?;
-        if let Some(result) = response.is_applied_and_valid() {
+        if let Some(result) = response.is_applied_and_valid(&cmt) {
             return Ok(result.initialized_accounts.first().cloned());
         }
     }
@@ -377,10 +378,11 @@ pub async fn submit_change_consensus_key(
         tx::dump_tx(namada.io(), &args.tx, tx);
     } else {
         sign(namada, &mut tx, &args.tx, signing_data).await?;
+        let cmt = tx.first_commitments().unwrap().to_owned();
         let resp = namada.submit(tx, &args.tx).await?;
 
         if !args.tx.dry_run {
-            if resp.is_applied_and_valid().is_some() {
+            if resp.is_applied_and_valid(&cmt).is_some() {
                 namada.wallet_mut().await.save().unwrap_or_else(|err| {
                     edisplay_line!(namada.io(), "{}", err)
                 });
@@ -570,6 +572,7 @@ pub async fn submit_become_validator(
         tx::dump_tx(namada.io(), &args.tx, tx);
     } else {
         sign(namada, &mut tx, &args.tx, signing_data).await?;
+        let cmt = tx.first_commitments().unwrap().to_owned();
         let resp = namada.submit(tx, &args.tx).await?;
 
         if args.tx.dry_run {
@@ -580,7 +583,7 @@ pub async fn submit_become_validator(
             safe_exit(0)
         }
 
-        if resp.is_applied_and_valid().is_none() {
+        if resp.is_applied_and_valid(&cmt).is_none() {
             display_line!(
                 namada.io(),
                 "Transaction failed. No key or addresses have been saved."
@@ -756,6 +759,7 @@ pub async fn submit_transfer(
             break;
         } else {
             sign(namada, &mut tx, &args.tx, signing_data).await?;
+            let cmt_hash = tx.first_commitments().unwrap().get_hash();
 
             let result = namada.submit(tx, &args.tx).await?;
 
@@ -764,7 +768,7 @@ pub async fn submit_transfer(
                     // If a transaction is shielded
                     tx_epoch.is_some() &&
                     // And it is rejected by a VP
-                    matches!(resp.inner_tx_result(), InnerTxResult::VpsRejected(_)) =>
+                    matches!(resp.batch_result().get(&cmt_hash), Some(InnerTxResult::VpsRejected(_))) =>
                 {
                     let submission_epoch = rpc::query_and_print_epoch(namada).await;
                     // And its submission epoch doesn't match construction epoch
@@ -1063,9 +1067,10 @@ where
         tx::dump_tx(namada.io(), &args.tx, tx);
     } else {
         sign(namada, &mut tx, &args.tx, signing_data).await?;
+        let cmt = tx.first_commitments().unwrap().to_owned();
         let resp = namada.submit(tx, &args.tx).await?;
 
-        if !args.tx.dry_run && resp.is_applied_and_valid().is_some() {
+        if !args.tx.dry_run && resp.is_applied_and_valid(&cmt).is_some() {
             tx::query_unbonds(namada, args.clone(), latest_withdrawal_pre)
                 .await?;
         }