Add sign and submit subcommands to sequencer CLI (#1696)

## Summary

> [!NOTE]  
> Most of the code is copied from Sam
(#1695) and Jordan's
(#1694) PRs.

Add two new subcommands `sign` and `submit` to the `sequencer`
subcommand.

### `sign`
1. Reads a pbjson formatted
`astria.protocol.transaction.v1.TransactionBody` from a file or `STDIN`
(`file` is a positional argument; `STDIN` is read when providing `-` as
the trailing argument).
2. Signs it with a given private key (`--private-key`).
3. Writes the pbjson formatted
`astria.protocol.transaction.v1.Transaction` to `--output`/`-o`, if
provided, or `STDOUT`.

### `submit`
1. 1. Reads a pbjson formatted
`astria.protocol.transaction.v1.Transaction` from a file or `STDIN`
(`file` is a positional argument; `STDIN` is read when providing `-` as
the trailing argument).
2. Submits it to a sequencer's CometBFT url (`--sequencer-url`)

## Background

We want to be able to test the submitting txs signed via FROST threshold
signing (see #1654) but do not
have a CLI command to submit already signed transactions. The `submit`
command resolves this.

To test the `submit` command it is desirable to have a corresponding
`sign` command which creates a signed `Transaction` from a single
private key.

## Changes
- List changes which were made.

## Testing
1. Run a local sequencer network using `astria-cli-go`
```
just run dev purge all
just run dev init
just run dev run --network local
```
2. Sign a `TransactionBody`:
```
cargo run -p astria-cli -- sequencer sign --private-key 2bd806c97f0e00af1a1fc3328fa763a9269723c8db8fac4f93af71db186d6e90 - <<EOF
{
  "params": {
    "nonce": 0,
    "chainId": "sequencer-test-chain-0"
  },
  "actions": [
    {
      "ibcRelayerChange": {
        "removal": {
          "bech32m": "astria13r24h8mj42sdfqflqyg2fycqf9mdqqzmm2xllj"
        }
      }
    }
  ]
}
EOF
```
3. Submit the signed `Transaction`
```
cargo run -p astria-cli -- sequencer submit --sequencer-url http://127.0.0.1:26657 - <<EOF
{
  "signature": "+hb4bd8kEM8/AQ3wJ2znXcF3Ds1iLZu6OieNOnxY7n1SZsiDr5NQP3lMK4s5134O629XjXhae/FsL+qtbXnBDw==",
  "publicKey": "1b9KP8znF7A4i8wnSevBSK2ZabI/Re4bYF/Vh3hXasQ=",
  "body": {
    "typeUrl": "/astria.protocol.transaction.v1.TransactionBody",
    "value": "ChgSFnNlcXVlbmNlci10ZXN0LWNoYWluLTASNKIDMRIvEi1hc3RyaWExM3IyNGg4bWo0MnNkZnFmbHF5ZzJmeWNxZjltZHFxem1tMnhsbGo="
  }
}
EOF 
```

> [!NOTE]  
> You can also do this is in a single command using `xargs -0`

```
cargo run -p astria-cli -- sequencer sign --private-key 2bd806c97f0e00af1a1fc3328fa763a9269723c8db8fac4f93af71db186d6e90 - <<EOF
{
  "params": {
    "nonce": 3,
    "chainId": "sequencer-test-chain-0"
  },
  "actions": [
    {
      "ibcRelayerChange": {
        "removal": {
          "bech32m": "astria13r24h8mj42sdfqflqyg2fycqf9mdqqzmm2xllj"
        }
      }
    }
  ]
}
EOF | xargs -0 cargo run -p astria-cli -- sequencer submit  --sequencer-url http://127.0.0.1:26657
```

## Metrics
- List out metrics added by PR, delete section if none. 

## Breaking Changelist
- Bulleted list of breaking changes, any notes on migration. Delete
section if none.

## Related Issues
Link any issues that are related, prefer full github links.

closes <!-- list any issues closed here -->

---------

Co-authored-by: Sam Bukowski <[email protected]>
Co-authored-by: Richard Janis Goldschmidt <[email protected]>
Co-authored-by: Fraser Hutchison <[email protected]>
Co-authored-by: Jordan Oroshiba <[email protected]>

Author: 5 people

Cargo.lock

@@ -15,6 +15,7 @@ use astria_core::{
         memos,
         transaction::v1::Action,
     },
+    Protobuf as _,
 };
 use astria_eyre::eyre::{
     self,

crates/astria-bridge-withdrawer/src/bridge_withdrawer/startup.rs

@@ -3,6 +3,7 @@ use std::time::Duration;
 use astria_core::{
     primitive::v1::asset,
     protocol::bridge::v1::BridgeAccountLastTxHashResponse,
+    Protobuf as _,
 };
 use prost::Message as _;
 use sequencer_client::{

crates/astria-bridge-withdrawer/tests/blackbox/helpers/mock_cometbft.rs

@@ -8,8 +8,12 @@ readme = "README.md"
 repository = "https://github.com/astriaorg/astria"
 homepage = "https://astria.org"
 
+[[bin]]
+name = "astria-cli"
+
 [dependencies]
 color-eyre = "0.6"
+clap-stdin = "0.5.1"
 # v2.0.0-rc.0 - can be updated once https://github.com/ZcashFoundation/frost/issues/755 is closed
 frost-ed25519 = { version = "2.0.0-rc.0", features = [] }
 serde_yaml = "0.9.25"

crates/astria-cli/Cargo.toml

@@ -8,6 +8,8 @@ mod block_height;
 mod bridge_lock;
 mod ics20_withdrawal;
 mod init_bridge_account;
+mod sign;
+mod submit;
 mod sudo;
 mod threshold;
 mod transfer;
@@ -31,6 +33,8 @@ impl Command {
             SubCommand::Transfer(transfer) => transfer.run().await,
             SubCommand::Threshold(threshold) => threshold.run().await,
             SubCommand::Ics20Withdrawal(ics20_withdrawal) => ics20_withdrawal.run().await,
+            SubCommand::Submit(submit) => submit.run().await,
+            SubCommand::Sign(sign) => sign.run(),
         }
     }
 }
@@ -59,4 +63,13 @@ enum SubCommand {
     Threshold(threshold::Command),
     /// Command for withdrawing an ICS20 asset
     Ics20Withdrawal(ics20_withdrawal::Command),
+    /// Submit the signed pbjson formatted Transaction.
+    Submit(submit::Command),
+    /// Sign a pbjson formatted TransactionBody to produce a Transaction.
+    #[expect(
+        clippy::doc_markdown,
+        reason = "doc comments are turned into CLI help strings which currently don't use \
+                  backticks"
+    )]
+    Sign(sign::Command),
 }

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

@@ -0,0 +1,99 @@
+use std::{
+    io::Write,
+    path::{
+        Path,
+        PathBuf,
+    },
+};
+
+use astria_core::{
+    protocol::transaction::v1::TransactionBody,
+    Protobuf,
+};
+use clap_stdin::FileOrStdin;
+use color_eyre::eyre::{
+    self,
+    WrapErr as _,
+};
+
+use crate::utils::signing_key_from_private_key;
+
+#[derive(clap::Args, Debug)]
+pub(super) struct Command {
+    /// The private key of account being sent from
+    #[arg(long, env = "SEQUENCER_PRIVATE_KEY")]
+    // TODO: https://github.com/astriaorg/astria/issues/594
+    // Don't use a plain text private, prefer wrapper like from
+    // the secrecy crate with specialized `Debug` and `Drop` implementations
+    // that overwrite the key on drop and don't reveal it when printing.
+    private_key: String,
+    /// Target to write the signed transaction in pbjson format (omit to write to STDOUT).
+    #[arg(long, short)]
+    output: Option<PathBuf>,
+    /// Forces an overwrite of `--output` if a file at that location exists.
+    #[arg(long, short)]
+    force: bool,
+    /// The source to read the pbjson formatted astra.protocol.transaction.v1.Transaction (use `-`
+    /// to pass via STDIN).
+    input: FileOrStdin,
+}
+
+// The goal of the `sign` CLI command is to take in a `TransactionBody` and to sign with a private
+// key to create a `Transaction`. This signed `Transaction` should be printed to the console in
+// pbjson format.
+impl Command {
+    pub(super) fn run(self) -> eyre::Result<()> {
+        let key = signing_key_from_private_key(self.private_key.as_str())?;
+
+        let filename = self.input.filename().to_string();
+        let transaction_body = read_transaction_body(self.input)
+            .wrap_err_with(|| format!("failed to read transaction body from `{filename}`"))?;
+        let transaction = transaction_body.sign(&key);
+
+        serde_json::to_writer(
+            stdout_or_file(self.output.as_ref(), self.force)
+                .wrap_err("failed to determine output target")?,
+            &transaction.to_raw(),
+        )
+        .wrap_err("failed to write signed transaction")?;
+        Ok(())
+    }
+}
+
+fn read_transaction_body(input: FileOrStdin) -> eyre::Result<TransactionBody> {
+    let wire_body: <TransactionBody as Protobuf>::Raw = serde_json::from_reader(
+        std::io::BufReader::new(input.into_reader()?),
+    )
+    .wrap_err_with(|| {
+        format!(
+            "failed to parse input as json `{}`",
+            TransactionBody::full_name()
+        )
+    })?;
+    TransactionBody::try_from_raw(wire_body).wrap_err("failed to validate transaction body")
+}
+
+fn stdout_or_file<P: AsRef<Path>>(
+    output: Option<P>,
+    force_overwrite: bool,
+) -> eyre::Result<Box<dyn Write>> {
+    let writer = match output {
+        Some(path) => {
+            let file = if force_overwrite {
+                std::fs::File::options()
+                    .write(true)
+                    .truncate(true)
+                    .open(path)
+            } else {
+                std::fs::File::options()
+                    .create_new(true)
+                    .write(true)
+                    .open(path)
+            }
+            .wrap_err("failed to open file for writing")?;
+            Box::new(file) as Box<dyn Write>
+        }
+        None => Box::new(std::io::stdout()),
+    };
+    Ok(writer)
+}

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

@@ -0,0 +1,73 @@
+use astria_core::{
+    self,
+    protocol::transaction::v1::Transaction,
+    Protobuf,
+};
+use astria_sequencer_client::{
+    HttpClient,
+    SequencerClientExt as _,
+};
+use clap_stdin::FileOrStdin;
+use color_eyre::eyre::{
+    self,
+    ensure,
+    WrapErr as _,
+};
+
+#[derive(clap::Args, Debug)]
+pub(super) struct Command {
+    /// The URL at which the Sequencer node is listening for ABCI commands.
+    #[arg(
+        long,
+        env = "SEQUENCER_URL",
+        default_value = crate::DEFAULT_SEQUENCER_RPC
+    )]
+    sequencer_url: String,
+    /// The source to read the pbjson formatted astra.protocol.transaction.v1.Transaction (use `-`
+    /// to pass via STDIN).
+    input: FileOrStdin,
+}
+
+// The 'submit' command takes a 'Transaction' in pbjson form and submits it to the sequencer
+impl Command {
+    pub(super) async fn run(self) -> eyre::Result<()> {
+        let sequencer_client = HttpClient::new(self.sequencer_url.as_str())
+            .wrap_err("failed constructing http sequencer client")?;
+
+        let filename = self.input.filename().to_string();
+        let transaction = read_transaction(self.input)
+            .wrap_err_with(|| format!("to signed transaction from `{filename}`"))?;
+
+        let res = sequencer_client
+            .submit_transaction_sync(transaction)
+            .await
+            .wrap_err("failed to submit transaction")?;
+
+        ensure!(res.code.is_ok(), "failed to check tx: {}", res.log);
+
+        let tx_response = sequencer_client.wait_for_tx_inclusion(res.hash).await;
+
+        ensure!(
+            tx_response.tx_result.code.is_ok(),
+            "failed to execute tx: {}",
+            tx_response.tx_result.log
+        );
+
+        println!("Submission completed!");
+        println!("Included in block: {}", tx_response.height);
+        Ok(())
+    }
+}
+
+fn read_transaction(input: FileOrStdin) -> eyre::Result<Transaction> {
+    let wire_body: <Transaction as Protobuf>::Raw = serde_json::from_reader(
+        std::io::BufReader::new(input.into_reader()?),
+    )
+    .wrap_err_with(|| {
+        format!(
+            "failed to parse input as json `{}`",
+            Transaction::full_name()
+        )
+    })?;
+    Transaction::try_from_raw(wire_body).wrap_err("failed to validate transaction body")
+}

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

