feat(sequencer)!: transaction categories on UnsignedTransaction

crates/astria-bridge-withdrawer/src/bridge_withdrawer/submitter/mod.rs

@@ -154,13 +154,14 @@ impl Submitter {
         .wrap_err("failed to get nonce from sequencer")?;
         debug!(nonce, "fetched latest nonce");
 
-        let unsigned = UnsignedTransaction {
+        let unsigned = UnsignedTransaction::new(
             actions,
-            params: TransactionParams::builder()
+            TransactionParams::builder()
                 .nonce(nonce)
                 .chain_id(sequencer_chain_id)
                 .build(),
-        };
+        )
+        .wrap_err("failed to build unsigned transaction")?;
 
         // sign transaction
         let signed = unsigned.into_signed(signer.signing_key());

crates/astria-cli/src/commands/bridge/submit.rs

@@ -129,13 +129,14 @@ async fn submit_transaction(
         .await
         .wrap_err("failed to get nonce")?;
 
-    let tx = UnsignedTransaction {
-        params: TransactionParams::builder()
+    let tx = UnsignedTransaction::new(
+        actions,
+        TransactionParams::builder()
             .nonce(nonce_res.nonce)
             .chain_id(chain_id)
             .build(),
-        actions,
-    }
+    )
+    .wrap_err("failed to build transaction from actions")?
     .into_signed(signing_key);
     let res = client
         .submit_transaction_sync(tx)

crates/astria-cli/src/commands/sequencer.rs

@@ -475,13 +475,14 @@ async fn submit_transaction(
         .await
         .wrap_err("failed to get nonce")?;
 
-    let tx = UnsignedTransaction {
-        params: TransactionParams::builder()
+    let tx = UnsignedTransaction::new(
+        vec![action],
+        TransactionParams::builder()
             .nonce(nonce_res.nonce)
             .chain_id(chain_id)
             .build(),
-        actions: vec![action],
-    }
+    )
+    .wrap_err("failed to build transaction from actions")?
     .into_signed(&sequencer_key);
     let res = sequencer_client
         .submit_transaction_sync(tx)

crates/astria-composer/src/executor/bundle_factory/mod.rs

@@ -13,6 +13,8 @@ use astria_core::{
     protocol::transaction::v1alpha1::{
         action::SequenceAction,
         Action,
+        TransactionParams,
+        UnsignedTransaction,
     },
     Protobuf as _,
 };
@@ -74,6 +76,12 @@ impl SizedBundle {
         }
     }
 
+    #[allow(clippy::panic)] // method is expected to never panic as an invariant of the type
+    /// Constructs an [`UnsignedTransaction`] from the actions contained in the bundle and `params`.
+    pub(super) fn to_unsigned_transaction(&self, params: TransactionParams) -> UnsignedTransaction {
+        UnsignedTransaction::new(self.buffer.clone(), params).unwrap()
+    }
+
     /// Buffer `seq_action` into the bundle.
     /// # Errors
     /// - `seq_action` is beyond the max size allowed for the entire bundle
@@ -112,6 +120,7 @@ impl SizedBundle {
     }
 
     /// Consume self and return the underlying buffer of actions.
+    #[cfg(test)]
     pub(super) fn into_actions(self) -> Vec<Action> {
         self.buffer
     }

crates/astria-composer/src/executor/bundle_factory/tests.rs

@@ -83,6 +83,8 @@ mod sized_bundle {
 
 #[cfg(test)]
 mod bundle_factory {
+    use astria_core::protocol::transaction::v1alpha1::TransactionParams;
+
     use super::*;
     use crate::{
         executor::bundle_factory::{
@@ -333,4 +335,27 @@ mod bundle_factory {
         assert_eq!(bundle_factory.finished.len(), 0);
         assert!(!bundle_factory.is_full());
     }
+
+    #[test]
+    fn unsigned_transaction_construction() {
+        let mut bundle_factory = BundleFactory::new(1000, 10);
+
+        bundle_factory
+            .try_push(sequence_action_with_n_bytes(50))
+            .unwrap();
+        bundle_factory
+            .try_push(sequence_action_with_n_bytes(50))
+            .unwrap();
+
+        let bundle = bundle_factory.pop_now();
+
+        let transaction_params = TransactionParams::builder()
+            .chain_id("astria-testnet-1".to_string())
+            .build();
+
+        // construction of multiple sequence actions should not panic
+        let unsigned_tx = bundle.to_unsigned_transaction(transaction_params);
+
+        assert_eq!(unsigned_tx.actions().len(), 2);
+    }
 }

crates/astria-composer/src/executor/mod.rs

@@ -18,7 +18,6 @@ use astria_core::{
             action::SequenceAction,
             SignedTransaction,
             TransactionParams,
-            UnsignedTransaction,
         },
     },
 };
@@ -681,11 +680,10 @@ impl Future for SubmitFut {
                         .nonce(*this.nonce)
                         .chain_id(&*this.chain_id)
                         .build();
-                    let tx = UnsignedTransaction {
-                        actions: this.bundle.clone().into_actions(),
-                        params,
-                    }
-                    .into_signed(this.signing_key);
+                    let tx = this
+                        .bundle
+                        .to_unsigned_transaction(params)
+                        .into_signed(this.signing_key);
                     info!(
                         nonce.actual = *this.nonce,
                         bundle = %telemetry::display::json(&SizedBundleReport(this.bundle)),
@@ -759,11 +757,10 @@ impl Future for SubmitFut {
                             .nonce(*this.nonce)
                             .chain_id(&*this.chain_id)
                             .build();
-                        let tx = UnsignedTransaction {
-                            actions: this.bundle.clone().into_actions(),
-                            params,
-                        }
-                        .into_signed(this.signing_key);
+                        let tx = this
+                            .bundle
+                            .to_unsigned_transaction(params)
+                            .into_signed(this.signing_key);
                         info!(
                             nonce.resubmission = *this.nonce,
                             bundle = %telemetry::display::json(&SizedBundleReport(this.bundle)),

crates/astria-core/src/protocol/test_utils.rs

@@ -104,16 +104,18 @@ impl ConfigureSequencerBlock {
         let txs = if actions.is_empty() {
             vec![]
         } else {
-            let unsigned_transaction = UnsignedTransaction {
+            let unsigned_transaction = UnsignedTransaction::new(
                 actions,
-                params: TransactionParams::builder()
+                TransactionParams::builder()
                     .nonce(1)
                     .chain_id(chain_id.clone())
                     .build(),
-            };
+            )
+            .expect(
+                "failed to build unsigned transaction, should be okay since only sequence actions",
+            );
             vec![unsigned_transaction.into_signed(&signing_key)]
         };
-
         let mut deposits_map: HashMap<RollupId, Vec<Deposit>> = HashMap::new();
         for deposit in deposits {
             if let Some(entry) = deposits_map.get_mut(&deposit.rollup_id) {

crates/astria-core/src/protocol/transaction/v1alpha1/action.rs

@@ -164,6 +164,14 @@ impl Action {
         };
         Some(transfer_action)
     }
+
+    pub fn is_fee_asset_change(&self) -> bool {
+        matches!(self, Self::FeeAssetChange(_))
+    }
+
+    pub fn is_fee_change(&self) -> bool {
+        matches!(self, Self::FeeChange(_))
+    }
 }
 
 impl From<SequenceAction> for Action {
@@ -252,6 +260,30 @@ impl TryFrom<raw::Action> for Action {
     }
 }
 
+pub(super) trait ActionName {
+    fn name(&self) -> &'static str;
+}
+
+impl ActionName for Action {
+    fn name(&self) -> &'static str {
+        match self {
+            Action::Sequence(_) => "Sequence",
+            Action::Transfer(_) => "Transfer",
+            Action::ValidatorUpdate(_) => "ValidatorUpdate",
+            Action::SudoAddressChange(_) => "SudoAddressChange",
+            Action::Ibc(_) => "Ibc",
+            Action::Ics20Withdrawal(_) => "Ics20Withdrawal",
+            Action::IbcRelayerChange(_) => "IbcRelayerChange",
+            Action::FeeAssetChange(_) => "FeeAssetChange",
+            Action::InitBridgeAccount(_) => "InitBridgeAccount",
+            Action::BridgeLock(_) => "BridgeLock",
+            Action::BridgeUnlock(_) => "BridgeUnlock",
+            Action::BridgeSudoChange(_) => "BridgeSudoChange",
+            Action::FeeChange(_) => "FeeChange",
+        }
+    }
+}
+
 #[allow(clippy::module_name_repetitions)]
 #[derive(Debug, thiserror::Error)]
 #[error(transparent)]