@@ -26,6 +26,7 @@ use astria_core::{
             Transaction,
         },
     },
+    Protobuf as _,
 };
 use astria_eyre::eyre::{
     self,

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

@@ -26,6 +26,7 @@ use astria_core::{
         abci::AbciErrorCode,
         transaction::v1::Transaction,
     },
+    Protobuf as _,
 };
 use astria_eyre::eyre;
 use ethers::prelude::Transaction as EthersTransaction;

crates/astria-composer/tests/blackbox/helper/mod.rs

@@ -20,6 +20,7 @@ use crate::{
         block::Deposit,
         SequencerBlock,
     },
+    Protobuf as _,
 };
 
 #[derive(Default)]

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

@@ -16,7 +16,7 @@ use crate::{
         TransactionId,
         ADDRESS_LEN,
     },
-    Protobuf as _,
+    Protobuf,
 };
 
 pub mod action;
@@ -81,34 +81,69 @@ pub struct Transaction {
     body_bytes: bytes::Bytes,
 }
 
-impl Transaction {
-    pub fn address_bytes(&self) -> &[u8; ADDRESS_LEN] {
-        self.verification_key.address_bytes()
+impl Protobuf for Transaction {
+    type Error = TransactionError;
+    type Raw = raw::Transaction;
+
+    fn try_from_raw_ref(raw: &Self::Raw) -> Result<Self, Self::Error> {
+        let Self::Raw {
+            signature,
+            public_key,
+            body,
+        } = raw;
+        let signature = Signature::try_from(&**signature).map_err(TransactionError::signature)?;
+        let verification_key =
+            VerificationKey::try_from(&**public_key).map_err(TransactionError::verification_key)?;
+        let Some(body) = body else {
+            return Err(TransactionError::unset_body());
+        };
+        let bytes = body.value.clone();
+        verification_key
+            .verify(&signature, &bytes)
+            .map_err(TransactionError::verification)?;
+        let transaction =
+            TransactionBody::try_from_any(body.clone()).map_err(TransactionError::body)?;
+        Ok(Self {
+            signature,
+            verification_key,
+            body: transaction,
+            body_bytes: bytes,
+        })
     }
 
-    /// Returns the transaction ID, containing the transaction hash.
-    ///
-    /// The transaction hash is calculated by protobuf-encoding the transaction
-    /// and hashing the resulting bytes with sha256.
-    #[must_use]
-    pub fn id(&self) -> TransactionId {
-        use sha2::{
-            Digest as _,
-            Sha256,
+    fn try_from_raw(raw: Self::Raw) -> Result<Self, TransactionError> {
+        let Self::Raw {
+            signature,
+            public_key,
+            body,
+        } = raw;
+        let signature = Signature::try_from(&*signature).map_err(TransactionError::signature)?;
+        let verification_key =
+            VerificationKey::try_from(&*public_key).map_err(TransactionError::verification_key)?;
+        let Some(body) = body else {
+            return Err(TransactionError::unset_body());
         };
-        let bytes = self.to_raw().encode_to_vec();
-        TransactionId::new(Sha256::digest(bytes).into())
+        let bytes = body.value.clone();
+        verification_key
+            .verify(&signature, &bytes)
+            .map_err(TransactionError::verification)?;
+        let transaction = TransactionBody::try_from_any(body).map_err(TransactionError::body)?;
+        Ok(Self {
+            signature,
+            verification_key,
+            body: transaction,
+            body_bytes: bytes,
+        })
     }
 
-    #[must_use]
-    pub fn into_raw(self) -> raw::Transaction {
+    fn into_raw(self) -> raw::Transaction {
         let Self {
             signature,
             verification_key,
             body_bytes: transaction_bytes,
             ..
         } = self;
-        raw::Transaction {
+        Self::Raw {
             signature: Bytes::copy_from_slice(&signature.to_bytes()),
             public_key: Bytes::copy_from_slice(&verification_key.to_bytes()),
             body: Some(pbjson_types::Any {
@@ -118,15 +153,14 @@ impl Transaction {
         }
     }
 
-    #[must_use]
-    pub fn to_raw(&self) -> raw::Transaction {
+    fn to_raw(&self) -> raw::Transaction {
         let Self {
             signature,
             verification_key,
             body_bytes: transaction_bytes,
             ..
         } = self;
-        raw::Transaction {
+        Self::Raw {
             signature: Bytes::copy_from_slice(&signature.to_bytes()),
             public_key: Bytes::copy_from_slice(&verification_key.to_bytes()),
             body: Some(pbjson_types::Any {
@@ -135,39 +169,25 @@ impl Transaction {
             }),
         }
     }
+}
 
-    /// Attempt to convert from a raw, unchecked protobuf [`raw::Transaction`].
-    ///
-    /// # Errors
+impl Transaction {
+    pub fn address_bytes(&self) -> &[u8; ADDRESS_LEN] {
+        self.verification_key.address_bytes()
+    }
+
+    /// Returns the transaction ID, containing the transaction hash.
     ///
-    /// Will return an error if signature or verification key cannot be reconstructed from the bytes
-    /// contained in the raw input, if the transaction field was empty (meaning it was mapped to
-    /// `None`), if the inner transaction could not be verified given the key and signature, or
-    /// if the native [`Body`] could not be created from the inner raw
-    /// [`raw::Body`].
-    pub fn try_from_raw(proto: raw::Transaction) -> Result<Self, TransactionError> {
-        let raw::Transaction {
-            signature,
-            public_key,
-            body,
-        } = proto;
-        let signature = Signature::try_from(&*signature).map_err(TransactionError::signature)?;
-        let verification_key =
-            VerificationKey::try_from(&*public_key).map_err(TransactionError::verification_key)?;
-        let Some(body) = body else {
-            return Err(TransactionError::unset_body());
+    /// The transaction hash is calculated by protobuf-encoding the transaction
+    /// and hashing the resulting bytes with sha256.
+    #[must_use]
+    pub fn id(&self) -> TransactionId {
+        use sha2::{
+            Digest as _,
+            Sha256,
         };
-        let bytes = body.value.clone();
-        verification_key
-            .verify(&signature, &bytes)
-            .map_err(TransactionError::verification)?;
-        let transaction = TransactionBody::try_from_any(body).map_err(TransactionError::body)?;
-        Ok(Self {
-            signature,
-            verification_key,
-            body: transaction,
-            body_bytes: bytes,
-        })
+        let bytes = self.to_raw().encode_to_vec();
+        TransactionId::new(Sha256::digest(bytes).into())
     }
 
     #[must_use]
@@ -215,12 +235,82 @@ impl Transaction {
     }
 }
 
+impl From<Transaction> for raw::Transaction {
+    fn from(value: Transaction) -> Self {
+        value.into_raw()
+    }
+}
+
+impl TryFrom<raw::Transaction> for Transaction {
+    type Error = TransactionError;
+
+    fn try_from(value: raw::Transaction) -> Result<Self, Self::Error> {
+        Self::try_from_raw(value)
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct TransactionBody {
     actions: Actions,
     params: TransactionParams,
 }
 
+impl Protobuf for TransactionBody {
+    type Error = TransactionBodyError;
+    type Raw = raw::TransactionBody;
+
+    fn try_from_raw_ref(raw: &Self::Raw) -> Result<Self, Self::Error> {
+        let raw::TransactionBody {
+            actions,
+            params,
+        } = raw;
+
+        let Some(params) = params else {
+            return Err(TransactionBodyError::unset_params());
+        };
+        let params = TransactionParams::from_raw_ref(params);
+        let actions: Vec<_> = actions
+            .iter()
+            .map(Action::try_from_raw_ref)
+            .collect::<Result<_, _>>()
+            .map_err(TransactionBodyError::action)?;
+
+        TransactionBody::builder()
+            .actions(actions)
+            .chain_id(params.chain_id)
+            .nonce(params.nonce)
+            .try_build()
+            .map_err(TransactionBodyError::group)
+    }
+
+    fn try_from_raw(proto: Self::Raw) -> Result<Self, TransactionBodyError> {
+        let raw::TransactionBody {
+            actions,
+            params,
+        } = proto;
+        let Some(params) = params else {
+            return Err(TransactionBodyError::unset_params());
+        };
+        let params = TransactionParams::from_raw(params);
+        let actions: Vec<_> = actions
+            .into_iter()
+            .map(Action::try_from_raw)
+            .collect::<Result<_, _>>()
+            .map_err(TransactionBodyError::action)?;
+
+        TransactionBody::builder()
+            .actions(actions)
+            .chain_id(params.chain_id)
+            .nonce(params.nonce)
+            .try_build()
+            .map_err(TransactionBodyError::group)
+    }
+
+    fn to_raw(&self) -> Self::Raw {
+        todo!()
+    }
+}
+
 impl TransactionBody {
     #[must_use]
     pub fn builder() -> TransactionBodyBuilder {
@@ -303,35 +393,6 @@ impl TransactionBody {
         self.clone().into_any()
     }
 
-    /// Attempt to convert from a raw, unchecked protobuf [`raw::Body`].
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if one of the inner raw actions could not be converted to a native
-    /// [`Action`].
-    pub fn try_from_raw(proto: raw::TransactionBody) -> Result<Self, TransactionBodyError> {
-        let raw::TransactionBody {
-            actions,
-            params,
-        } = proto;
-        let Some(params) = params else {
-            return Err(TransactionBodyError::unset_params());
-        };
-        let params = TransactionParams::from_raw(params);
-        let actions: Vec<_> = actions
-            .into_iter()
-            .map(Action::try_from_raw)
-            .collect::<Result<_, _>>()
-            .map_err(TransactionBodyError::action)?;
-
-        TransactionBody::builder()
-            .actions(actions)
-            .chain_id(params.chain_id)
-            .nonce(params.nonce)
-            .try_build()
-            .map_err(TransactionBodyError::group)
-    }
-
     /// Attempt to convert from a protobuf [`pbjson_types::Any`].
     ///
     /// # Errors
@@ -493,6 +554,20 @@ impl TransactionParams {
             chain_id,
         }
     }
+
+    /// Convert from a raw protobuf [`raw::Body`].
+    #[must_use]
+    pub fn from_raw_ref(proto: &raw::TransactionParams) -> Self {
+        let raw::TransactionParams {
+            nonce,
+            chain_id,
+        } = proto;
+
+        Self {
+            nonce: *nonce,
+            chain_id: chain_id.clone(),
+        }
+    }
 }
 
 #[cfg(test)]

crates/astria-core/src/protocol/transaction/v1/mod.rs

@@ -33,15 +33,6 @@ use std::{
     sync::Arc,
 };
 
-use astria_core::protocol::{
-    asset::v1::AllowedFeeAssetsResponse,
-    bridge::v1::{
-        BridgeAccountInfoResponse,
-        BridgeAccountLastTxHashResponse,
-    },
-    fees::v1::TransactionFeeResponse,
-    transaction::v1::TransactionBody,
-};
 pub use astria_core::{
     primitive::v1::Address,
     protocol::{
@@ -56,6 +47,18 @@ pub use astria_core::{
         SequencerBlock,
     },
 };
+use astria_core::{
+    protocol::{
+        asset::v1::AllowedFeeAssetsResponse,
+        bridge::v1::{
+            BridgeAccountInfoResponse,
+            BridgeAccountLastTxHashResponse,
+        },
+        fees::v1::TransactionFeeResponse,
+        transaction::v1::TransactionBody,
+    },
+    Protobuf as _,
+};
 use async_trait::async_trait;
 use futures::Stream;
 use prost::{

crates/astria-sequencer-client/src/extension_trait.rs

@@ -34,6 +34,7 @@ use astria_core::{
         },
     },
     sequencerblock::v1::block::SequencerBlock,
+    Protobuf as _,
 };
 use astria_eyre::{
     anyhow_to_eyre,

crates/astria-sequencer/src/app/mod.rs

@@ -3,9 +3,12 @@ use std::{
     ops::Deref,
 };
 
-use astria_core::protocol::transaction::v1::{
-    action::group::Group,
-    Transaction,
+use astria_core::{
+    protocol::transaction::v1::{
+        action::group::Group,
+        Transaction,
+    },
+    Protobuf as _,
 };
 use bytes::Bytes;
 use prost::Message;

crates/astria-sequencer/src/app/tests_block_ordering.rs

@@ -11,6 +11,7 @@ use astria_core::{
             TransactionBody,
         },
     },
+    Protobuf as _,
 };
 use astria_eyre::eyre::{
     self,

crates/astria-sequencer/src/fees/query.rs

@@ -213,6 +213,7 @@ mod tests {
             action::RollupDataSubmission,
             TransactionBody,
         },
+        Protobuf as _,
     };
     use bytes::Bytes;
     use prost::Message as _;

crates/astria-sequencer/src/service/consensus.rs

@@ -16,6 +16,7 @@ use astria_core::{
         abci::AbciErrorCode,
         transaction::v1::Transaction,
     },
+    Protobuf as _,
 };
 use astria_eyre::eyre::WrapErr as _;
 use bytes::Bytes;

crates/astria-sequencer/src/service/mempool/mod.rs

@@ -1,5 +1,6 @@
 use std::num::NonZeroU32;
 
+use astria_core::Protobuf as _;
 use prost::Message as _;
 use telemetry::Metrics;
 use tendermint::{