From ddceb6c5bd90a259159e0f27405a635458bf3fda Mon Sep 17 00:00:00 2001
From: ethanoroshiba <ethan@astria.org>
Date: Mon, 28 Oct 2024 16:06:50 -0500
Subject: [PATCH 1/5] add instrumentation

---
 .../astria-sequencer/src/accounts/action.rs   |  7 +++
 .../src/accounts/component.rs                 |  2 +-
 crates/astria-sequencer/src/accounts/query.rs |  7 ++-
 .../src/accounts/state_ext.rs                 |  6 +-
 .../astria-sequencer/src/address/state_ext.rs |  7 ++-
 crates/astria-sequencer/src/app/mod.rs        | 21 ++++---
 crates/astria-sequencer/src/app/state_ext.rs  | 10 +--
 crates/astria-sequencer/src/assets/query.rs   |  2 +
 .../astria-sequencer/src/assets/state_ext.rs  |  4 +-
 .../astria-sequencer/src/authority/action.rs  |  7 +++
 .../src/authority/component.rs                |  6 +-
 .../src/authority/state_ext.rs                |  6 +-
 .../src/bridge/bridge_lock_action.rs          |  5 ++
 .../src/bridge/bridge_sudo_change_action.rs   |  5 ++
 .../src/bridge/bridge_unlock_action.rs        |  6 ++
 .../src/bridge/init_bridge_account_action.rs  |  5 ++
 crates/astria-sequencer/src/bridge/query.rs   |  6 +-
 .../astria-sequencer/src/bridge/state_ext.rs  | 12 ++--
 crates/astria-sequencer/src/fees/action.rs    |  6 ++
 crates/astria-sequencer/src/fees/component.rs |  2 +-
 crates/astria-sequencer/src/fees/query.rs     |  5 +-
 crates/astria-sequencer/src/fees/state_ext.rs | 62 +++++++++----------
 crates/astria-sequencer/src/grpc/state_ext.rs | 16 ++---
 crates/astria-sequencer/src/ibc/component.rs  |  6 +-
 .../src/ibc/host_interface.rs                 |  5 ++
 .../src/ibc/ibc_relayer_change.rs             |  5 ++
 .../src/ibc/ics20_transfer.rs                 | 10 +++
 .../src/ibc/ics20_withdrawal.rs               |  8 +++
 crates/astria-sequencer/src/ibc/state_ext.rs  |  4 +-
 .../src/mempool/mempool_state.rs              |  2 +-
 crates/astria-sequencer/src/mempool/mod.rs    | 10 +--
 .../src/mempool/transactions_container.rs     |  7 ++-
 crates/astria-sequencer/src/sequencer.rs      | 41 +++++++-----
 .../astria-sequencer/src/service/consensus.rs |  9 +--
 .../src/service/mempool/mod.rs                |  4 ++
 .../src/transaction/checks.rs                 |  6 +-
 .../astria-sequencer/src/transaction/mod.rs   |  7 ++-
 37 files changed, 226 insertions(+), 113 deletions(-)

diff --git a/crates/astria-sequencer/src/accounts/action.rs b/crates/astria-sequencer/src/accounts/action.rs
index dce040abf1..4d1669d1a7 100644
--- a/crates/astria-sequencer/src/accounts/action.rs
+++ b/crates/astria-sequencer/src/accounts/action.rs
@@ -8,6 +8,10 @@ use cnidarium::{
     StateRead,
     StateWrite,
 };
+use tracing::{
+    instrument,
+    Level,
+};
 
 use super::AddressBytes;
 use crate::{
@@ -27,6 +31,7 @@ impl ActionHandler for Transfer {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
@@ -49,6 +54,7 @@ impl ActionHandler for Transfer {
     }
 }
 
+#[instrument(skip_all, err(level = Level::WARN))]
 pub(crate) async fn execute_transfer<S, TAddress>(
     action: &Transfer,
     from: &TAddress,
@@ -71,6 +77,7 @@ where
     Ok(())
 }
 
+#[instrument(skip_all, err(level = Level::WARN))]
 pub(crate) async fn check_transfer<S, TAddress>(
     action: &Transfer,
     from: &TAddress,
diff --git a/crates/astria-sequencer/src/accounts/component.rs b/crates/astria-sequencer/src/accounts/component.rs
index c9d515ec45..b8869d4a7c 100644
--- a/crates/astria-sequencer/src/accounts/component.rs
+++ b/crates/astria-sequencer/src/accounts/component.rs
@@ -25,7 +25,7 @@ pub(crate) struct AccountsComponent;
 impl Component for AccountsComponent {
     type AppState = GenesisAppState;
 
-    #[instrument(name = "AccountsComponent::init_chain", skip_all)]
+    #[instrument(name = "AccountsComponent::init_chain", skip_all, err)]
     async fn init_chain<S>(mut state: S, app_state: &Self::AppState) -> Result<()>
     where
         S: accounts::StateWriteExt + assets::StateReadExt,
diff --git a/crates/astria-sequencer/src/accounts/query.rs b/crates/astria-sequencer/src/accounts/query.rs
index 00c23a4095..5c76cf6aab 100644
--- a/crates/astria-sequencer/src/accounts/query.rs
+++ b/crates/astria-sequencer/src/accounts/query.rs
@@ -36,6 +36,7 @@ use crate::{
     assets::StateReadExt as _,
 };
 
+#[instrument(skip_all, fields(%asset), err)]
 async fn ibc_to_trace<S: StateRead>(
     state: S,
     asset: &asset::IbcPrefixed,
@@ -47,7 +48,7 @@ async fn ibc_to_trace<S: StateRead>(
         .ok_or_eyre("asset not found when user has balance of it; this is a bug")
 }
 
-#[instrument(skip_all, fields(%address))]
+#[instrument(skip_all, fields(%address), err)]
 async fn get_trace_prefixed_account_balances<S: StateRead>(
     state: &S,
     address: &Address,
@@ -70,6 +71,7 @@ async fn get_trace_prefixed_account_balances<S: StateRead>(
 
 /// Returns a list of [`AssetBalance`]s for the provided address. `AssetBalance`s are sorted
 /// alphabetically by [`asset::Denom`].
+#[instrument(skip_all)]
 pub(crate) async fn balance_request(
     storage: Storage,
     request: request::Query,
@@ -112,6 +114,7 @@ pub(crate) async fn balance_request(
     }
 }
 
+#[instrument(skip_all)]
 pub(crate) async fn nonce_request(
     storage: Storage,
     request: request::Query,
@@ -150,6 +153,7 @@ pub(crate) async fn nonce_request(
     }
 }
 
+#[instrument(skip_all, fields(%height), err)]
 async fn get_snapshot_and_height(storage: &Storage, height: Height) -> Result<(Snapshot, Height)> {
     let snapshot = match height.value() {
         0 => storage.latest_snapshot(),
@@ -173,6 +177,7 @@ async fn get_snapshot_and_height(storage: &Storage, height: Height) -> Result<(S
     Ok((snapshot, height))
 }
 
+#[instrument(skip_all)]
 async fn preprocess_request(
     storage: &Storage,
     request: &request::Query,
diff --git a/crates/astria-sequencer/src/accounts/state_ext.rs b/crates/astria-sequencer/src/accounts/state_ext.rs
index 3811dfa54d..c25f840c0f 100644
--- a/crates/astria-sequencer/src/accounts/state_ext.rs
+++ b/crates/astria-sequencer/src/accounts/state_ext.rs
@@ -165,7 +165,7 @@ pub(crate) trait StateReadExt: StateRead + crate::assets::StateReadExt {
             .wrap_err("invalid balance bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_account_nonce<T: AddressBytes>(&self, address: &T) -> Result<u32> {
         let bytes = self
             .get_raw(&keys::nonce(address))
@@ -205,7 +205,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(address = %address.display_address(), nonce), err)]
     fn put_account_nonce<T: AddressBytes>(&mut self, address: &T, nonce: u32) -> Result<()> {
         let bytes = StoredValue::from(storage::Nonce::from(nonce))
             .serialize()
@@ -241,7 +241,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address(), %asset, amount))]
+    #[instrument(skip_all, fields(address = %address.display_address(), %asset, amount), err)]
     async fn decrease_balance<'a, TAddress, TAsset>(
         &mut self,
         address: &TAddress,
diff --git a/crates/astria-sequencer/src/address/state_ext.rs b/crates/astria-sequencer/src/address/state_ext.rs
index 0f5cd5bf30..308bdfc21e 100644
--- a/crates/astria-sequencer/src/address/state_ext.rs
+++ b/crates/astria-sequencer/src/address/state_ext.rs
@@ -22,10 +22,14 @@ use super::storage::{
     self,
     keys,
 };
-use crate::storage::StoredValue;
+use crate::{
+    accounts::AddressBytes as _,
+    storage::StoredValue,
+};
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
+    #[instrument(skip_all, fields(address = %address.display_address()), err)]
     async fn ensure_base_prefix(&self, address: &Address<Bech32m>) -> Result<()> {
         let prefix = self
             .get_base_prefix()
@@ -39,6 +43,7 @@ pub(crate) trait StateReadExt: StateRead {
         Ok(())
     }
 
+    #[instrument(skip_all, err)]
     async fn try_base_prefixed(&self, slice: &[u8]) -> Result<Address> {
         let prefix = self
             .get_base_prefix()
diff --git a/crates/astria-sequencer/src/app/mod.rs b/crates/astria-sequencer/src/app/mod.rs
index 2231b3ab64..1bee46b645 100644
--- a/crates/astria-sequencer/src/app/mod.rs
+++ b/crates/astria-sequencer/src/app/mod.rs
@@ -234,6 +234,7 @@ pub(crate) struct App {
 }
 
 impl App {
+    #[instrument(name = "App::new", skip_all, err)]
     pub(crate) async fn new(
         snapshot: Snapshot,
         mempool: Mempool,
@@ -267,7 +268,7 @@ impl App {
         })
     }
 
-    #[instrument(name = "App:init_chain", skip_all)]
+    #[instrument(name = "App:init_chain", skip_all, err)]
     pub(crate) async fn init_chain(
         &mut self,
         storage: Storage,
@@ -354,7 +355,7 @@ impl App {
     /// It puts this special "commitment" as the first transaction in a block.
     /// When other validators receive the block, they know the first transaction is
     /// supposed to be the commitment, and verifies that is it correct.
-    #[instrument(name = "App::prepare_proposal", skip_all)]
+    #[instrument(name = "App::prepare_proposal", skip_all, err)]
     pub(crate) async fn prepare_proposal(
         &mut self,
         prepare_proposal: abci::request::PrepareProposal,
@@ -404,7 +405,7 @@ impl App {
     /// Generates a commitment to the `sequence::Actions` in the block's transactions
     /// and ensures it matches the commitment created by the proposer, which
     /// should be the first transaction in the block.
-    #[instrument(name = "App::process_proposal", skip_all)]
+    #[instrument(name = "App::process_proposal", skip_all, err)]
     pub(crate) async fn process_proposal(
         &mut self,
         process_proposal: abci::request::ProcessProposal,
@@ -564,7 +565,7 @@ impl App {
     ///
     /// As a result, all transactions in a sequencer block are guaranteed to execute
     /// successfully.
-    #[instrument(name = "App::execute_transactions_prepare_proposal", skip_all)]
+    #[instrument(name = "App::execute_transactions_prepare_proposal", skip_all, err)]
     async fn execute_transactions_prepare_proposal(
         &mut self,
         block_size_constraints: &mut BlockSizeConstraints,
@@ -744,7 +745,7 @@ impl App {
     ///
     /// As a result, all transactions in a sequencer block are guaranteed to execute
     /// successfully.
-    #[instrument(name = "App::execute_transactions_process_proposal", skip_all)]
+    #[instrument(name = "App::execute_transactions_process_proposal", skip_all, err)]
     async fn execute_transactions_process_proposal(
         &mut self,
         txs: Vec<Transaction>,
@@ -877,7 +878,7 @@ impl App {
     /// `SequencerBlock`.
     ///
     /// this must be called after a block's transactions are executed.
-    #[instrument(name = "App::post_execute_transactions", skip_all)]
+    #[instrument(name = "App::post_execute_transactions", skip_all, err)]
     async fn post_execute_transactions(
         &mut self,
         block_hash: Hash,
@@ -961,7 +962,7 @@ impl App {
     ///
     /// This is called by cometbft after the block has already been
     /// committed by the network's consensus.
-    #[instrument(name = "App::finalize_block", skip_all)]
+    #[instrument(name = "App::finalize_block", skip_all, err)]
     pub(crate) async fn finalize_block(
         &mut self,
         finalize_block: abci::request::FinalizeBlock,
@@ -1112,7 +1113,7 @@ impl App {
         Ok(app_hash)
     }
 
-    #[instrument(name = "App::begin_block", skip_all)]
+    #[instrument(name = "App::begin_block", skip_all, err)]
     async fn begin_block(
         &mut self,
         begin_block: &abci::request::BeginBlock,
@@ -1148,7 +1149,7 @@ impl App {
     }
 
     /// Executes a signed transaction.
-    #[instrument(name = "App::execute_transaction", skip_all)]
+    #[instrument(name = "App::execute_transaction", skip_all, err)]
     async fn execute_transaction(&mut self, signed_tx: Arc<Transaction>) -> Result<Vec<Event>> {
         signed_tx
             .check_stateless()
@@ -1176,7 +1177,7 @@ impl App {
         Ok(state_tx.apply().1)
     }
 
-    #[instrument(name = "App::end_block", skip_all)]
+    #[instrument(name = "App::end_block", skip_all, err)]
     async fn end_block(
         &mut self,
         height: u64,
diff --git a/crates/astria-sequencer/src/app/state_ext.rs b/crates/astria-sequencer/src/app/state_ext.rs
index b9a2e3b78e..d4ef0f1de6 100644
--- a/crates/astria-sequencer/src/app/state_ext.rs
+++ b/crates/astria-sequencer/src/app/state_ext.rs
@@ -22,7 +22,7 @@ use crate::storage::StoredValue;
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_chain_id(&self) -> Result<tendermint::chain::Id> {
         let Some(bytes) = self
             .get_raw(keys::CHAIN_ID)
@@ -37,7 +37,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid chain id bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_revision_number(&self) -> Result<u64> {
         let Some(bytes) = self
             .get_raw(keys::REVISION_NUMBER)
@@ -52,7 +52,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid revision number bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_block_height(&self) -> Result<u64> {
         let Some(bytes) = self
             .get_raw(keys::BLOCK_HEIGHT)
@@ -67,7 +67,7 @@ pub(crate) trait StateReadExt: StateRead {
             .context("invalid block height bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_block_timestamp(&self) -> Result<Time> {
         let Some(bytes) = self
             .get_raw(keys::BLOCK_TIMESTAMP)
@@ -82,7 +82,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid block timestamp bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(%height), err)]
     async fn get_storage_version_by_height(&self, height: u64) -> Result<u64> {
         use astria_eyre::eyre::WrapErr as _;
 
diff --git a/crates/astria-sequencer/src/assets/query.rs b/crates/astria-sequencer/src/assets/query.rs
index ee3dad59d2..eacdd47f7c 100644
--- a/crates/astria-sequencer/src/assets/query.rs
+++ b/crates/astria-sequencer/src/assets/query.rs
@@ -11,6 +11,7 @@ use tendermint::abci::{
     response,
     Code,
 };
+use tracing::instrument;
 
 use crate::{
     app::StateReadExt as _,
@@ -21,6 +22,7 @@ use crate::{
 //
 // Example:
 // `abci-cli query --path=asset/denom/<DENOM_ID>`
+#[instrument(skip_all)]
 pub(crate) async fn denom_request(
     storage: Storage,
     request: request::Query,
diff --git a/crates/astria-sequencer/src/assets/state_ext.rs b/crates/astria-sequencer/src/assets/state_ext.rs
index b2ca7d0ca0..da4113f75e 100644
--- a/crates/astria-sequencer/src/assets/state_ext.rs
+++ b/crates/astria-sequencer/src/assets/state_ext.rs
@@ -25,7 +25,7 @@ use crate::storage::StoredValue;
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_native_asset(&self) -> Result<Option<asset::TracePrefixed>> {
         let Some(bytes) = self
             .get_raw(keys::NATIVE_ASSET)
@@ -43,7 +43,7 @@ pub(crate) trait StateReadExt: StateRead {
             .map(Option::Some)
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn has_ibc_asset<'a, TAsset>(&self, asset: &'a TAsset) -> Result<bool>
     where
         TAsset: Sync,
diff --git a/crates/astria-sequencer/src/authority/action.rs b/crates/astria-sequencer/src/authority/action.rs
index 78d69733eb..bc2a778134 100644
--- a/crates/astria-sequencer/src/authority/action.rs
+++ b/crates/astria-sequencer/src/authority/action.rs
@@ -10,6 +10,10 @@ use astria_eyre::eyre::{
     WrapErr as _,
 };
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     address::StateReadExt as _,
@@ -28,6 +32,7 @@ impl ActionHandler for ValidatorUpdate {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
@@ -79,6 +84,7 @@ impl ActionHandler for SudoAddressChange {
 
     /// check that the signer of the transaction is the current sudo address,
     /// as only that address can change the sudo address
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
@@ -107,6 +113,7 @@ impl ActionHandler for IbcSudoChange {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/authority/component.rs b/crates/astria-sequencer/src/authority/component.rs
index f6347dcf0c..01e313f51d 100644
--- a/crates/astria-sequencer/src/authority/component.rs
+++ b/crates/astria-sequencer/src/authority/component.rs
@@ -35,7 +35,7 @@ pub(crate) struct AuthorityComponentAppState {
 impl Component for AuthorityComponent {
     type AppState = AuthorityComponentAppState;
 
-    #[instrument(name = "AuthorityComponent::init_chain", skip_all)]
+    #[instrument(name = "AuthorityComponent::init_chain", skip_all, err)]
     async fn init_chain<S: StateWriteExt>(mut state: S, app_state: &Self::AppState) -> Result<()> {
         // set sudo key and initial validator set
         state
@@ -48,7 +48,7 @@ impl Component for AuthorityComponent {
         Ok(())
     }
 
-    #[instrument(name = "AuthorityComponent::begin_block", skip_all)]
+    #[instrument(name = "AuthorityComponent::begin_block", skip_all, err)]
     async fn begin_block<S: StateWriteExt + 'static>(
         state: &mut Arc<S>,
         begin_block: &BeginBlock,
@@ -70,7 +70,7 @@ impl Component for AuthorityComponent {
         Ok(())
     }
 
-    #[instrument(name = "AuthorityComponent::end_block", skip_all)]
+    #[instrument(name = "AuthorityComponent::end_block", skip_all, err)]
     async fn end_block<S: StateWriteExt + StateReadExt + 'static>(
         state: &mut Arc<S>,
         _end_block: &EndBlock,
diff --git a/crates/astria-sequencer/src/authority/state_ext.rs b/crates/astria-sequencer/src/authority/state_ext.rs
index 16b1dde859..f4b5ac5d12 100644
--- a/crates/astria-sequencer/src/authority/state_ext.rs
+++ b/crates/astria-sequencer/src/authority/state_ext.rs
@@ -30,7 +30,7 @@ use crate::{
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_sudo_address(&self) -> Result<[u8; ADDRESS_LEN]> {
         let Some(bytes) = self
             .get_raw(keys::SUDO)
@@ -46,7 +46,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid sudo key bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_validator_set(&self) -> Result<ValidatorSet> {
         let Some(bytes) = self
             .get_raw(keys::VALIDATOR_SET)
@@ -62,7 +62,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid validator set bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_validator_updates(&self) -> Result<ValidatorSet> {
         let Some(bytes) = self
             .nonverifiable_get_raw(keys::VALIDATOR_UPDATES.as_bytes())
diff --git a/crates/astria-sequencer/src/bridge/bridge_lock_action.rs b/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
index 3a3a4218ea..33f2f0ae6b 100644
--- a/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
+++ b/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
@@ -12,6 +12,10 @@ use astria_eyre::eyre::{
     WrapErr as _,
 };
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     accounts::action::{
@@ -34,6 +38,7 @@ impl ActionHandler for BridgeLock {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs b/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs
index 2a44ae1708..901c62e5b1 100644
--- a/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs
+++ b/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs
@@ -6,6 +6,10 @@ use astria_eyre::eyre::{
     WrapErr as _,
 };
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     address::StateReadExt as _,
@@ -22,6 +26,7 @@ impl ActionHandler for BridgeSudoChange {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/bridge/bridge_unlock_action.rs b/crates/astria-sequencer/src/bridge/bridge_unlock_action.rs
index ed90e15f59..a3291d39ad 100644
--- a/crates/astria-sequencer/src/bridge/bridge_unlock_action.rs
+++ b/crates/astria-sequencer/src/bridge/bridge_unlock_action.rs
@@ -9,6 +9,10 @@ use astria_eyre::eyre::{
     WrapErr as _,
 };
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     accounts::action::{
@@ -27,6 +31,7 @@ use crate::{
 #[async_trait::async_trait]
 impl ActionHandler for BridgeUnlock {
     // TODO(https://github.com/astriaorg/astria/issues/1430): move checks to the `BridgeUnlock` parsing.
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_stateless(&self) -> Result<()> {
         ensure!(self.amount > 0, "amount must be greater than zero",);
         ensure!(self.memo.len() <= 64, "memo must not be more than 64 bytes");
@@ -45,6 +50,7 @@ impl ActionHandler for BridgeUnlock {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs b/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs
index 72d62f1b76..c4e2c140c9 100644
--- a/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs
+++ b/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs
@@ -8,6 +8,10 @@ use astria_eyre::eyre::{
     WrapErr as _,
 };
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     address::StateReadExt as _,
@@ -25,6 +29,7 @@ impl ActionHandler for InitBridgeAccount {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/bridge/query.rs b/crates/astria-sequencer/src/bridge/query.rs
index 9f194f57e4..0333e40862 100644
--- a/crates/astria-sequencer/src/bridge/query.rs
+++ b/crates/astria-sequencer/src/bridge/query.rs
@@ -16,8 +16,10 @@ use tendermint::abci::{
     response,
     Code,
 };
+use tracing::instrument;
 
 use crate::{
+    accounts::AddressBytes as _,
     address::StateReadExt,
     app::StateReadExt as _,
     assets::StateReadExt as _,
@@ -43,7 +45,7 @@ fn error_query_response(
 
 // FIXME (https://github.com/astriaorg/astria/issues/1582): there is a lot of code duplication due to `error_query_response`.
 // this could be significantly shortened.
-#[expect(clippy::too_many_lines, reason = "should be refactored")]
+#[instrument(skip_all, fields(address = %address.display_address()))]
 async fn get_bridge_account_info(
     snapshot: cnidarium::Snapshot,
     address: &Address,
@@ -162,6 +164,7 @@ async fn get_bridge_account_info(
     }))
 }
 
+#[instrument(skip_all)]
 pub(crate) async fn bridge_account_info_request(
     storage: Storage,
     request: request::Query,
@@ -210,6 +213,7 @@ pub(crate) async fn bridge_account_info_request(
     }
 }
 
+#[instrument(skip_all)]
 pub(crate) async fn bridge_account_last_tx_hash_request(
     storage: Storage,
     request: request::Query,
diff --git a/crates/astria-sequencer/src/bridge/state_ext.rs b/crates/astria-sequencer/src/bridge/state_ext.rs
index 692274db8c..a9c3c04867 100644
--- a/crates/astria-sequencer/src/bridge/state_ext.rs
+++ b/crates/astria-sequencer/src/bridge/state_ext.rs
@@ -40,7 +40,7 @@ use crate::{
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(address = %address.display_address()), err)]
     async fn is_a_bridge_account<T: AddressBytes>(&self, address: &T) -> Result<bool> {
         let maybe_id = self.get_bridge_account_rollup_id(address).await?;
         Ok(maybe_id.is_some())
@@ -86,7 +86,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .wrap_err("invalid bridge account asset ID bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(bridge_address = %bridge_address.display_address()), err)]
     async fn get_bridge_account_sudo_address<T: AddressBytes>(
         &self,
         bridge_address: &T,
@@ -109,7 +109,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .wrap_err("invalid bridge account sudo address bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(bridge_address = %bridge_address.display_address()), err)]
     async fn get_bridge_account_withdrawer_address<T: AddressBytes>(
         &self,
         bridge_address: &T,
@@ -138,7 +138,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .unwrap_or_default()
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(block_hash = %hex::encode(block_hash), %rollup_id), err)]
     async fn get_deposits(
         &self,
         block_hash: &[u8; 32],
@@ -157,7 +157,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .context("invalid deposits bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(address = %address.display_address()), err)]
     async fn get_last_transaction_id_for_bridge_account<T: AddressBytes>(
         &self,
         address: &T,
@@ -249,7 +249,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(block_hash = %address.display_address(), withdrawal_event_id, block_num), err)]
     async fn check_and_set_withdrawal_event_block_for_bridge_account<T: AddressBytes>(
         &mut self,
         address: &T,
diff --git a/crates/astria-sequencer/src/fees/action.rs b/crates/astria-sequencer/src/fees/action.rs
index 927eea5ec9..41dd914c96 100644
--- a/crates/astria-sequencer/src/fees/action.rs
+++ b/crates/astria-sequencer/src/fees/action.rs
@@ -10,6 +10,10 @@ use astria_eyre::eyre::{
 use cnidarium::StateWrite;
 use futures::StreamExt;
 use tokio::pin;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     app::ActionHandler,
@@ -29,6 +33,7 @@ impl ActionHandler for FeeChange {
 
     /// check that the signer of the transaction is the current sudo address,
     /// as only that address can change the fee
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> eyre::Result<()> {
         let from = state
             .get_transaction_context()
@@ -94,6 +99,7 @@ impl ActionHandler for FeeAssetChange {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> eyre::Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/fees/component.rs b/crates/astria-sequencer/src/fees/component.rs
index 03ed7cb36c..ec9c917672 100644
--- a/crates/astria-sequencer/src/fees/component.rs
+++ b/crates/astria-sequencer/src/fees/component.rs
@@ -23,7 +23,7 @@ pub(crate) struct FeesComponent;
 impl Component for FeesComponent {
     type AppState = GenesisAppState;
 
-    #[instrument(name = "FeesComponent::init_chain", skip_all)]
+    #[instrument(name = "FeesComponent::init_chain", skip_all, err)]
     async fn init_chain<S>(mut state: S, app_state: &Self::AppState) -> Result<()>
     where
         S: fees::StateWriteExt + fees::StateReadExt,
diff --git a/crates/astria-sequencer/src/fees/query.rs b/crates/astria-sequencer/src/fees/query.rs
index 6342843668..4b90883089 100644
--- a/crates/astria-sequencer/src/fees/query.rs
+++ b/crates/astria-sequencer/src/fees/query.rs
@@ -59,6 +59,7 @@ use crate::{
     assets::StateReadExt as _,
 };
 
+#[instrument(skip_all, fields(%asset))]
 async fn find_trace_prefixed_or_return_ibc<S: StateRead>(
     state: S,
     asset: asset::IbcPrefixed,
@@ -89,6 +90,7 @@ async fn get_allowed_fee_assets<S: StateRead>(state: &S) -> Vec<Denom> {
     stream.collect::<Vec<_>>().await
 }
 
+#[instrument(skip_all)]
 pub(crate) async fn allowed_fee_assets_request(
     storage: Storage,
     request: request::Query,
@@ -134,6 +136,7 @@ pub(crate) async fn allowed_fee_assets_request(
     }
 }
 
+#[instrument(skip_all)]
 pub(crate) async fn transaction_fee_request(
     storage: Storage,
     request: request::Query,
@@ -216,7 +219,7 @@ pub(crate) async fn transaction_fee_request(
     }
 }
 
-#[instrument(skip_all)]
+#[instrument(skip_all, err)]
 pub(crate) async fn get_fees_for_transaction<S: StateRead>(
     tx: &TransactionBody,
     state: &S,
diff --git a/crates/astria-sequencer/src/fees/state_ext.rs b/crates/astria-sequencer/src/fees/state_ext.rs
index dd66e87bb6..021d3a8884 100644
--- a/crates/astria-sequencer/src/fees/state_ext.rs
+++ b/crates/astria-sequencer/src/fees/state_ext.rs
@@ -99,7 +99,7 @@ pub(crate) trait StateReadExt: StateRead {
         self.object_get(keys::BLOCK).unwrap_or_default()
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_transfer_fees(&self) -> Result<Option<TransferFeeComponents>> {
         let bytes = self
             .get_raw(keys::TRANSFER)
@@ -117,7 +117,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_rollup_data_submission_fees(
         &self,
     ) -> Result<Option<RollupDataSubmissionFeeComponents>> {
@@ -137,7 +137,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_ics20_withdrawal_fees(&self) -> Result<Option<Ics20WithdrawalFeeComponents>> {
         let bytes = self
             .get_raw(keys::ICS20_WITHDRAWAL)
@@ -155,7 +155,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_init_bridge_account_fees(&self) -> Result<Option<InitBridgeAccountFeeComponents>> {
         let bytes = self
             .get_raw(keys::INIT_BRIDGE_ACCOUNT)
@@ -173,7 +173,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_bridge_lock_fees(&self) -> Result<Option<BridgeLockFeeComponents>> {
         let bytes = self
             .get_raw(keys::BRIDGE_LOCK)
@@ -191,7 +191,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_bridge_unlock_fees(&self) -> Result<Option<BridgeUnlockFeeComponents>> {
         let bytes = self
             .get_raw(keys::BRIDGE_UNLOCK)
@@ -209,7 +209,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_bridge_sudo_change_fees(&self) -> Result<Option<BridgeSudoChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::BRIDGE_SUDO_CHANGE)
@@ -227,7 +227,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_ibc_relay_fees(&self) -> Result<Option<IbcRelayFeeComponents>> {
         let bytes = self
             .get_raw(keys::IBC_RELAY)
@@ -245,7 +245,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_validator_update_fees(&self) -> Result<Option<ValidatorUpdateFeeComponents>> {
         let bytes = self
             .get_raw(keys::VALIDATOR_UPDATE)
@@ -263,7 +263,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_fee_asset_change_fees(&self) -> Result<Option<FeeAssetChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::FEE_ASSET_CHANGE)
@@ -281,7 +281,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_fee_change_fees(&self) -> Result<Option<FeeChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::FEE_CHANGE)
@@ -299,7 +299,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_ibc_relayer_change_fees(&self) -> Result<Option<IbcRelayerChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::IBC_RELAYER_CHANGE)
@@ -317,7 +317,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_sudo_address_change_fees(&self) -> Result<Option<SudoAddressChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::SUDO_ADDRESS_CHANGE)
@@ -335,7 +335,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_ibc_sudo_change_fees(&self) -> Result<Option<IbcSudoChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::IBC_SUDO_CHANGE)
@@ -353,7 +353,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn is_allowed_fee_asset<'a, TAsset>(&self, asset: &'a TAsset) -> Result<bool>
     where
         TAsset: Sync,
@@ -380,7 +380,7 @@ impl<T: ?Sized + StateRead> StateReadExt for T {}
 #[async_trait]
 pub(crate) trait StateWriteExt: StateWrite {
     /// Constructs and adds `Fee` object to the block fees vec.
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn add_fee_to_block_fees<'a, TAsset, T: FeeHandler + Protobuf>(
         &mut self,
         asset: &'a TAsset,
@@ -415,7 +415,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_transfer_fees(&mut self, fees: TransferFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::TransferFeeComponentsStorage::from(fees))
             .serialize()
@@ -424,7 +424,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_rollup_data_submission_fees(
         &mut self,
         fees: RollupDataSubmissionFeeComponents,
@@ -438,7 +438,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_ics20_withdrawal_fees(&mut self, fees: Ics20WithdrawalFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::Ics20WithdrawalFeeComponentsStorage::from(fees))
             .serialize()
@@ -447,7 +447,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_init_bridge_account_fees(&mut self, fees: InitBridgeAccountFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::InitBridgeAccountFeeComponentsStorage::from(fees))
             .serialize()
@@ -456,7 +456,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_bridge_lock_fees(&mut self, fees: BridgeLockFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::BridgeLockFeeComponentsStorage::from(fees))
             .serialize()
@@ -465,7 +465,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_bridge_unlock_fees(&mut self, fees: BridgeUnlockFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::BridgeUnlockFeeComponentsStorage::from(fees))
             .serialize()
@@ -474,7 +474,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_bridge_sudo_change_fees(&mut self, fees: BridgeSudoChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::BridgeSudoChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -483,7 +483,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_ibc_relay_fees(&mut self, fees: IbcRelayFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::IbcRelayFeeComponentsStorage::from(fees))
             .serialize()
@@ -492,7 +492,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_validator_update_fees(&mut self, fees: ValidatorUpdateFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::ValidatorUpdateFeeComponentsStorage::from(fees))
             .serialize()
@@ -501,7 +501,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_fee_asset_change_fees(&mut self, fees: FeeAssetChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::FeeAssetChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -510,7 +510,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_fee_change_fees(&mut self, fees: FeeChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::FeeChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -519,7 +519,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_ibc_relayer_change_fees(&mut self, fees: IbcRelayerChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::IbcRelayerChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -528,7 +528,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_sudo_address_change_fees(&mut self, fees: SudoAddressChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::SudoAddressChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -537,7 +537,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_ibc_sudo_change_fees(&mut self, fees: IbcSudoChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::IbcSudoChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -554,7 +554,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         self.delete(keys::allowed_asset(asset));
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     fn put_allowed_fee_asset<'a, TAsset>(&mut self, asset: &'a TAsset) -> Result<()>
     where
         &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
diff --git a/crates/astria-sequencer/src/grpc/state_ext.rs b/crates/astria-sequencer/src/grpc/state_ext.rs
index c1af73011c..561a7dbd85 100644
--- a/crates/astria-sequencer/src/grpc/state_ext.rs
+++ b/crates/astria-sequencer/src/grpc/state_ext.rs
@@ -30,7 +30,7 @@ use crate::storage::StoredValue;
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(%height), err)]
     async fn get_block_hash_by_height(&self, height: u64) -> Result<[u8; 32]> {
         let Some(bytes) = self
             .nonverifiable_get_raw(keys::block_hash_by_height(height).as_bytes())
@@ -45,7 +45,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid block hash bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err)]
     async fn get_sequencer_block_header_by_hash(
         &self,
         hash: &[u8; 32],
@@ -65,7 +65,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid sequencer block header bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err)]
     async fn get_rollup_ids_by_block_hash(&self, hash: &[u8; 32]) -> Result<Vec<RollupId>> {
         let Some(bytes) = self
             .nonverifiable_get_raw(keys::rollup_ids_by_hash(hash).as_bytes())
@@ -80,7 +80,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid rollup ids bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(%height), err)]
     async fn get_sequencer_block_by_height(&self, height: u64) -> Result<SequencerBlock> {
         let hash = self
             .get_block_hash_by_height(height)
@@ -91,7 +91,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("failed to get sequencer block by hash")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash), %rollup_id), err)]
     async fn get_rollup_data(
         &self,
         hash: &[u8; 32],
@@ -116,7 +116,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid rollup transactions bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err)]
     async fn get_rollup_transactions_proof_by_block_hash(
         &self,
         hash: &[u8; 32],
@@ -134,7 +134,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid rollup transactions proof bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err)]
     async fn get_rollup_ids_proof_by_block_hash(&self, hash: &[u8; 32]) -> Result<merkle::Proof> {
         let Some(bytes) = self
             .nonverifiable_get_raw(keys::rollup_ids_proof_by_hash(hash).as_bytes())
@@ -180,7 +180,7 @@ pub(crate) trait StateWriteExt: StateWrite {
     }
 }
 
-#[instrument(skip_all)]
+#[instrument(skip_all, fields(hash = %hex::encode(hash)), err)]
 async fn get_sequencer_block_by_hash<S: StateRead + ?Sized>(
     state: &S,
     hash: &[u8; 32],
diff --git a/crates/astria-sequencer/src/ibc/component.rs b/crates/astria-sequencer/src/ibc/component.rs
index f8bc969e39..b3a748f69f 100644
--- a/crates/astria-sequencer/src/ibc/component.rs
+++ b/crates/astria-sequencer/src/ibc/component.rs
@@ -30,7 +30,7 @@ pub(crate) struct IbcComponent;
 impl Component for IbcComponent {
     type AppState = GenesisAppState;
 
-    #[instrument(name = "IbcComponent::init_chain", skip_all)]
+    #[instrument(name = "IbcComponent::init_chain", skip_all, err)]
     async fn init_chain<S: StateWriteExt>(mut state: S, app_state: &Self::AppState) -> Result<()> {
         Ibc::init_chain(
             &mut state,
@@ -53,7 +53,7 @@ impl Component for IbcComponent {
         Ok(())
     }
 
-    #[instrument(name = "IbcComponent::begin_block", skip_all)]
+    #[instrument(name = "IbcComponent::begin_block", skip_all, err)]
     async fn begin_block<S: StateWriteExt + 'static>(
         state: &mut Arc<S>,
         begin_block: &BeginBlock,
@@ -62,7 +62,7 @@ impl Component for IbcComponent {
         Ok(())
     }
 
-    #[instrument(name = "IbcComponent::end_block", skip_all)]
+    #[instrument(name = "IbcComponent::end_block", skip_all, err)]
     async fn end_block<S: StateWriteExt + 'static>(
         state: &mut Arc<S>,
         end_block: &EndBlock,
diff --git a/crates/astria-sequencer/src/ibc/host_interface.rs b/crates/astria-sequencer/src/ibc/host_interface.rs
index 33e76455b2..c00114c59d 100644
--- a/crates/astria-sequencer/src/ibc/host_interface.rs
+++ b/crates/astria-sequencer/src/ibc/host_interface.rs
@@ -4,6 +4,7 @@ use astria_eyre::{
 };
 use cnidarium::StateRead;
 use penumbra_ibc::component::HostInterface;
+use tracing::instrument;
 
 use crate::app::StateReadExt as _;
 
@@ -12,6 +13,7 @@ pub(crate) struct AstriaHost;
 
 #[async_trait::async_trait]
 impl HostInterface for AstriaHost {
+    #[instrument(skip_all)]
     async fn get_chain_id<S: StateRead>(state: S) -> anyhow::Result<String> {
         state
             .get_chain_id()
@@ -20,14 +22,17 @@ impl HostInterface for AstriaHost {
             .map(|s| s.to_string())
     }
 
+    #[instrument(skip_all)]
     async fn get_revision_number<S: StateRead>(state: S) -> anyhow::Result<u64> {
         state.get_revision_number().await.map_err(eyre_to_anyhow)
     }
 
+    #[instrument(skip_all)]
     async fn get_block_height<S: StateRead>(state: S) -> anyhow::Result<u64> {
         state.get_block_height().await.map_err(eyre_to_anyhow)
     }
 
+    #[instrument(skip_all)]
     async fn get_block_timestamp<S: StateRead>(state: S) -> anyhow::Result<tendermint::Time> {
         state.get_block_timestamp().await.map_err(eyre_to_anyhow)
     }
diff --git a/crates/astria-sequencer/src/ibc/ibc_relayer_change.rs b/crates/astria-sequencer/src/ibc/ibc_relayer_change.rs
index 0c277b412e..bd9936cdfa 100644
--- a/crates/astria-sequencer/src/ibc/ibc_relayer_change.rs
+++ b/crates/astria-sequencer/src/ibc/ibc_relayer_change.rs
@@ -6,6 +6,10 @@ use astria_eyre::eyre::{
 };
 use async_trait::async_trait;
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     address::StateReadExt as _,
@@ -23,6 +27,7 @@ impl ActionHandler for IbcRelayerChange {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/ibc/ics20_transfer.rs b/crates/astria-sequencer/src/ibc/ics20_transfer.rs
index 0dc0d2794b..4cb73b2afe 100644
--- a/crates/astria-sequencer/src/ibc/ics20_transfer.rs
+++ b/crates/astria-sequencer/src/ibc/ics20_transfer.rs
@@ -179,6 +179,7 @@ pub(crate) struct Ics20Transfer;
 
 #[async_trait::async_trait]
 impl AppHandlerCheck for Ics20Transfer {
+    #[instrument(skip_all)]
     async fn chan_open_init_check<S: StateRead>(
         _: S,
         msg: &MsgChannelOpenInit,
@@ -194,6 +195,7 @@ impl AppHandlerCheck for Ics20Transfer {
         Ok(())
     }
 
+    #[instrument(skip_all)]
     async fn chan_open_try_check<S: StateRead>(
         _: S,
         msg: &MsgChannelOpenTry,
@@ -209,6 +211,7 @@ impl AppHandlerCheck for Ics20Transfer {
         Ok(())
     }
 
+    #[instrument(skip_all)]
     async fn chan_open_ack_check<S: StateRead>(
         _: S,
         msg: &MsgChannelOpenAck,
@@ -220,6 +223,7 @@ impl AppHandlerCheck for Ics20Transfer {
         Ok(())
     }
 
+    #[instrument(skip_all)]
     async fn chan_open_confirm_check<S: StateRead>(
         _: S,
         _: &MsgChannelOpenConfirm,
@@ -229,6 +233,7 @@ impl AppHandlerCheck for Ics20Transfer {
         Ok(())
     }
 
+    #[instrument(skip_all)]
     async fn chan_close_init_check<S: StateRead>(
         _: S,
         _: &MsgChannelCloseInit,
@@ -236,6 +241,7 @@ impl AppHandlerCheck for Ics20Transfer {
         anyhow::bail!("ics20 always aborts on chan_close_init");
     }
 
+    #[instrument(skip_all)]
     async fn chan_close_confirm_check<S: StateRead>(
         _: S,
         _: &MsgChannelCloseConfirm,
@@ -244,6 +250,7 @@ impl AppHandlerCheck for Ics20Transfer {
         Ok(())
     }
 
+    #[instrument(skip_all)]
     async fn recv_packet_check<S: StateRead>(_: S, msg: &MsgRecvPacket) -> anyhow::Result<()> {
         // most checks performed in `execute`
         // perform stateless checks here
@@ -258,6 +265,7 @@ impl AppHandlerCheck for Ics20Transfer {
         Ok(())
     }
 
+    #[instrument(skip_all)]
     async fn timeout_packet_check<S: StateRead>(state: S, msg: &MsgTimeout) -> anyhow::Result<()> {
         refund_tokens_check(
             state,
@@ -269,6 +277,7 @@ impl AppHandlerCheck for Ics20Transfer {
         .map_err(eyre_to_anyhow)
     }
 
+    #[instrument(skip_all)]
     async fn acknowledge_packet_check<S: StateRead>(
         state: S,
         msg: &MsgAcknowledgement,
@@ -293,6 +302,7 @@ impl AppHandlerCheck for Ics20Transfer {
     }
 }
 
+#[instrument(skip_all, fields(%source_port, %source_channel), err)]
 async fn refund_tokens_check<S: StateRead>(
     state: S,
     data: &[u8],
diff --git a/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs b/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs
index 10c955e694..4ccbb4d15d 100644
--- a/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs
+++ b/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs
@@ -34,6 +34,10 @@ use penumbra_ibc::component::packet::{
     Unchecked,
 };
 use penumbra_proto::core::component::ibc::v1::FungibleTokenPacketData;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     accounts::{
@@ -56,6 +60,7 @@ use crate::{
     transaction::StateReadExt as _,
 };
 
+#[instrument(skip_all, err)]
 async fn create_ibc_packet_from_withdrawal<S: StateRead>(
     withdrawal: &action::Ics20Withdrawal,
     state: S,
@@ -105,6 +110,7 @@ async fn create_ibc_packet_from_withdrawal<S: StateRead>(
 /// 1. Errors reading from DB
 /// 2. `action.bridge_address` is set, but `from` is not the withdrawer address.
 /// 3. `action.bridge_address` is unset, but `from` is a bridge account.
+#[instrument(skip_all, fields(from_address = %hex::encode(from)), err)]
 async fn establish_withdrawal_target<'a, S: StateRead>(
     action: &'a action::Ics20Withdrawal,
     state: &S,
@@ -144,6 +150,7 @@ async fn establish_withdrawal_target<'a, S: StateRead>(
 #[async_trait::async_trait]
 impl ActionHandler for action::Ics20Withdrawal {
     // TODO(https://github.com/astriaorg/astria/issues/1430): move checks to the `Ics20Withdrawal` parsing.
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_stateless(&self) -> Result<()> {
         ensure!(self.timeout_time() != 0, "timeout time must be non-zero",);
         ensure!(self.amount() > 0, "amount must be greater than zero",);
@@ -179,6 +186,7 @@ impl ActionHandler for action::Ics20Withdrawal {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/ibc/state_ext.rs b/crates/astria-sequencer/src/ibc/state_ext.rs
index 5bc28cf21a..3460f21451 100644
--- a/crates/astria-sequencer/src/ibc/state_ext.rs
+++ b/crates/astria-sequencer/src/ibc/state_ext.rs
@@ -62,7 +62,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid ibc channel balance bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn get_ibc_sudo_address(&self) -> Result<[u8; ADDRESS_LEN]> {
         let Some(bytes) = self
             .get_raw(keys::IBC_SUDO)
@@ -78,7 +78,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid ibc sudo address bytes")
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn is_ibc_relayer<T: AddressBytes>(&self, address: T) -> Result<bool> {
         Ok(self
             .get_raw(&keys::ibc_relayer(&address))
diff --git a/crates/astria-sequencer/src/mempool/mempool_state.rs b/crates/astria-sequencer/src/mempool/mempool_state.rs
index ad970bc3fd..88e8ccebc7 100644
--- a/crates/astria-sequencer/src/mempool/mempool_state.rs
+++ b/crates/astria-sequencer/src/mempool/mempool_state.rs
@@ -10,7 +10,7 @@ use crate::accounts::{
     StateReadExt as _,
 };
 
-#[instrument(skip_all)]
+#[instrument(skip_all, fields(address = %address.display_address()), err)]
 pub(crate) async fn get_account_balances<S: StateRead, T: AddressBytes>(
     state: S,
     address: &T,
diff --git a/crates/astria-sequencer/src/mempool/mod.rs b/crates/astria-sequencer/src/mempool/mod.rs
index 623f6f963b..352448d648 100644
--- a/crates/astria-sequencer/src/mempool/mod.rs
+++ b/crates/astria-sequencer/src/mempool/mod.rs
@@ -203,7 +203,7 @@ impl Mempool {
 
     /// Inserts a transaction into the mempool and does not allow for transaction replacement.
     /// Will return the reason for insertion failure if failure occurs.
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(tx_hash = %tx.id(), current_account_nonce), err)]
     pub(crate) async fn insert(
         &self,
         tx: Arc<Transaction>,
@@ -291,6 +291,7 @@ impl Mempool {
     /// Returns a copy of all transactions and their hashes ready for execution, sorted first by the
     /// difference between a transaction and the account's current nonce and then by the time that
     /// the transaction was first seen by the appside mempool.
+    #[instrument(skip_all, err)]
     pub(crate) async fn builder_queue<S: accounts::StateReadExt>(
         &self,
         state: &S,
@@ -303,6 +304,7 @@ impl Mempool {
     ///
     /// This function should only be used to remove invalid/failing transactions and not executed
     /// transactions. Executed transactions will be removed in the `run_maintenance()` function.
+    #[instrument(skip_all, fields(tx_hash = %signed_tx.id()))]
     pub(crate) async fn remove_tx_invalid(
         &self,
         signed_tx: Arc<Transaction>,
@@ -342,13 +344,13 @@ impl Mempool {
 
     /// Checks if a transaction was flagged to be removed from the `CometBFT` mempool. Will
     /// remove the transaction from the cache if it is present.
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(tx_hash = %hex::encode(tx_hash)))]
     pub(crate) async fn check_removed_comet_bft(&self, tx_hash: [u8; 32]) -> Option<RemovalReason> {
         self.comet_bft_removal_cache.write().await.remove(tx_hash)
     }
 
     /// Returns true if the transaction is tracked as inserted.
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(tx_hash = %hex::encode(tx_hash)))]
     pub(crate) async fn is_tracked(&self, tx_hash: [u8; 32]) -> bool {
         self.contained_txs.read().await.contains(&tx_hash)
     }
@@ -482,7 +484,7 @@ impl Mempool {
     /// does not take into account gapped nonces in the parked queue. For example, if the
     /// pending queue for an account has nonces [0,1] and the parked queue has [3], [1] will be
     /// returned.
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(address = %hex::encode(address)))]
     pub(crate) async fn pending_nonce(&self, address: &[u8; 20]) -> Option<u32> {
         self.pending.read().await.pending_nonce(address)
     }
diff --git a/crates/astria-sequencer/src/mempool/transactions_container.rs b/crates/astria-sequencer/src/mempool/transactions_container.rs
index 54ba8266ac..647396fa54 100644
--- a/crates/astria-sequencer/src/mempool/transactions_container.rs
+++ b/crates/astria-sequencer/src/mempool/transactions_container.rs
@@ -26,7 +26,10 @@ use tokio::time::{
     Duration,
     Instant,
 };
-use tracing::error;
+use tracing::{
+    error,
+    instrument,
+};
 
 use super::RemovalReason;
 use crate::{
@@ -569,6 +572,7 @@ pub(super) trait TransactionsContainer<T: TransactionsForAccount> {
     /// Recosts transactions for an account.
     ///
     /// Logs an error if fails to recost a transaction.
+    #[instrument(skip_all, fields(address = %hex::encode(address)))]
     async fn recost_transactions<S: accounts::StateReadExt>(
         &mut self,
         address: &[u8; 20],
@@ -770,6 +774,7 @@ impl PendingTransactions {
 
     /// Returns a copy of transactions and their hashes sorted by nonce difference and then time
     /// first seen.
+    #[instrument(skip_all, err)]
     pub(super) async fn builder_queue<S: accounts::StateReadExt>(
         &self,
         state: &S,
diff --git a/crates/astria-sequencer/src/sequencer.rs b/crates/astria-sequencer/src/sequencer.rs
index 8d0dca32c6..594e951a4a 100644
--- a/crates/astria-sequencer/src/sequencer.rs
+++ b/crates/astria-sequencer/src/sequencer.rs
@@ -29,8 +29,9 @@ use tokio::{
 use tower_abci::v038::Server;
 use tracing::{
     error,
+    error_span,
     info,
-    instrument,
+    info_span,
 };
 
 use crate::{
@@ -46,7 +47,7 @@ use crate::{
 pub struct Sequencer;
 
 impl Sequencer {
-    #[instrument(skip_all)]
+    #[expect(clippy::missing_errors_doc, reason = "not a public function")]
     pub async fn run_until_stopped(config: Config, metrics: &'static Metrics) -> Result<()> {
         cnidarium::register_metrics();
         register_histogram_global("cnidarium_get_raw_duration_seconds");
@@ -57,15 +58,19 @@ impl Sequencer {
             .try_exists()
             .context("failed checking for existence of db storage file")?
         {
-            info!(
-                path = %config.db_filepath.display(),
-                "opening storage db"
-            );
+            info_span!("Sequencer::run_until_stopped").in_scope(|| {
+                info!(
+                    path = %config.db_filepath.display(),
+                    "opening storage db"
+                );
+            });
         } else {
-            info!(
-                path = %config.db_filepath.display(),
-                "creating storage db"
-            );
+            info_span!("Sequencer::run_until_stopped").in_scope(|| {
+                info!(
+                    path = %config.db_filepath.display(),
+                    "creating storage db"
+                );
+            });
         }
 
         let mut signals = spawn_signal_handler();
@@ -119,15 +124,17 @@ impl Sequencer {
             .wrap_err("failed to parse grpc_addr address")?;
         let grpc_server_handle = start_grpc_server(&storage, mempool, grpc_addr, shutdown_rx);
 
-        info!(config.listen_addr, "starting sequencer");
+        info_span!("Sequencer::run_until_stopped")
+            .in_scope(|| info!(config.listen_addr, "starting sequencer"));
         let server_handle = tokio::spawn(async move {
             match server.listen_tcp(&config.listen_addr).await {
                 Ok(()) => {
                     // this shouldn't happen, as there isn't a way for the ABCI server to exit
-                    info!("ABCI server exited successfully");
+                    info_span!("abci_server").in_scope(|| info!("ABCI server exited successfully"));
                 }
                 Err(e) => {
-                    error!(err = e.as_ref(), "ABCI server exited with error");
+                    error_span!("abci_server")
+                        .in_scope(|| error!(err = e.as_ref(), "ABCI server exited with error"));
                 }
             }
             let _ = server_exit_tx.send(());
@@ -135,11 +142,11 @@ impl Sequencer {
 
         select! {
             _ = signals.stop_rx.changed() => {
-                info!("shutting down sequencer");
+                info_span!("Sequencer::run_until_stopped").in_scope(|| info!("shutting down sequencer"));
             }
 
             _ = server_exit_rx => {
-                error!("ABCI server task exited, this shouldn't happen");
+                error_span!("Sequencer::run_until_stopped").in_scope(|| error!("ABCI server task exited, this shouldn't happen"));
             }
         }
 
@@ -179,9 +186,9 @@ fn start_grpc_server(
         .trace_fn(|req| {
             if let Some(remote_addr) = remote_addr(req) {
                 let addr = remote_addr.to_string();
-                tracing::error_span!("grpc", addr)
+                error_span!("grpc", addr)
             } else {
-                tracing::error_span!("grpc")
+                error_span!("grpc")
             }
         })
         // (from Penumbra) Allow HTTP/1, which will be used by grpc-web connections.
diff --git a/crates/astria-sequencer/src/service/consensus.rs b/crates/astria-sequencer/src/service/consensus.rs
index 2d0443513b..9fec22fa0c 100644
--- a/crates/astria-sequencer/src/service/consensus.rs
+++ b/crates/astria-sequencer/src/service/consensus.rs
@@ -15,6 +15,7 @@ use tokio::sync::mpsc;
 use tower_abci::BoxError;
 use tower_actor::Message;
 use tracing::{
+    debug,
     instrument,
     warn,
     Instrument,
@@ -153,7 +154,7 @@ impl Consensus {
         })
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn handle_prepare_proposal(
         &mut self,
         prepare_proposal: request::PrepareProposal,
@@ -163,7 +164,7 @@ impl Consensus {
             .await
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn handle_process_proposal(
         &mut self,
         process_proposal: request::ProcessProposal,
@@ -171,11 +172,11 @@ impl Consensus {
         self.app
             .process_proposal(process_proposal, self.storage.clone())
             .await?;
-        tracing::debug!("proposal processed");
+        debug!("proposal processed");
         Ok(())
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, err)]
     async fn finalize_block(
         &mut self,
         finalize_block: request::FinalizeBlock,
diff --git a/crates/astria-sequencer/src/service/mempool/mod.rs b/crates/astria-sequencer/src/service/mempool/mod.rs
index 88b59a5b77..56e1000d6a 100644
--- a/crates/astria-sequencer/src/service/mempool/mod.rs
+++ b/crates/astria-sequencer/src/service/mempool/mod.rs
@@ -262,6 +262,7 @@ async fn handle_check_tx<S: StateRead>(
 }
 
 /// Checks if the transaction is already in the mempool.
+#[instrument(skip_all, fields(tx_hash = %hex::encode(tx_hash)))]
 async fn is_tracked(tx_hash: [u8; 32], mempool: &AppMempool, metrics: &Metrics) -> bool {
     let start_tracked_check = Instant::now();
 
@@ -276,6 +277,7 @@ async fn is_tracked(tx_hash: [u8; 32], mempool: &AppMempool, metrics: &Metrics)
 ///
 /// Returns an `Err(response::CheckTx)` with an error code and message if the transaction has been
 /// removed from the appside mempool.
+#[instrument(skip_all, fields(tx_hash = %hex::encode(tx_hash)))]
 async fn check_removed_comet_bft(
     tx_hash: [u8; 32],
     mempool: &AppMempool,
@@ -308,6 +310,7 @@ async fn check_removed_comet_bft(
 ///
 /// Returns an `Err(response::CheckTx)` if the transaction fails any of the checks.
 /// Otherwise, it returns the [`Transaction`] to be inserted into the mempool.
+#[instrument(skip_all)]
 async fn stateless_checks<S: StateRead>(
     tx: Bytes,
     state: &S,
@@ -387,6 +390,7 @@ async fn stateless_checks<S: StateRead>(
 ///
 /// Returns a `Err(response::CheckTx)` with an error code and message if the transaction fails
 /// insertion into the mempool.
+#[instrument(skip_all)]
 async fn insert_into_mempool<S: StateRead>(
     mempool: &AppMempool,
     state: &S,
diff --git a/crates/astria-sequencer/src/transaction/checks.rs b/crates/astria-sequencer/src/transaction/checks.rs
index 507a22153a..450bfb543e 100644
--- a/crates/astria-sequencer/src/transaction/checks.rs
+++ b/crates/astria-sequencer/src/transaction/checks.rs
@@ -24,7 +24,7 @@ use crate::{
     fees::query::get_fees_for_transaction,
 };
 
-#[instrument(skip_all)]
+#[instrument(skip_all, fields(tx_hash = %tx.id()), err)]
 pub(crate) async fn check_chain_id_mempool<S: StateRead>(
     tx: &Transaction,
     state: &S,
@@ -39,7 +39,7 @@ pub(crate) async fn check_chain_id_mempool<S: StateRead>(
 
 // Checks that the account has enough balance to cover the total fees and transferred values
 // for all actions in the transaction.
-#[instrument(skip_all)]
+#[instrument(skip_all, fields(tx_hash = %tx.id()), err)]
 pub(crate) async fn check_balance_for_total_fees_and_transfers<S: StateRead>(
     tx: &Transaction,
     state: &S,
@@ -64,7 +64,7 @@ pub(crate) async fn check_balance_for_total_fees_and_transfers<S: StateRead>(
 
 // Returns the total cost of the transaction (fees and transferred values for all actions in the
 // transaction).
-#[instrument(skip_all)]
+#[instrument(skip_all, fields(tx_hash = %tx.id()), err)]
 pub(crate) async fn get_total_transaction_cost<S: StateRead>(
     tx: &Transaction,
     state: &S,
diff --git a/crates/astria-sequencer/src/transaction/mod.rs b/crates/astria-sequencer/src/transaction/mod.rs
index d430cca111..547037e7c8 100644
--- a/crates/astria-sequencer/src/transaction/mod.rs
+++ b/crates/astria-sequencer/src/transaction/mod.rs
@@ -30,6 +30,10 @@ pub(crate) use state_ext::{
     StateReadExt,
     StateWriteExt,
 };
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     accounts::{
@@ -83,6 +87,7 @@ impl std::error::Error for InvalidNonce {}
 
 #[async_trait::async_trait]
 impl ActionHandler for Transaction {
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_stateless(&self) -> Result<()> {
         ensure!(!self.actions().is_empty(), "must have at least one action");
 
@@ -158,7 +163,7 @@ impl ActionHandler for Transaction {
     // FIXME (https://github.com/astriaorg/astria/issues/1584): because most lines come from delegating (and error wrapping) to the
     // individual actions. This could be tidied up by implementing `ActionHandler for Action`
     // and letting it delegate.
-    #[expect(clippy::too_many_lines, reason = "should be refactored")]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         // Add the current signed transaction into the ephemeral state in case
         // downstream actions require access to it.

From 6f2efa006835125713a1c90d94f0c1f9f6501595 Mon Sep 17 00:00:00 2001
From: ethanoroshiba <ethan@astria.org>
Date: Tue, 3 Dec 2024 14:16:03 -0600
Subject: [PATCH 2/5] more conservative use of error level logging

---
 .../astria-sequencer/src/accounts/action.rs   |  6 +-
 crates/astria-sequencer/src/accounts/query.rs | 11 +--
 .../src/accounts/state_ext.rs                 | 15 +++--
 .../astria-sequencer/src/address/state_ext.rs | 13 ++--
 crates/astria-sequencer/src/app/mod.rs        | 21 +++---
 crates/astria-sequencer/src/app/state_ext.rs  | 15 +++--
 .../astria-sequencer/src/assets/state_ext.rs  | 11 +--
 .../astria-sequencer/src/authority/action.rs  |  6 +-
 .../src/authority/component.rs                |  9 ++-
 .../src/authority/state_ext.rs                | 11 +--
 .../src/bridge/bridge_lock_action.rs          |  2 +-
 .../src/bridge/bridge_sudo_change_action.rs   |  2 +-
 .../src/bridge/bridge_unlock_action.rs        |  4 +-
 .../src/bridge/init_bridge_account_action.rs  |  2 +-
 .../astria-sequencer/src/bridge/state_ext.rs  | 19 +++---
 crates/astria-sequencer/src/fees/action.rs    |  4 +-
 crates/astria-sequencer/src/fees/mod.rs       | 30 ++++-----
 crates/astria-sequencer/src/fees/query.rs     |  3 +-
 crates/astria-sequencer/src/fees/state_ext.rs | 67 ++++++++++---------
 crates/astria-sequencer/src/grpc/state_ext.rs | 21 +++---
 crates/astria-sequencer/src/ibc/component.rs  |  9 ++-
 .../src/ibc/ibc_relayer_change.rs             |  2 +-
 .../src/ibc/ics20_transfer.rs                 | 23 ++++---
 .../src/ibc/ics20_withdrawal.rs               |  8 +--
 crates/astria-sequencer/src/ibc/state_ext.rs  | 11 +--
 .../src/mempool/mempool_state.rs              |  7 +-
 crates/astria-sequencer/src/mempool/mod.rs    |  5 +-
 .../src/mempool/transactions_container.rs     |  3 +-
 .../astria-sequencer/src/service/consensus.rs |  5 +-
 .../src/transaction/checks.rs                 | 11 +--
 .../astria-sequencer/src/transaction/mod.rs   |  7 +-
 31 files changed, 203 insertions(+), 160 deletions(-)

diff --git a/crates/astria-sequencer/src/accounts/action.rs b/crates/astria-sequencer/src/accounts/action.rs
index 4d1669d1a7..9096ed7489 100644
--- a/crates/astria-sequencer/src/accounts/action.rs
+++ b/crates/astria-sequencer/src/accounts/action.rs
@@ -31,7 +31,7 @@ impl ActionHandler for Transfer {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
@@ -54,7 +54,7 @@ impl ActionHandler for Transfer {
     }
 }
 
-#[instrument(skip_all, err(level = Level::WARN))]
+#[instrument(skip_all, err(level = Level::DEBUG))]
 pub(crate) async fn execute_transfer<S, TAddress>(
     action: &Transfer,
     from: &TAddress,
@@ -77,7 +77,7 @@ where
     Ok(())
 }
 
-#[instrument(skip_all, err(level = Level::WARN))]
+#[instrument(skip_all, err(level = Level::DEBUG))]
 pub(crate) async fn check_transfer<S, TAddress>(
     action: &Transfer,
     from: &TAddress,
diff --git a/crates/astria-sequencer/src/accounts/query.rs b/crates/astria-sequencer/src/accounts/query.rs
index 5c76cf6aab..c1436da6b4 100644
--- a/crates/astria-sequencer/src/accounts/query.rs
+++ b/crates/astria-sequencer/src/accounts/query.rs
@@ -28,7 +28,10 @@ use tendermint::{
     },
     block::Height,
 };
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     accounts::StateReadExt as _,
@@ -36,7 +39,7 @@ use crate::{
     assets::StateReadExt as _,
 };
 
-#[instrument(skip_all, fields(%asset), err)]
+#[instrument(skip_all, fields(%asset), err(level = Level::DEBUG))]
 async fn ibc_to_trace<S: StateRead>(
     state: S,
     asset: &asset::IbcPrefixed,
@@ -48,7 +51,7 @@ async fn ibc_to_trace<S: StateRead>(
         .ok_or_eyre("asset not found when user has balance of it; this is a bug")
 }
 
-#[instrument(skip_all, fields(%address), err)]
+#[instrument(skip_all, fields(%address), err(level = Level::INFO))]
 async fn get_trace_prefixed_account_balances<S: StateRead>(
     state: &S,
     address: &Address,
@@ -153,7 +156,7 @@ pub(crate) async fn nonce_request(
     }
 }
 
-#[instrument(skip_all, fields(%height), err)]
+#[instrument(skip_all, fields(%height), err(level = Level::INFO))]
 async fn get_snapshot_and_height(storage: &Storage, height: Height) -> Result<(Snapshot, Height)> {
     let snapshot = match height.value() {
         0 => storage.latest_snapshot(),
diff --git a/crates/astria-sequencer/src/accounts/state_ext.rs b/crates/astria-sequencer/src/accounts/state_ext.rs
index c25f840c0f..75bad7f137 100644
--- a/crates/astria-sequencer/src/accounts/state_ext.rs
+++ b/crates/astria-sequencer/src/accounts/state_ext.rs
@@ -25,7 +25,10 @@ use cnidarium::{
 };
 use futures::Stream;
 use pin_project_lite::pin_project;
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use super::storage::{
     self,
@@ -141,7 +144,7 @@ pub(crate) trait StateReadExt: StateRead + crate::assets::StateReadExt {
         }
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address(), %asset), err)]
+    #[instrument(skip_all, fields(address = %address.display_address(), %asset), err(level = Level::DEBUG))]
     async fn get_account_balance<'a, TAddress, TAsset>(
         &self,
         address: &TAddress,
@@ -186,7 +189,7 @@ impl<T: StateRead + ?Sized> StateReadExt for T {}
 
 #[async_trait]
 pub(crate) trait StateWriteExt: StateWrite {
-    #[instrument(skip_all, fields(address = %address.display_address(), %asset, balance), err)]
+    #[instrument(skip_all, fields(address = %address.display_address(), %asset, balance), err(level = Level::DEBUG))]
     fn put_account_balance<'a, TAddress, TAsset>(
         &mut self,
         address: &TAddress,
@@ -205,7 +208,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address(), nonce), err)]
+    #[instrument(skip_all, fields(address = %address.display_address(), nonce), err(level = Level::DEBUG))]
     fn put_account_nonce<T: AddressBytes>(&mut self, address: &T, nonce: u32) -> Result<()> {
         let bytes = StoredValue::from(storage::Nonce::from(nonce))
             .serialize()
@@ -214,7 +217,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address(), %asset, amount), err)]
+    #[instrument(skip_all, fields(address = %address.display_address(), %asset, amount), err(level = Level::DEBUG))]
     async fn increase_balance<'a, TAddress, TAsset>(
         &mut self,
         address: &TAddress,
@@ -241,7 +244,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address(), %asset, amount), err)]
+    #[instrument(skip_all, fields(address = %address.display_address(), %asset, amount), err(level = Level::DEBUG))]
     async fn decrease_balance<'a, TAddress, TAsset>(
         &mut self,
         address: &TAddress,
diff --git a/crates/astria-sequencer/src/address/state_ext.rs b/crates/astria-sequencer/src/address/state_ext.rs
index 308bdfc21e..0721e41e9b 100644
--- a/crates/astria-sequencer/src/address/state_ext.rs
+++ b/crates/astria-sequencer/src/address/state_ext.rs
@@ -16,7 +16,10 @@ use cnidarium::{
     StateRead,
     StateWrite,
 };
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use super::storage::{
     self,
@@ -29,7 +32,7 @@ use crate::{
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all, fields(address = %address.display_address()), err)]
+    #[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::DEBUG))]
     async fn ensure_base_prefix(&self, address: &Address<Bech32m>) -> Result<()> {
         let prefix = self
             .get_base_prefix()
@@ -43,7 +46,7 @@ pub(crate) trait StateReadExt: StateRead {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn try_base_prefixed(&self, slice: &[u8]) -> Result<Address> {
         let prefix = self
             .get_base_prefix()
@@ -56,7 +59,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("failed to construct address from byte slice and state-provided base prefix")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_base_prefix(&self) -> Result<String> {
         let Some(bytes) = self
             .get_raw(keys::BASE_PREFIX)
@@ -71,7 +74,7 @@ pub(crate) trait StateReadExt: StateRead {
             .context("invalid base prefix bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_ibc_compat_prefix(&self) -> Result<String> {
         let Some(bytes) = self
             .get_raw(keys::IBC_COMPAT_PREFIX)
diff --git a/crates/astria-sequencer/src/app/mod.rs b/crates/astria-sequencer/src/app/mod.rs
index 1bee46b645..3c696db8d1 100644
--- a/crates/astria-sequencer/src/app/mod.rs
+++ b/crates/astria-sequencer/src/app/mod.rs
@@ -78,6 +78,7 @@ use tracing::{
     debug,
     info,
     instrument,
+    Level,
 };
 
 pub(crate) use self::{
@@ -355,7 +356,7 @@ impl App {
     /// It puts this special "commitment" as the first transaction in a block.
     /// When other validators receive the block, they know the first transaction is
     /// supposed to be the commitment, and verifies that is it correct.
-    #[instrument(name = "App::prepare_proposal", skip_all, err)]
+    #[instrument(name = "App::prepare_proposal", skip_all, err(level = Level::WARN))]
     pub(crate) async fn prepare_proposal(
         &mut self,
         prepare_proposal: abci::request::PrepareProposal,
@@ -405,7 +406,7 @@ impl App {
     /// Generates a commitment to the `sequence::Actions` in the block's transactions
     /// and ensures it matches the commitment created by the proposer, which
     /// should be the first transaction in the block.
-    #[instrument(name = "App::process_proposal", skip_all, err)]
+    #[instrument(name = "App::process_proposal", skip_all, err(level = Level::WARN))]
     pub(crate) async fn process_proposal(
         &mut self,
         process_proposal: abci::request::ProcessProposal,
@@ -565,7 +566,7 @@ impl App {
     ///
     /// As a result, all transactions in a sequencer block are guaranteed to execute
     /// successfully.
-    #[instrument(name = "App::execute_transactions_prepare_proposal", skip_all, err)]
+    #[instrument(name = "App::execute_transactions_prepare_proposal", skip_all, err(level = Level::DEBUG))]
     async fn execute_transactions_prepare_proposal(
         &mut self,
         block_size_constraints: &mut BlockSizeConstraints,
@@ -745,7 +746,7 @@ impl App {
     ///
     /// As a result, all transactions in a sequencer block are guaranteed to execute
     /// successfully.
-    #[instrument(name = "App::execute_transactions_process_proposal", skip_all, err)]
+    #[instrument(name = "App::execute_transactions_process_proposal", skip_all, err(level = Level::DEBUG))]
     async fn execute_transactions_process_proposal(
         &mut self,
         txs: Vec<Transaction>,
@@ -823,7 +824,7 @@ impl App {
     ///
     /// this *must* be called anytime before a block's txs are executed, whether it's
     /// during the proposal phase, or finalize_block phase.
-    #[instrument(name = "App::pre_execute_transactions", skip_all, err)]
+    #[instrument(name = "App::pre_execute_transactions", skip_all, err(level = Level::DEBUG))]
     async fn pre_execute_transactions(&mut self, block_data: BlockData) -> Result<()> {
         let chain_id = self
             .state
@@ -878,7 +879,7 @@ impl App {
     /// `SequencerBlock`.
     ///
     /// this must be called after a block's transactions are executed.
-    #[instrument(name = "App::post_execute_transactions", skip_all, err)]
+    #[instrument(name = "App::post_execute_transactions", skip_all, err(level = Level::DEBUG))]
     async fn post_execute_transactions(
         &mut self,
         block_hash: Hash,
@@ -1076,7 +1077,7 @@ impl App {
         Ok(finalize_block)
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn prepare_commit(&mut self, storage: Storage) -> Result<AppHash> {
         // extract the state we've built up to so we can prepare it as a `StagedWriteBatch`.
         let dummy_state = StateDelta::new(storage.latest_snapshot());
@@ -1113,7 +1114,7 @@ impl App {
         Ok(app_hash)
     }
 
-    #[instrument(name = "App::begin_block", skip_all, err)]
+    #[instrument(name = "App::begin_block", skip_all, err(level = Level::DEBUG))]
     async fn begin_block(
         &mut self,
         begin_block: &abci::request::BeginBlock,
@@ -1149,7 +1150,7 @@ impl App {
     }
 
     /// Executes a signed transaction.
-    #[instrument(name = "App::execute_transaction", skip_all, err)]
+    #[instrument(name = "App::execute_transaction", skip_all, err(level = Level::INFO))]
     async fn execute_transaction(&mut self, signed_tx: Arc<Transaction>) -> Result<Vec<Event>> {
         signed_tx
             .check_stateless()
@@ -1177,7 +1178,7 @@ impl App {
         Ok(state_tx.apply().1)
     }
 
-    #[instrument(name = "App::end_block", skip_all, err)]
+    #[instrument(name = "App::end_block", skip_all, err(level = Level::DEBUG))]
     async fn end_block(
         &mut self,
         height: u64,
diff --git a/crates/astria-sequencer/src/app/state_ext.rs b/crates/astria-sequencer/src/app/state_ext.rs
index d4ef0f1de6..8841fff2a4 100644
--- a/crates/astria-sequencer/src/app/state_ext.rs
+++ b/crates/astria-sequencer/src/app/state_ext.rs
@@ -12,7 +12,10 @@ use cnidarium::{
     StateWrite,
 };
 use tendermint::Time;
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use super::storage::{
     self,
@@ -22,7 +25,7 @@ use crate::storage::StoredValue;
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_chain_id(&self) -> Result<tendermint::chain::Id> {
         let Some(bytes) = self
             .get_raw(keys::CHAIN_ID)
@@ -37,7 +40,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid chain id bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_revision_number(&self) -> Result<u64> {
         let Some(bytes) = self
             .get_raw(keys::REVISION_NUMBER)
@@ -52,7 +55,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid revision number bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_block_height(&self) -> Result<u64> {
         let Some(bytes) = self
             .get_raw(keys::BLOCK_HEIGHT)
@@ -67,7 +70,7 @@ pub(crate) trait StateReadExt: StateRead {
             .context("invalid block height bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_block_timestamp(&self) -> Result<Time> {
         let Some(bytes) = self
             .get_raw(keys::BLOCK_TIMESTAMP)
@@ -82,7 +85,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid block timestamp bytes")
     }
 
-    #[instrument(skip_all, fields(%height), err)]
+    #[instrument(skip_all, fields(%height), err(level = Level::DEBUG))]
     async fn get_storage_version_by_height(&self, height: u64) -> Result<u64> {
         use astria_eyre::eyre::WrapErr as _;
 
diff --git a/crates/astria-sequencer/src/assets/state_ext.rs b/crates/astria-sequencer/src/assets/state_ext.rs
index da4113f75e..f264c46f3f 100644
--- a/crates/astria-sequencer/src/assets/state_ext.rs
+++ b/crates/astria-sequencer/src/assets/state_ext.rs
@@ -13,7 +13,10 @@ use cnidarium::{
     StateRead,
     StateWrite,
 };
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use super::storage::{
     self,
@@ -25,7 +28,7 @@ use crate::storage::StoredValue;
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_native_asset(&self) -> Result<Option<asset::TracePrefixed>> {
         let Some(bytes) = self
             .get_raw(keys::NATIVE_ASSET)
@@ -43,7 +46,7 @@ pub(crate) trait StateReadExt: StateRead {
             .map(Option::Some)
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn has_ibc_asset<'a, TAsset>(&self, asset: &'a TAsset) -> Result<bool>
     where
         TAsset: Sync,
@@ -57,7 +60,7 @@ pub(crate) trait StateReadExt: StateRead {
             .is_some())
     }
 
-    #[instrument(skip_all, fields(%asset), err)]
+    #[instrument(skip_all, fields(%asset), err(level = Level::DEBUG))]
     async fn map_ibc_to_trace_prefixed_asset(
         &self,
         asset: &asset::IbcPrefixed,
diff --git a/crates/astria-sequencer/src/authority/action.rs b/crates/astria-sequencer/src/authority/action.rs
index bc2a778134..49dbcb4bd0 100644
--- a/crates/astria-sequencer/src/authority/action.rs
+++ b/crates/astria-sequencer/src/authority/action.rs
@@ -32,7 +32,7 @@ impl ActionHandler for ValidatorUpdate {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
@@ -84,7 +84,7 @@ impl ActionHandler for SudoAddressChange {
 
     /// check that the signer of the transaction is the current sudo address,
     /// as only that address can change the sudo address
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
@@ -113,7 +113,7 @@ impl ActionHandler for IbcSudoChange {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/authority/component.rs b/crates/astria-sequencer/src/authority/component.rs
index 01e313f51d..aee3186ea1 100644
--- a/crates/astria-sequencer/src/authority/component.rs
+++ b/crates/astria-sequencer/src/authority/component.rs
@@ -13,7 +13,10 @@ use tendermint::abci::request::{
     BeginBlock,
     EndBlock,
 };
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use super::{
     StateReadExt,
@@ -48,7 +51,7 @@ impl Component for AuthorityComponent {
         Ok(())
     }
 
-    #[instrument(name = "AuthorityComponent::begin_block", skip_all, err)]
+    #[instrument(name = "AuthorityComponent::begin_block", skip_all, err(level = Level::WARN))]
     async fn begin_block<S: StateWriteExt + 'static>(
         state: &mut Arc<S>,
         begin_block: &BeginBlock,
@@ -70,7 +73,7 @@ impl Component for AuthorityComponent {
         Ok(())
     }
 
-    #[instrument(name = "AuthorityComponent::end_block", skip_all, err)]
+    #[instrument(name = "AuthorityComponent::end_block", skip_all, err(level = Level::WARN))]
     async fn end_block<S: StateWriteExt + StateReadExt + 'static>(
         state: &mut Arc<S>,
         _end_block: &EndBlock,
diff --git a/crates/astria-sequencer/src/authority/state_ext.rs b/crates/astria-sequencer/src/authority/state_ext.rs
index f4b5ac5d12..9218712707 100644
--- a/crates/astria-sequencer/src/authority/state_ext.rs
+++ b/crates/astria-sequencer/src/authority/state_ext.rs
@@ -14,7 +14,10 @@ use cnidarium::{
     StateRead,
     StateWrite,
 };
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use super::{
     storage::{
@@ -30,7 +33,7 @@ use crate::{
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_sudo_address(&self) -> Result<[u8; ADDRESS_LEN]> {
         let Some(bytes) = self
             .get_raw(keys::SUDO)
@@ -46,7 +49,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid sudo key bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_validator_set(&self) -> Result<ValidatorSet> {
         let Some(bytes) = self
             .get_raw(keys::VALIDATOR_SET)
@@ -62,7 +65,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid validator set bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_validator_updates(&self) -> Result<ValidatorSet> {
         let Some(bytes) = self
             .nonverifiable_get_raw(keys::VALIDATOR_UPDATES.as_bytes())
diff --git a/crates/astria-sequencer/src/bridge/bridge_lock_action.rs b/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
index 33f2f0ae6b..c947635fea 100644
--- a/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
+++ b/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
@@ -38,7 +38,7 @@ impl ActionHandler for BridgeLock {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs b/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs
index 901c62e5b1..0fe12df17d 100644
--- a/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs
+++ b/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs
@@ -26,7 +26,7 @@ impl ActionHandler for BridgeSudoChange {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/bridge/bridge_unlock_action.rs b/crates/astria-sequencer/src/bridge/bridge_unlock_action.rs
index a3291d39ad..a59bacd457 100644
--- a/crates/astria-sequencer/src/bridge/bridge_unlock_action.rs
+++ b/crates/astria-sequencer/src/bridge/bridge_unlock_action.rs
@@ -31,7 +31,7 @@ use crate::{
 #[async_trait::async_trait]
 impl ActionHandler for BridgeUnlock {
     // TODO(https://github.com/astriaorg/astria/issues/1430): move checks to the `BridgeUnlock` parsing.
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_stateless(&self) -> Result<()> {
         ensure!(self.amount > 0, "amount must be greater than zero",);
         ensure!(self.memo.len() <= 64, "memo must not be more than 64 bytes");
@@ -50,7 +50,7 @@ impl ActionHandler for BridgeUnlock {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs b/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs
index c4e2c140c9..751fc9e7aa 100644
--- a/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs
+++ b/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs
@@ -29,7 +29,7 @@ impl ActionHandler for InitBridgeAccount {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/bridge/state_ext.rs b/crates/astria-sequencer/src/bridge/state_ext.rs
index a9c3c04867..7c337f700c 100644
--- a/crates/astria-sequencer/src/bridge/state_ext.rs
+++ b/crates/astria-sequencer/src/bridge/state_ext.rs
@@ -26,6 +26,7 @@ use cnidarium::{
 use tracing::{
     debug,
     instrument,
+    Level,
 };
 
 use super::storage::{
@@ -40,13 +41,13 @@ use crate::{
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
-    #[instrument(skip_all, fields(address = %address.display_address()), err)]
+    #[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::DEBUG))]
     async fn is_a_bridge_account<T: AddressBytes>(&self, address: &T) -> Result<bool> {
         let maybe_id = self.get_bridge_account_rollup_id(address).await?;
         Ok(maybe_id.is_some())
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address()), err)]
+    #[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::DEBUG))]
     async fn get_bridge_account_rollup_id<T: AddressBytes>(
         &self,
         address: &T,
@@ -68,7 +69,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .wrap_err("invalid rollup ID bytes")
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address()), err)]
+    #[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::DEBUG))]
     async fn get_bridge_account_ibc_asset<T: AddressBytes>(
         &self,
         address: &T,
@@ -86,7 +87,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .wrap_err("invalid bridge account asset ID bytes")
     }
 
-    #[instrument(skip_all, fields(bridge_address = %bridge_address.display_address()), err)]
+    #[instrument(skip_all, fields(bridge_address = %bridge_address.display_address()), err(level = Level::DEBUG))]
     async fn get_bridge_account_sudo_address<T: AddressBytes>(
         &self,
         bridge_address: &T,
@@ -109,7 +110,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .wrap_err("invalid bridge account sudo address bytes")
     }
 
-    #[instrument(skip_all, fields(bridge_address = %bridge_address.display_address()), err)]
+    #[instrument(skip_all, fields(bridge_address = %bridge_address.display_address()), err(level = Level::DEBUG))]
     async fn get_bridge_account_withdrawer_address<T: AddressBytes>(
         &self,
         bridge_address: &T,
@@ -138,7 +139,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .unwrap_or_default()
     }
 
-    #[instrument(skip_all, fields(block_hash = %hex::encode(block_hash), %rollup_id), err)]
+    #[instrument(skip_all, fields(block_hash = %hex::encode(block_hash), %rollup_id), err(level = Level::DEBUG))]
     async fn get_deposits(
         &self,
         block_hash: &[u8; 32],
@@ -157,7 +158,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .context("invalid deposits bytes")
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address()), err)]
+    #[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::DEBUG))]
     async fn get_last_transaction_id_for_bridge_account<T: AddressBytes>(
         &self,
         address: &T,
@@ -249,7 +250,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, fields(block_hash = %address.display_address(), withdrawal_event_id, block_num), err)]
+    #[instrument(skip_all, fields(block_hash = %address.display_address(), withdrawal_event_id, block_num), err(level = Level::DEBUG))]
     async fn check_and_set_withdrawal_event_block_for_bridge_account<T: AddressBytes>(
         &mut self,
         address: &T,
@@ -293,7 +294,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         self.object_put(keys::DEPOSITS_EPHEMERAL, cached_deposits);
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_deposits(
         &mut self,
         block_hash: &[u8; 32],
diff --git a/crates/astria-sequencer/src/fees/action.rs b/crates/astria-sequencer/src/fees/action.rs
index 41dd914c96..b91e88b401 100644
--- a/crates/astria-sequencer/src/fees/action.rs
+++ b/crates/astria-sequencer/src/fees/action.rs
@@ -33,7 +33,7 @@ impl ActionHandler for FeeChange {
 
     /// check that the signer of the transaction is the current sudo address,
     /// as only that address can change the fee
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> eyre::Result<()> {
         let from = state
             .get_transaction_context()
@@ -99,7 +99,7 @@ impl ActionHandler for FeeAssetChange {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> eyre::Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/fees/mod.rs b/crates/astria-sequencer/src/fees/mod.rs
index 2e3547e7fb..c86bc7dc3f 100644
--- a/crates/astria-sequencer/src/fees/mod.rs
+++ b/crates/astria-sequencer/src/fees/mod.rs
@@ -82,7 +82,7 @@ impl Fee {
 
 #[async_trait::async_trait]
 impl FeeHandler for Transfer {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_transfer_fees()
@@ -100,7 +100,7 @@ impl FeeHandler for Transfer {
 
 #[async_trait::async_trait]
 impl FeeHandler for BridgeLock {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_bridge_lock_fees()
@@ -118,7 +118,7 @@ impl FeeHandler for BridgeLock {
 
 #[async_trait::async_trait]
 impl FeeHandler for BridgeSudoChange {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_bridge_sudo_change_fees()
@@ -136,7 +136,7 @@ impl FeeHandler for BridgeSudoChange {
 
 #[async_trait::async_trait]
 impl FeeHandler for BridgeUnlock {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_bridge_unlock_fees()
@@ -154,7 +154,7 @@ impl FeeHandler for BridgeUnlock {
 
 #[async_trait::async_trait]
 impl FeeHandler for InitBridgeAccount {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_init_bridge_account_fees()
@@ -172,7 +172,7 @@ impl FeeHandler for InitBridgeAccount {
 
 #[async_trait::async_trait]
 impl FeeHandler for transaction::v1::action::Ics20Withdrawal {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_ics20_withdrawal_fees()
@@ -190,7 +190,7 @@ impl FeeHandler for transaction::v1::action::Ics20Withdrawal {
 
 #[async_trait::async_trait]
 impl FeeHandler for RollupDataSubmission {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_rollup_data_submission_fees()
@@ -209,7 +209,7 @@ impl FeeHandler for RollupDataSubmission {
 
 #[async_trait::async_trait]
 impl FeeHandler for ValidatorUpdate {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_validator_update_fees()
@@ -226,7 +226,7 @@ impl FeeHandler for ValidatorUpdate {
 
 #[async_trait::async_trait]
 impl FeeHandler for SudoAddressChange {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_sudo_address_change_fees()
@@ -243,7 +243,7 @@ impl FeeHandler for SudoAddressChange {
 
 #[async_trait::async_trait]
 impl FeeHandler for FeeChange {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_fee_change_fees()
@@ -260,7 +260,7 @@ impl FeeHandler for FeeChange {
 
 #[async_trait::async_trait]
 impl FeeHandler for IbcSudoChange {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_ibc_sudo_change_fees()
@@ -277,7 +277,7 @@ impl FeeHandler for IbcSudoChange {
 
 #[async_trait::async_trait]
 impl FeeHandler for IbcRelayerChange {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_ibc_relayer_change_fees()
@@ -294,7 +294,7 @@ impl FeeHandler for IbcRelayerChange {
 
 #[async_trait::async_trait]
 impl FeeHandler for FeeAssetChange {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_fee_asset_change_fees()
@@ -311,7 +311,7 @@ impl FeeHandler for FeeAssetChange {
 
 #[async_trait::async_trait]
 impl FeeHandler for IbcRelay {
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_ibc_relay_fees()
@@ -326,7 +326,7 @@ impl FeeHandler for IbcRelay {
     }
 }
 
-#[instrument(skip_all, err(level = Level::WARN))]
+#[instrument(skip_all, err(level = Level::DEBUG))]
 async fn check_and_pay_fees<S: StateWrite, T: FeeHandler + Protobuf>(
     act: &T,
     base: u128,
diff --git a/crates/astria-sequencer/src/fees/query.rs b/crates/astria-sequencer/src/fees/query.rs
index 4b90883089..9587c6f963 100644
--- a/crates/astria-sequencer/src/fees/query.rs
+++ b/crates/astria-sequencer/src/fees/query.rs
@@ -48,6 +48,7 @@ use tokio::{
 use tracing::{
     instrument,
     warn,
+    Level,
 };
 
 use super::{
@@ -219,7 +220,7 @@ pub(crate) async fn transaction_fee_request(
     }
 }
 
-#[instrument(skip_all, err)]
+#[instrument(skip_all, err(level = Level::INFO))]
 pub(crate) async fn get_fees_for_transaction<S: StateRead>(
     tx: &TransactionBody,
     state: &S,
diff --git a/crates/astria-sequencer/src/fees/state_ext.rs b/crates/astria-sequencer/src/fees/state_ext.rs
index 021d3a8884..6ad70d25ca 100644
--- a/crates/astria-sequencer/src/fees/state_ext.rs
+++ b/crates/astria-sequencer/src/fees/state_ext.rs
@@ -46,7 +46,10 @@ use tendermint::abci::{
     Event,
     EventAttributeIndexExt as _,
 };
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use super::{
     storage::{
@@ -99,7 +102,7 @@ pub(crate) trait StateReadExt: StateRead {
         self.object_get(keys::BLOCK).unwrap_or_default()
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_transfer_fees(&self) -> Result<Option<TransferFeeComponents>> {
         let bytes = self
             .get_raw(keys::TRANSFER)
@@ -117,7 +120,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_rollup_data_submission_fees(
         &self,
     ) -> Result<Option<RollupDataSubmissionFeeComponents>> {
@@ -137,7 +140,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_ics20_withdrawal_fees(&self) -> Result<Option<Ics20WithdrawalFeeComponents>> {
         let bytes = self
             .get_raw(keys::ICS20_WITHDRAWAL)
@@ -155,7 +158,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_init_bridge_account_fees(&self) -> Result<Option<InitBridgeAccountFeeComponents>> {
         let bytes = self
             .get_raw(keys::INIT_BRIDGE_ACCOUNT)
@@ -173,7 +176,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_bridge_lock_fees(&self) -> Result<Option<BridgeLockFeeComponents>> {
         let bytes = self
             .get_raw(keys::BRIDGE_LOCK)
@@ -191,7 +194,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_bridge_unlock_fees(&self) -> Result<Option<BridgeUnlockFeeComponents>> {
         let bytes = self
             .get_raw(keys::BRIDGE_UNLOCK)
@@ -209,7 +212,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_bridge_sudo_change_fees(&self) -> Result<Option<BridgeSudoChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::BRIDGE_SUDO_CHANGE)
@@ -227,7 +230,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_ibc_relay_fees(&self) -> Result<Option<IbcRelayFeeComponents>> {
         let bytes = self
             .get_raw(keys::IBC_RELAY)
@@ -245,7 +248,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_validator_update_fees(&self) -> Result<Option<ValidatorUpdateFeeComponents>> {
         let bytes = self
             .get_raw(keys::VALIDATOR_UPDATE)
@@ -263,7 +266,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_fee_asset_change_fees(&self) -> Result<Option<FeeAssetChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::FEE_ASSET_CHANGE)
@@ -281,7 +284,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_fee_change_fees(&self) -> Result<Option<FeeChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::FEE_CHANGE)
@@ -299,7 +302,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_ibc_relayer_change_fees(&self) -> Result<Option<IbcRelayerChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::IBC_RELAYER_CHANGE)
@@ -317,7 +320,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_sudo_address_change_fees(&self) -> Result<Option<SudoAddressChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::SUDO_ADDRESS_CHANGE)
@@ -335,7 +338,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_ibc_sudo_change_fees(&self) -> Result<Option<IbcSudoChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::IBC_SUDO_CHANGE)
@@ -353,7 +356,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn is_allowed_fee_asset<'a, TAsset>(&self, asset: &'a TAsset) -> Result<bool>
     where
         TAsset: Sync,
@@ -380,7 +383,7 @@ impl<T: ?Sized + StateRead> StateReadExt for T {}
 #[async_trait]
 pub(crate) trait StateWriteExt: StateWrite {
     /// Constructs and adds `Fee` object to the block fees vec.
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn add_fee_to_block_fees<'a, TAsset, T: FeeHandler + Protobuf>(
         &mut self,
         asset: &'a TAsset,
@@ -415,7 +418,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_transfer_fees(&mut self, fees: TransferFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::TransferFeeComponentsStorage::from(fees))
             .serialize()
@@ -424,7 +427,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_rollup_data_submission_fees(
         &mut self,
         fees: RollupDataSubmissionFeeComponents,
@@ -438,7 +441,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_ics20_withdrawal_fees(&mut self, fees: Ics20WithdrawalFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::Ics20WithdrawalFeeComponentsStorage::from(fees))
             .serialize()
@@ -447,7 +450,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_init_bridge_account_fees(&mut self, fees: InitBridgeAccountFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::InitBridgeAccountFeeComponentsStorage::from(fees))
             .serialize()
@@ -456,7 +459,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_bridge_lock_fees(&mut self, fees: BridgeLockFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::BridgeLockFeeComponentsStorage::from(fees))
             .serialize()
@@ -465,7 +468,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_bridge_unlock_fees(&mut self, fees: BridgeUnlockFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::BridgeUnlockFeeComponentsStorage::from(fees))
             .serialize()
@@ -474,7 +477,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_bridge_sudo_change_fees(&mut self, fees: BridgeSudoChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::BridgeSudoChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -483,7 +486,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_ibc_relay_fees(&mut self, fees: IbcRelayFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::IbcRelayFeeComponentsStorage::from(fees))
             .serialize()
@@ -492,7 +495,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_validator_update_fees(&mut self, fees: ValidatorUpdateFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::ValidatorUpdateFeeComponentsStorage::from(fees))
             .serialize()
@@ -501,7 +504,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_fee_asset_change_fees(&mut self, fees: FeeAssetChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::FeeAssetChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -510,7 +513,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_fee_change_fees(&mut self, fees: FeeChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::FeeChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -519,7 +522,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_ibc_relayer_change_fees(&mut self, fees: IbcRelayerChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::IbcRelayerChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -528,7 +531,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_sudo_address_change_fees(&mut self, fees: SudoAddressChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::SudoAddressChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -537,7 +540,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_ibc_sudo_change_fees(&mut self, fees: IbcSudoChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::IbcSudoChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -554,7 +557,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         self.delete(keys::allowed_asset(asset));
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     fn put_allowed_fee_asset<'a, TAsset>(&mut self, asset: &'a TAsset) -> Result<()>
     where
         &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
diff --git a/crates/astria-sequencer/src/grpc/state_ext.rs b/crates/astria-sequencer/src/grpc/state_ext.rs
index 561a7dbd85..05f53352fc 100644
--- a/crates/astria-sequencer/src/grpc/state_ext.rs
+++ b/crates/astria-sequencer/src/grpc/state_ext.rs
@@ -20,7 +20,10 @@ use cnidarium::{
     StateRead,
     StateWrite,
 };
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use super::storage::{
     self,
@@ -30,7 +33,7 @@ use crate::storage::StoredValue;
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all, fields(%height), err)]
+    #[instrument(skip_all, fields(%height), err(level = Level::DEBUG))]
     async fn get_block_hash_by_height(&self, height: u64) -> Result<[u8; 32]> {
         let Some(bytes) = self
             .nonverifiable_get_raw(keys::block_hash_by_height(height).as_bytes())
@@ -45,7 +48,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid block hash bytes")
     }
 
-    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err)]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::DEBUG))]
     async fn get_sequencer_block_header_by_hash(
         &self,
         hash: &[u8; 32],
@@ -65,7 +68,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid sequencer block header bytes")
     }
 
-    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err)]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::DEBUG))]
     async fn get_rollup_ids_by_block_hash(&self, hash: &[u8; 32]) -> Result<Vec<RollupId>> {
         let Some(bytes) = self
             .nonverifiable_get_raw(keys::rollup_ids_by_hash(hash).as_bytes())
@@ -80,7 +83,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid rollup ids bytes")
     }
 
-    #[instrument(skip_all, fields(%height), err)]
+    #[instrument(skip_all, fields(%height), err(level = Level::DEBUG))]
     async fn get_sequencer_block_by_height(&self, height: u64) -> Result<SequencerBlock> {
         let hash = self
             .get_block_hash_by_height(height)
@@ -91,7 +94,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("failed to get sequencer block by hash")
     }
 
-    #[instrument(skip_all, fields(hash = %hex::encode(hash), %rollup_id), err)]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash), %rollup_id), err(level = Level::DEBUG))]
     async fn get_rollup_data(
         &self,
         hash: &[u8; 32],
@@ -116,7 +119,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid rollup transactions bytes")
     }
 
-    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err)]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::DEBUG))]
     async fn get_rollup_transactions_proof_by_block_hash(
         &self,
         hash: &[u8; 32],
@@ -134,7 +137,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid rollup transactions proof bytes")
     }
 
-    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err)]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::DEBUG))]
     async fn get_rollup_ids_proof_by_block_hash(&self, hash: &[u8; 32]) -> Result<merkle::Proof> {
         let Some(bytes) = self
             .nonverifiable_get_raw(keys::rollup_ids_proof_by_hash(hash).as_bytes())
@@ -180,7 +183,7 @@ pub(crate) trait StateWriteExt: StateWrite {
     }
 }
 
-#[instrument(skip_all, fields(hash = %hex::encode(hash)), err)]
+#[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::DEBUG))]
 async fn get_sequencer_block_by_hash<S: StateRead + ?Sized>(
     state: &S,
     hash: &[u8; 32],
diff --git a/crates/astria-sequencer/src/ibc/component.rs b/crates/astria-sequencer/src/ibc/component.rs
index b3a748f69f..8a17b30c61 100644
--- a/crates/astria-sequencer/src/ibc/component.rs
+++ b/crates/astria-sequencer/src/ibc/component.rs
@@ -13,7 +13,10 @@ use tendermint::abci::request::{
     BeginBlock,
     EndBlock,
 };
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     component::Component,
@@ -53,7 +56,7 @@ impl Component for IbcComponent {
         Ok(())
     }
 
-    #[instrument(name = "IbcComponent::begin_block", skip_all, err)]
+    #[instrument(name = "IbcComponent::begin_block", skip_all, err(level = Level::WARN))]
     async fn begin_block<S: StateWriteExt + 'static>(
         state: &mut Arc<S>,
         begin_block: &BeginBlock,
@@ -62,7 +65,7 @@ impl Component for IbcComponent {
         Ok(())
     }
 
-    #[instrument(name = "IbcComponent::end_block", skip_all, err)]
+    #[instrument(name = "IbcComponent::end_block", skip_all, er(level = Level::WARN))]
     async fn end_block<S: StateWriteExt + 'static>(
         state: &mut Arc<S>,
         end_block: &EndBlock,
diff --git a/crates/astria-sequencer/src/ibc/ibc_relayer_change.rs b/crates/astria-sequencer/src/ibc/ibc_relayer_change.rs
index bd9936cdfa..dd87409268 100644
--- a/crates/astria-sequencer/src/ibc/ibc_relayer_change.rs
+++ b/crates/astria-sequencer/src/ibc/ibc_relayer_change.rs
@@ -27,7 +27,7 @@ impl ActionHandler for IbcRelayerChange {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/ibc/ics20_transfer.rs b/crates/astria-sequencer/src/ibc/ics20_transfer.rs
index 4cb73b2afe..377eb31cd8 100644
--- a/crates/astria-sequencer/src/ibc/ics20_transfer.rs
+++ b/crates/astria-sequencer/src/ibc/ics20_transfer.rs
@@ -71,7 +71,10 @@ use penumbra_ibc::component::app_handler::{
 };
 use penumbra_proto::penumbra::core::component::ibc::v1::FungibleTokenPacketData;
 use tokio::try_join;
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     accounts::StateWriteExt as _,
@@ -302,7 +305,7 @@ impl AppHandlerCheck for Ics20Transfer {
     }
 }
 
-#[instrument(skip_all, fields(%source_port, %source_channel), err)]
+#[instrument(skip_all, fields(%source_port, %source_channel), err(level = Level::INFO))]
 async fn refund_tokens_check<S: StateRead>(
     state: S,
     data: &[u8],
@@ -355,7 +358,7 @@ impl AppHandlerExecute for Ics20Transfer {
 
     async fn chan_close_init_execute<S: StateWrite>(_: S, _: &MsgChannelCloseInit) {}
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn recv_packet_execute<S: StateWrite>(
         mut state: S,
         msg: &MsgRecvPacket,
@@ -381,7 +384,7 @@ impl AppHandlerExecute for Ics20Transfer {
             .context("failed to write acknowledgement")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn timeout_packet_execute<S: StateWrite>(
         mut state: S,
         msg: &MsgTimeout,
@@ -391,7 +394,7 @@ impl AppHandlerExecute for Ics20Transfer {
         })
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn acknowledge_packet_execute<S: StateWrite>(
         mut state: S,
         msg: &MsgAcknowledgement,
@@ -583,7 +586,7 @@ fn does_failed_transfer_come_from_rollup(
     serde_json::from_str::<Ics20WithdrawalFromRollup>(&packet_data.memo).ok()
 }
 
-#[instrument(skip_all, fields(%recipient, %asset, amount), err)]
+#[instrument(skip_all, fields(%recipient, %asset, amount), err(level = Level::INFO))]
 async fn refund_tokens_to_sequencer_address<S: StateWrite>(
     mut state: S,
     recipient: &Address,
@@ -606,7 +609,7 @@ async fn refund_tokens_to_sequencer_address<S: StateWrite>(
     Ok(())
 }
 
-#[instrument(skip_all, fields(input), err)]
+#[instrument(skip_all, fields(input), err(level = Level::DEBUG))]
 async fn parse_asset<S: StateRead>(state: S, input: &str) -> Result<denom::TracePrefixed> {
     let asset = match input
         .parse::<Denom>()
@@ -624,7 +627,7 @@ async fn parse_asset<S: StateRead>(state: S, input: &str) -> Result<denom::Trace
     Ok(asset)
 }
 
-#[instrument(skip_all, fields(input), err)]
+#[instrument(skip_all, fields(input), err(level = Level::DEBUG))]
 async fn parse_address_on_sequencer<S: StateRead>(state: &S, input: &str) -> Result<Address> {
     use futures::TryFutureExt as _;
     let (base_prefix, compat_prefix) = match try_join!(
@@ -670,7 +673,7 @@ async fn parse_address_on_sequencer<S: StateRead>(state: &S, input: &str) -> Res
 
 /// Emits a deposit event signaling to the rollup that funds
 /// were added to `bridge_address`.
-#[instrument(skip_all, fields(%bridge_address, %asset, amount, memo), err)]
+#[instrument(skip_all, fields(%bridge_address, %asset, amount, memo), err(level = Level::INFO))]
 async fn emit_bridge_lock_deposit<S: StateWrite>(
     mut state: S,
     bridge_address: Address,
@@ -701,7 +704,7 @@ async fn emit_bridge_lock_deposit<S: StateWrite>(
     .await
 }
 
-#[instrument(skip_all, fields(%bridge_address, destination_chain_address, %asset, amount), err)]
+#[instrument(skip_all, fields(%bridge_address, destination_chain_address, %asset, amount), err(level = Level::INFO))]
 async fn emit_deposit<S: StateWrite>(
     mut state: S,
     bridge_address: &Address,
diff --git a/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs b/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs
index 4ccbb4d15d..55b6b35150 100644
--- a/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs
+++ b/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs
@@ -60,7 +60,7 @@ use crate::{
     transaction::StateReadExt as _,
 };
 
-#[instrument(skip_all, err)]
+#[instrument(skip_all, err(level = Level::DEBUG))]
 async fn create_ibc_packet_from_withdrawal<S: StateRead>(
     withdrawal: &action::Ics20Withdrawal,
     state: S,
@@ -110,7 +110,7 @@ async fn create_ibc_packet_from_withdrawal<S: StateRead>(
 /// 1. Errors reading from DB
 /// 2. `action.bridge_address` is set, but `from` is not the withdrawer address.
 /// 3. `action.bridge_address` is unset, but `from` is a bridge account.
-#[instrument(skip_all, fields(from_address = %hex::encode(from)), err)]
+#[instrument(skip_all, fields(from_address = %hex::encode(from)), err(level = Level::DEBUG))]
 async fn establish_withdrawal_target<'a, S: StateRead>(
     action: &'a action::Ics20Withdrawal,
     state: &S,
@@ -150,7 +150,7 @@ async fn establish_withdrawal_target<'a, S: StateRead>(
 #[async_trait::async_trait]
 impl ActionHandler for action::Ics20Withdrawal {
     // TODO(https://github.com/astriaorg/astria/issues/1430): move checks to the `Ics20Withdrawal` parsing.
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_stateless(&self) -> Result<()> {
         ensure!(self.timeout_time() != 0, "timeout time must be non-zero",);
         ensure!(self.amount() > 0, "amount must be greater than zero",);
@@ -186,7 +186,7 @@ impl ActionHandler for action::Ics20Withdrawal {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/ibc/state_ext.rs b/crates/astria-sequencer/src/ibc/state_ext.rs
index 3460f21451..95f93bda21 100644
--- a/crates/astria-sequencer/src/ibc/state_ext.rs
+++ b/crates/astria-sequencer/src/ibc/state_ext.rs
@@ -25,6 +25,7 @@ use ibc_types::core::channel::ChannelId;
 use tracing::{
     debug,
     instrument,
+    Level,
 };
 
 use super::storage::{
@@ -38,7 +39,7 @@ use crate::{
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all, fields(%channel, %asset), err)]
+    #[instrument(skip_all, fields(%channel, %asset), err(level = Level::DEBUG))]
     async fn get_ibc_channel_balance<'a, TAsset>(
         &self,
         channel: &ChannelId,
@@ -62,7 +63,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid ibc channel balance bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn get_ibc_sudo_address(&self) -> Result<[u8; ADDRESS_LEN]> {
         let Some(bytes) = self
             .get_raw(keys::IBC_SUDO)
@@ -78,7 +79,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid ibc sudo address bytes")
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn is_ibc_relayer<T: AddressBytes>(&self, address: T) -> Result<bool> {
         Ok(self
             .get_raw(&keys::ibc_relayer(&address))
@@ -93,7 +94,7 @@ impl<T: StateRead + ?Sized> StateReadExt for T {}
 
 #[async_trait]
 pub(crate) trait StateWriteExt: StateWrite {
-    #[instrument(skip_all, fields(%channel, %asset, balance), err)]
+    #[instrument(skip_all, fields(%channel, %asset, balance), err(level = Level::DEBUG))]
     fn put_ibc_channel_balance<'a, TAsset>(
         &mut self,
         channel: &ChannelId,
@@ -111,7 +112,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, fields(%channel, %asset, amount), err)]
+    #[instrument(skip_all, fields(%channel, %asset, amount), err(level = Level::DEBUG))]
     async fn decrease_ibc_channel_balance<'a, TAsset>(
         &mut self,
         channel: &ChannelId,
diff --git a/crates/astria-sequencer/src/mempool/mempool_state.rs b/crates/astria-sequencer/src/mempool/mempool_state.rs
index 88e8ccebc7..4030378568 100644
--- a/crates/astria-sequencer/src/mempool/mempool_state.rs
+++ b/crates/astria-sequencer/src/mempool/mempool_state.rs
@@ -3,14 +3,17 @@ use std::collections::HashMap;
 use astria_core::primitive::v1::asset;
 use astria_eyre::eyre::Result;
 use cnidarium::StateRead;
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::accounts::{
     AddressBytes,
     StateReadExt as _,
 };
 
-#[instrument(skip_all, fields(address = %address.display_address()), err)]
+#[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::DEBUG))]
 pub(crate) async fn get_account_balances<S: StateRead, T: AddressBytes>(
     state: S,
     address: &T,
diff --git a/crates/astria-sequencer/src/mempool/mod.rs b/crates/astria-sequencer/src/mempool/mod.rs
index 352448d648..ecc76f4118 100644
--- a/crates/astria-sequencer/src/mempool/mod.rs
+++ b/crates/astria-sequencer/src/mempool/mod.rs
@@ -29,6 +29,7 @@ use tokio::{
 use tracing::{
     error,
     instrument,
+    Level,
 };
 pub(crate) use transactions_container::InsertionError;
 use transactions_container::{
@@ -203,7 +204,7 @@ impl Mempool {
 
     /// Inserts a transaction into the mempool and does not allow for transaction replacement.
     /// Will return the reason for insertion failure if failure occurs.
-    #[instrument(skip_all, fields(tx_hash = %tx.id(), current_account_nonce), err)]
+    #[instrument(skip_all, fields(tx_hash = %tx.id(), current_account_nonce), err(level = Level::DEBUG))]
     pub(crate) async fn insert(
         &self,
         tx: Arc<Transaction>,
@@ -291,7 +292,7 @@ impl Mempool {
     /// Returns a copy of all transactions and their hashes ready for execution, sorted first by the
     /// difference between a transaction and the account's current nonce and then by the time that
     /// the transaction was first seen by the appside mempool.
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     pub(crate) async fn builder_queue<S: accounts::StateReadExt>(
         &self,
         state: &S,
diff --git a/crates/astria-sequencer/src/mempool/transactions_container.rs b/crates/astria-sequencer/src/mempool/transactions_container.rs
index 647396fa54..0a195376ec 100644
--- a/crates/astria-sequencer/src/mempool/transactions_container.rs
+++ b/crates/astria-sequencer/src/mempool/transactions_container.rs
@@ -29,6 +29,7 @@ use tokio::time::{
 use tracing::{
     error,
     instrument,
+    Level,
 };
 
 use super::RemovalReason;
@@ -774,7 +775,7 @@ impl PendingTransactions {
 
     /// Returns a copy of transactions and their hashes sorted by nonce difference and then time
     /// first seen.
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     pub(super) async fn builder_queue<S: accounts::StateReadExt>(
         &self,
         state: &S,
diff --git a/crates/astria-sequencer/src/service/consensus.rs b/crates/astria-sequencer/src/service/consensus.rs
index 9fec22fa0c..d34881b120 100644
--- a/crates/astria-sequencer/src/service/consensus.rs
+++ b/crates/astria-sequencer/src/service/consensus.rs
@@ -19,6 +19,7 @@ use tracing::{
     instrument,
     warn,
     Instrument,
+    Level,
 };
 
 use crate::app::App;
@@ -154,7 +155,7 @@ impl Consensus {
         })
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn handle_prepare_proposal(
         &mut self,
         prepare_proposal: request::PrepareProposal,
@@ -164,7 +165,7 @@ impl Consensus {
             .await
     }
 
-    #[instrument(skip_all, err)]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn handle_process_proposal(
         &mut self,
         process_proposal: request::ProcessProposal,
diff --git a/crates/astria-sequencer/src/transaction/checks.rs b/crates/astria-sequencer/src/transaction/checks.rs
index 450bfb543e..7ff27db732 100644
--- a/crates/astria-sequencer/src/transaction/checks.rs
+++ b/crates/astria-sequencer/src/transaction/checks.rs
@@ -15,7 +15,10 @@ use astria_eyre::eyre::{
     WrapErr as _,
 };
 use cnidarium::StateRead;
-use tracing::instrument;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     accounts::StateReadExt as _,
@@ -24,7 +27,7 @@ use crate::{
     fees::query::get_fees_for_transaction,
 };
 
-#[instrument(skip_all, fields(tx_hash = %tx.id()), err)]
+#[instrument(skip_all, fields(tx_hash = %tx.id()), err(level = Level::INFO))]
 pub(crate) async fn check_chain_id_mempool<S: StateRead>(
     tx: &Transaction,
     state: &S,
@@ -39,7 +42,7 @@ pub(crate) async fn check_chain_id_mempool<S: StateRead>(
 
 // Checks that the account has enough balance to cover the total fees and transferred values
 // for all actions in the transaction.
-#[instrument(skip_all, fields(tx_hash = %tx.id()), err)]
+#[instrument(skip_all, fields(tx_hash = %tx.id()), err(level = Level::INFO))]
 pub(crate) async fn check_balance_for_total_fees_and_transfers<S: StateRead>(
     tx: &Transaction,
     state: &S,
@@ -64,7 +67,7 @@ pub(crate) async fn check_balance_for_total_fees_and_transfers<S: StateRead>(
 
 // Returns the total cost of the transaction (fees and transferred values for all actions in the
 // transaction).
-#[instrument(skip_all, fields(tx_hash = %tx.id()), err)]
+#[instrument(skip_all, fields(tx_hash = %tx.id()), err(level = Level::DEBUG))]
 pub(crate) async fn get_total_transaction_cost<S: StateRead>(
     tx: &Transaction,
     state: &S,
diff --git a/crates/astria-sequencer/src/transaction/mod.rs b/crates/astria-sequencer/src/transaction/mod.rs
index 547037e7c8..21b911d839 100644
--- a/crates/astria-sequencer/src/transaction/mod.rs
+++ b/crates/astria-sequencer/src/transaction/mod.rs
@@ -87,7 +87,7 @@ impl std::error::Error for InvalidNonce {}
 
 #[async_trait::async_trait]
 impl ActionHandler for Transaction {
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_stateless(&self) -> Result<()> {
         ensure!(!self.actions().is_empty(), "must have at least one action");
 
@@ -160,10 +160,7 @@ impl ActionHandler for Transaction {
         Ok(())
     }
 
-    // FIXME (https://github.com/astriaorg/astria/issues/1584): because most lines come from delegating (and error wrapping) to the
-    // individual actions. This could be tidied up by implementing `ActionHandler for Action`
-    // and letting it delegate.
-    #[instrument(skip_all, err(level = Level::WARN))]
+    #[instrument(skip_all, err(level = Level::INFO))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         // Add the current signed transaction into the ephemeral state in case
         // downstream actions require access to it.

From 09971768518018978420b442171544e6fb23fd7d Mon Sep 17 00:00:00 2001
From: ethanoroshiba <ethan@astria.org>
Date: Wed, 4 Dec 2024 09:11:25 -0600
Subject: [PATCH 3/5] more fine-toother run through logging levels

---
 .../astria-sequencer/src/accounts/action.rs   |  2 +-
 crates/astria-sequencer/src/accounts/query.rs |  4 +-
 .../src/accounts/state_ext.rs                 |  8 +--
 .../astria-sequencer/src/address/state_ext.rs |  4 +-
 crates/astria-sequencer/src/app/mod.rs        | 12 ++--
 crates/astria-sequencer/src/app/state_ext.rs  | 10 +--
 .../astria-sequencer/src/assets/state_ext.rs  |  6 +-
 .../astria-sequencer/src/authority/action.rs  |  6 +-
 .../src/authority/state_ext.rs                |  6 +-
 .../src/bridge/bridge_lock_action.rs          |  2 +-
 .../src/bridge/bridge_sudo_change_action.rs   |  2 +-
 .../src/bridge/bridge_unlock_action.rs        |  4 +-
 .../src/bridge/init_bridge_account_action.rs  |  2 +-
 .../astria-sequencer/src/bridge/state_ext.rs  | 14 ++---
 crates/astria-sequencer/src/fees/action.rs    |  4 +-
 crates/astria-sequencer/src/fees/mod.rs       | 28 ++++-----
 crates/astria-sequencer/src/fees/query.rs     |  2 +-
 crates/astria-sequencer/src/fees/state_ext.rs | 63 ++++++++++---------
 crates/astria-sequencer/src/grpc/state_ext.rs | 12 ++--
 .../src/ibc/ibc_relayer_change.rs             |  2 +-
 .../src/ibc/ics20_transfer.rs                 | 14 ++---
 .../src/ibc/ics20_withdrawal.rs               |  4 +-
 crates/astria-sequencer/src/ibc/state_ext.rs  |  8 +--
 .../src/transaction/checks.rs                 |  4 +-
 .../astria-sequencer/src/transaction/mod.rs   |  4 +-
 25 files changed, 114 insertions(+), 113 deletions(-)

diff --git a/crates/astria-sequencer/src/accounts/action.rs b/crates/astria-sequencer/src/accounts/action.rs
index 9096ed7489..ef93505567 100644
--- a/crates/astria-sequencer/src/accounts/action.rs
+++ b/crates/astria-sequencer/src/accounts/action.rs
@@ -31,7 +31,7 @@ impl ActionHandler for Transfer {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/accounts/query.rs b/crates/astria-sequencer/src/accounts/query.rs
index c1436da6b4..af7d320228 100644
--- a/crates/astria-sequencer/src/accounts/query.rs
+++ b/crates/astria-sequencer/src/accounts/query.rs
@@ -51,7 +51,7 @@ async fn ibc_to_trace<S: StateRead>(
         .ok_or_eyre("asset not found when user has balance of it; this is a bug")
 }
 
-#[instrument(skip_all, fields(%address), err(level = Level::INFO))]
+#[instrument(skip_all, fields(%address), err(level = Level::DEBUG))]
 async fn get_trace_prefixed_account_balances<S: StateRead>(
     state: &S,
     address: &Address,
@@ -156,7 +156,7 @@ pub(crate) async fn nonce_request(
     }
 }
 
-#[instrument(skip_all, fields(%height), err(level = Level::INFO))]
+#[instrument(skip_all, fields(%height), err(level = Level::DEBUG))]
 async fn get_snapshot_and_height(storage: &Storage, height: Height) -> Result<(Snapshot, Height)> {
     let snapshot = match height.value() {
         0 => storage.latest_snapshot(),
diff --git a/crates/astria-sequencer/src/accounts/state_ext.rs b/crates/astria-sequencer/src/accounts/state_ext.rs
index 75bad7f137..22e9fea37f 100644
--- a/crates/astria-sequencer/src/accounts/state_ext.rs
+++ b/crates/astria-sequencer/src/accounts/state_ext.rs
@@ -144,7 +144,7 @@ pub(crate) trait StateReadExt: StateRead + crate::assets::StateReadExt {
         }
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address(), %asset), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(address = %address.display_address(), %asset), err(level = Level::WARN))]
     async fn get_account_balance<'a, TAddress, TAsset>(
         &self,
         address: &TAddress,
@@ -189,7 +189,7 @@ impl<T: StateRead + ?Sized> StateReadExt for T {}
 
 #[async_trait]
 pub(crate) trait StateWriteExt: StateWrite {
-    #[instrument(skip_all, fields(address = %address.display_address(), %asset, balance), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(address = %address.display_address(), %asset, balance), err(level = Level::WARN))]
     fn put_account_balance<'a, TAddress, TAsset>(
         &mut self,
         address: &TAddress,
@@ -208,7 +208,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address(), nonce), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(address = %address.display_address(), nonce), err(level = Level::WARN))]
     fn put_account_nonce<T: AddressBytes>(&mut self, address: &T, nonce: u32) -> Result<()> {
         let bytes = StoredValue::from(storage::Nonce::from(nonce))
             .serialize()
@@ -217,7 +217,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address(), %asset, amount), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(address = %address.display_address(), %asset, amount), err(level = Level::WARN))]
     async fn increase_balance<'a, TAddress, TAsset>(
         &mut self,
         address: &TAddress,
diff --git a/crates/astria-sequencer/src/address/state_ext.rs b/crates/astria-sequencer/src/address/state_ext.rs
index 0721e41e9b..b217e80a56 100644
--- a/crates/astria-sequencer/src/address/state_ext.rs
+++ b/crates/astria-sequencer/src/address/state_ext.rs
@@ -59,7 +59,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("failed to construct address from byte slice and state-provided base prefix")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_base_prefix(&self) -> Result<String> {
         let Some(bytes) = self
             .get_raw(keys::BASE_PREFIX)
@@ -74,7 +74,7 @@ pub(crate) trait StateReadExt: StateRead {
             .context("invalid base prefix bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_ibc_compat_prefix(&self) -> Result<String> {
         let Some(bytes) = self
             .get_raw(keys::IBC_COMPAT_PREFIX)
diff --git a/crates/astria-sequencer/src/app/mod.rs b/crates/astria-sequencer/src/app/mod.rs
index 3c696db8d1..4c48f8659e 100644
--- a/crates/astria-sequencer/src/app/mod.rs
+++ b/crates/astria-sequencer/src/app/mod.rs
@@ -824,7 +824,7 @@ impl App {
     ///
     /// this *must* be called anytime before a block's txs are executed, whether it's
     /// during the proposal phase, or finalize_block phase.
-    #[instrument(name = "App::pre_execute_transactions", skip_all, err(level = Level::DEBUG))]
+    #[instrument(name = "App::pre_execute_transactions", skip_all, err(level = Level::WARN))]
     async fn pre_execute_transactions(&mut self, block_data: BlockData) -> Result<()> {
         let chain_id = self
             .state
@@ -879,7 +879,7 @@ impl App {
     /// `SequencerBlock`.
     ///
     /// this must be called after a block's transactions are executed.
-    #[instrument(name = "App::post_execute_transactions", skip_all, err(level = Level::DEBUG))]
+    #[instrument(name = "App::post_execute_transactions", skip_all, err(level = Level::WARN))]
     async fn post_execute_transactions(
         &mut self,
         block_hash: Hash,
@@ -1077,7 +1077,7 @@ impl App {
         Ok(finalize_block)
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn prepare_commit(&mut self, storage: Storage) -> Result<AppHash> {
         // extract the state we've built up to so we can prepare it as a `StagedWriteBatch`.
         let dummy_state = StateDelta::new(storage.latest_snapshot());
@@ -1114,7 +1114,7 @@ impl App {
         Ok(app_hash)
     }
 
-    #[instrument(name = "App::begin_block", skip_all, err(level = Level::DEBUG))]
+    #[instrument(name = "App::begin_block", skip_all, err(level = Level::WARN))]
     async fn begin_block(
         &mut self,
         begin_block: &abci::request::BeginBlock,
@@ -1150,7 +1150,7 @@ impl App {
     }
 
     /// Executes a signed transaction.
-    #[instrument(name = "App::execute_transaction", skip_all, err(level = Level::INFO))]
+    #[instrument(name = "App::execute_transaction", skip_all, err(level = Level::DEBUG))]
     async fn execute_transaction(&mut self, signed_tx: Arc<Transaction>) -> Result<Vec<Event>> {
         signed_tx
             .check_stateless()
@@ -1178,7 +1178,7 @@ impl App {
         Ok(state_tx.apply().1)
     }
 
-    #[instrument(name = "App::end_block", skip_all, err(level = Level::DEBUG))]
+    #[instrument(name = "App::end_block", skip_all, err(level = Level::WARN))]
     async fn end_block(
         &mut self,
         height: u64,
diff --git a/crates/astria-sequencer/src/app/state_ext.rs b/crates/astria-sequencer/src/app/state_ext.rs
index 8841fff2a4..d1dfb5e07a 100644
--- a/crates/astria-sequencer/src/app/state_ext.rs
+++ b/crates/astria-sequencer/src/app/state_ext.rs
@@ -25,7 +25,7 @@ use crate::storage::StoredValue;
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_chain_id(&self) -> Result<tendermint::chain::Id> {
         let Some(bytes) = self
             .get_raw(keys::CHAIN_ID)
@@ -40,7 +40,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid chain id bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_revision_number(&self) -> Result<u64> {
         let Some(bytes) = self
             .get_raw(keys::REVISION_NUMBER)
@@ -55,7 +55,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid revision number bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_block_height(&self) -> Result<u64> {
         let Some(bytes) = self
             .get_raw(keys::BLOCK_HEIGHT)
@@ -70,7 +70,7 @@ pub(crate) trait StateReadExt: StateRead {
             .context("invalid block height bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_block_timestamp(&self) -> Result<Time> {
         let Some(bytes) = self
             .get_raw(keys::BLOCK_TIMESTAMP)
@@ -85,7 +85,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid block timestamp bytes")
     }
 
-    #[instrument(skip_all, fields(%height), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(%height), err(level = Level::WARN))]
     async fn get_storage_version_by_height(&self, height: u64) -> Result<u64> {
         use astria_eyre::eyre::WrapErr as _;
 
diff --git a/crates/astria-sequencer/src/assets/state_ext.rs b/crates/astria-sequencer/src/assets/state_ext.rs
index f264c46f3f..90ea50c65c 100644
--- a/crates/astria-sequencer/src/assets/state_ext.rs
+++ b/crates/astria-sequencer/src/assets/state_ext.rs
@@ -28,7 +28,7 @@ use crate::storage::StoredValue;
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_native_asset(&self) -> Result<Option<asset::TracePrefixed>> {
         let Some(bytes) = self
             .get_raw(keys::NATIVE_ASSET)
@@ -46,7 +46,7 @@ pub(crate) trait StateReadExt: StateRead {
             .map(Option::Some)
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn has_ibc_asset<'a, TAsset>(&self, asset: &'a TAsset) -> Result<bool>
     where
         TAsset: Sync,
@@ -60,7 +60,7 @@ pub(crate) trait StateReadExt: StateRead {
             .is_some())
     }
 
-    #[instrument(skip_all, fields(%asset), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(%asset), err(level = Level::WARN))]
     async fn map_ibc_to_trace_prefixed_asset(
         &self,
         asset: &asset::IbcPrefixed,
diff --git a/crates/astria-sequencer/src/authority/action.rs b/crates/astria-sequencer/src/authority/action.rs
index 49dbcb4bd0..bf614e18f4 100644
--- a/crates/astria-sequencer/src/authority/action.rs
+++ b/crates/astria-sequencer/src/authority/action.rs
@@ -32,7 +32,7 @@ impl ActionHandler for ValidatorUpdate {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
@@ -84,7 +84,7 @@ impl ActionHandler for SudoAddressChange {
 
     /// check that the signer of the transaction is the current sudo address,
     /// as only that address can change the sudo address
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
@@ -113,7 +113,7 @@ impl ActionHandler for IbcSudoChange {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/authority/state_ext.rs b/crates/astria-sequencer/src/authority/state_ext.rs
index 9218712707..e692967d25 100644
--- a/crates/astria-sequencer/src/authority/state_ext.rs
+++ b/crates/astria-sequencer/src/authority/state_ext.rs
@@ -33,7 +33,7 @@ use crate::{
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_sudo_address(&self) -> Result<[u8; ADDRESS_LEN]> {
         let Some(bytes) = self
             .get_raw(keys::SUDO)
@@ -49,7 +49,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid sudo key bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_validator_set(&self) -> Result<ValidatorSet> {
         let Some(bytes) = self
             .get_raw(keys::VALIDATOR_SET)
@@ -65,7 +65,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid validator set bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_validator_updates(&self) -> Result<ValidatorSet> {
         let Some(bytes) = self
             .nonverifiable_get_raw(keys::VALIDATOR_UPDATES.as_bytes())
diff --git a/crates/astria-sequencer/src/bridge/bridge_lock_action.rs b/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
index c947635fea..df287bcc70 100644
--- a/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
+++ b/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
@@ -38,7 +38,7 @@ impl ActionHandler for BridgeLock {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs b/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs
index 0fe12df17d..ff73b57d42 100644
--- a/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs
+++ b/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs
@@ -26,7 +26,7 @@ impl ActionHandler for BridgeSudoChange {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/bridge/bridge_unlock_action.rs b/crates/astria-sequencer/src/bridge/bridge_unlock_action.rs
index a59bacd457..1a0a2a3591 100644
--- a/crates/astria-sequencer/src/bridge/bridge_unlock_action.rs
+++ b/crates/astria-sequencer/src/bridge/bridge_unlock_action.rs
@@ -31,7 +31,7 @@ use crate::{
 #[async_trait::async_trait]
 impl ActionHandler for BridgeUnlock {
     // TODO(https://github.com/astriaorg/astria/issues/1430): move checks to the `BridgeUnlock` parsing.
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_stateless(&self) -> Result<()> {
         ensure!(self.amount > 0, "amount must be greater than zero",);
         ensure!(self.memo.len() <= 64, "memo must not be more than 64 bytes");
@@ -50,7 +50,7 @@ impl ActionHandler for BridgeUnlock {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs b/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs
index 751fc9e7aa..fbb90cffef 100644
--- a/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs
+++ b/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs
@@ -29,7 +29,7 @@ impl ActionHandler for InitBridgeAccount {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/bridge/state_ext.rs b/crates/astria-sequencer/src/bridge/state_ext.rs
index 7c337f700c..2628edc002 100644
--- a/crates/astria-sequencer/src/bridge/state_ext.rs
+++ b/crates/astria-sequencer/src/bridge/state_ext.rs
@@ -47,7 +47,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
         Ok(maybe_id.is_some())
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::WARN))]
     async fn get_bridge_account_rollup_id<T: AddressBytes>(
         &self,
         address: &T,
@@ -69,7 +69,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .wrap_err("invalid rollup ID bytes")
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::WARN))]
     async fn get_bridge_account_ibc_asset<T: AddressBytes>(
         &self,
         address: &T,
@@ -87,7 +87,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .wrap_err("invalid bridge account asset ID bytes")
     }
 
-    #[instrument(skip_all, fields(bridge_address = %bridge_address.display_address()), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(bridge_address = %bridge_address.display_address()), err(level = Level::WARN))]
     async fn get_bridge_account_sudo_address<T: AddressBytes>(
         &self,
         bridge_address: &T,
@@ -110,7 +110,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .wrap_err("invalid bridge account sudo address bytes")
     }
 
-    #[instrument(skip_all, fields(bridge_address = %bridge_address.display_address()), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(bridge_address = %bridge_address.display_address()), err(level = Level::WARN))]
     async fn get_bridge_account_withdrawer_address<T: AddressBytes>(
         &self,
         bridge_address: &T,
@@ -139,7 +139,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .unwrap_or_default()
     }
 
-    #[instrument(skip_all, fields(block_hash = %hex::encode(block_hash), %rollup_id), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(block_hash = %hex::encode(block_hash), %rollup_id), err(level = Level::WARN))]
     async fn get_deposits(
         &self,
         block_hash: &[u8; 32],
@@ -158,7 +158,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
             .context("invalid deposits bytes")
     }
 
-    #[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::WARN))]
     async fn get_last_transaction_id_for_bridge_account<T: AddressBytes>(
         &self,
         address: &T,
@@ -294,7 +294,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         self.object_put(keys::DEPOSITS_EPHEMERAL, cached_deposits);
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_deposits(
         &mut self,
         block_hash: &[u8; 32],
diff --git a/crates/astria-sequencer/src/fees/action.rs b/crates/astria-sequencer/src/fees/action.rs
index b91e88b401..4aef00132d 100644
--- a/crates/astria-sequencer/src/fees/action.rs
+++ b/crates/astria-sequencer/src/fees/action.rs
@@ -33,7 +33,7 @@ impl ActionHandler for FeeChange {
 
     /// check that the signer of the transaction is the current sudo address,
     /// as only that address can change the fee
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> eyre::Result<()> {
         let from = state
             .get_transaction_context()
@@ -99,7 +99,7 @@ impl ActionHandler for FeeAssetChange {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> eyre::Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/fees/mod.rs b/crates/astria-sequencer/src/fees/mod.rs
index c86bc7dc3f..31fb6a36b4 100644
--- a/crates/astria-sequencer/src/fees/mod.rs
+++ b/crates/astria-sequencer/src/fees/mod.rs
@@ -82,7 +82,7 @@ impl Fee {
 
 #[async_trait::async_trait]
 impl FeeHandler for Transfer {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_transfer_fees()
@@ -100,7 +100,7 @@ impl FeeHandler for Transfer {
 
 #[async_trait::async_trait]
 impl FeeHandler for BridgeLock {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_bridge_lock_fees()
@@ -118,7 +118,7 @@ impl FeeHandler for BridgeLock {
 
 #[async_trait::async_trait]
 impl FeeHandler for BridgeSudoChange {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_bridge_sudo_change_fees()
@@ -136,7 +136,7 @@ impl FeeHandler for BridgeSudoChange {
 
 #[async_trait::async_trait]
 impl FeeHandler for BridgeUnlock {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_bridge_unlock_fees()
@@ -154,7 +154,7 @@ impl FeeHandler for BridgeUnlock {
 
 #[async_trait::async_trait]
 impl FeeHandler for InitBridgeAccount {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_init_bridge_account_fees()
@@ -172,7 +172,7 @@ impl FeeHandler for InitBridgeAccount {
 
 #[async_trait::async_trait]
 impl FeeHandler for transaction::v1::action::Ics20Withdrawal {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_ics20_withdrawal_fees()
@@ -190,7 +190,7 @@ impl FeeHandler for transaction::v1::action::Ics20Withdrawal {
 
 #[async_trait::async_trait]
 impl FeeHandler for RollupDataSubmission {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         let fees = state
             .get_rollup_data_submission_fees()
@@ -209,7 +209,7 @@ impl FeeHandler for RollupDataSubmission {
 
 #[async_trait::async_trait]
 impl FeeHandler for ValidatorUpdate {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_validator_update_fees()
@@ -226,7 +226,7 @@ impl FeeHandler for ValidatorUpdate {
 
 #[async_trait::async_trait]
 impl FeeHandler for SudoAddressChange {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_sudo_address_change_fees()
@@ -243,7 +243,7 @@ impl FeeHandler for SudoAddressChange {
 
 #[async_trait::async_trait]
 impl FeeHandler for FeeChange {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_fee_change_fees()
@@ -260,7 +260,7 @@ impl FeeHandler for FeeChange {
 
 #[async_trait::async_trait]
 impl FeeHandler for IbcSudoChange {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_ibc_sudo_change_fees()
@@ -277,7 +277,7 @@ impl FeeHandler for IbcSudoChange {
 
 #[async_trait::async_trait]
 impl FeeHandler for IbcRelayerChange {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_ibc_relayer_change_fees()
@@ -294,7 +294,7 @@ impl FeeHandler for IbcRelayerChange {
 
 #[async_trait::async_trait]
 impl FeeHandler for FeeAssetChange {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_fee_asset_change_fees()
@@ -311,7 +311,7 @@ impl FeeHandler for FeeAssetChange {
 
 #[async_trait::async_trait]
 impl FeeHandler for IbcRelay {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_pay_fees<S: StateWrite>(&self, state: S) -> eyre::Result<()> {
         state
             .get_ibc_relay_fees()
diff --git a/crates/astria-sequencer/src/fees/query.rs b/crates/astria-sequencer/src/fees/query.rs
index 9587c6f963..6812132cdc 100644
--- a/crates/astria-sequencer/src/fees/query.rs
+++ b/crates/astria-sequencer/src/fees/query.rs
@@ -220,7 +220,7 @@ pub(crate) async fn transaction_fee_request(
     }
 }
 
-#[instrument(skip_all, err(level = Level::INFO))]
+#[instrument(skip_all, err(level = Level::DEBUG))]
 pub(crate) async fn get_fees_for_transaction<S: StateRead>(
     tx: &TransactionBody,
     state: &S,
diff --git a/crates/astria-sequencer/src/fees/state_ext.rs b/crates/astria-sequencer/src/fees/state_ext.rs
index 6ad70d25ca..8872bd591a 100644
--- a/crates/astria-sequencer/src/fees/state_ext.rs
+++ b/crates/astria-sequencer/src/fees/state_ext.rs
@@ -102,7 +102,7 @@ pub(crate) trait StateReadExt: StateRead {
         self.object_get(keys::BLOCK).unwrap_or_default()
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_transfer_fees(&self) -> Result<Option<TransferFeeComponents>> {
         let bytes = self
             .get_raw(keys::TRANSFER)
@@ -120,7 +120,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_rollup_data_submission_fees(
         &self,
     ) -> Result<Option<RollupDataSubmissionFeeComponents>> {
@@ -140,7 +140,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_ics20_withdrawal_fees(&self) -> Result<Option<Ics20WithdrawalFeeComponents>> {
         let bytes = self
             .get_raw(keys::ICS20_WITHDRAWAL)
@@ -158,7 +158,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_init_bridge_account_fees(&self) -> Result<Option<InitBridgeAccountFeeComponents>> {
         let bytes = self
             .get_raw(keys::INIT_BRIDGE_ACCOUNT)
@@ -176,7 +176,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_bridge_lock_fees(&self) -> Result<Option<BridgeLockFeeComponents>> {
         let bytes = self
             .get_raw(keys::BRIDGE_LOCK)
@@ -194,7 +194,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_bridge_unlock_fees(&self) -> Result<Option<BridgeUnlockFeeComponents>> {
         let bytes = self
             .get_raw(keys::BRIDGE_UNLOCK)
@@ -212,7 +212,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_bridge_sudo_change_fees(&self) -> Result<Option<BridgeSudoChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::BRIDGE_SUDO_CHANGE)
@@ -230,7 +230,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_ibc_relay_fees(&self) -> Result<Option<IbcRelayFeeComponents>> {
         let bytes = self
             .get_raw(keys::IBC_RELAY)
@@ -248,7 +248,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_validator_update_fees(&self) -> Result<Option<ValidatorUpdateFeeComponents>> {
         let bytes = self
             .get_raw(keys::VALIDATOR_UPDATE)
@@ -266,7 +266,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_fee_asset_change_fees(&self) -> Result<Option<FeeAssetChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::FEE_ASSET_CHANGE)
@@ -284,7 +284,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_fee_change_fees(&self) -> Result<Option<FeeChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::FEE_CHANGE)
@@ -302,7 +302,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_ibc_relayer_change_fees(&self) -> Result<Option<IbcRelayerChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::IBC_RELAYER_CHANGE)
@@ -320,7 +320,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_sudo_address_change_fees(&self) -> Result<Option<SudoAddressChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::SUDO_ADDRESS_CHANGE)
@@ -338,7 +338,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_ibc_sudo_change_fees(&self) -> Result<Option<IbcSudoChangeFeeComponents>> {
         let bytes = self
             .get_raw(keys::IBC_SUDO_CHANGE)
@@ -356,7 +356,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid fees bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn is_allowed_fee_asset<'a, TAsset>(&self, asset: &'a TAsset) -> Result<bool>
     where
         TAsset: Sync,
@@ -382,8 +382,9 @@ impl<T: ?Sized + StateRead> StateReadExt for T {}
 
 #[async_trait]
 pub(crate) trait StateWriteExt: StateWrite {
+    // TODO(https://github.com/astriaorg/astria/issues/1845): This doesn't need to return a result
     /// Constructs and adds `Fee` object to the block fees vec.
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn add_fee_to_block_fees<'a, TAsset, T: FeeHandler + Protobuf>(
         &mut self,
         asset: &'a TAsset,
@@ -418,7 +419,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_transfer_fees(&mut self, fees: TransferFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::TransferFeeComponentsStorage::from(fees))
             .serialize()
@@ -427,7 +428,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_rollup_data_submission_fees(
         &mut self,
         fees: RollupDataSubmissionFeeComponents,
@@ -441,7 +442,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_ics20_withdrawal_fees(&mut self, fees: Ics20WithdrawalFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::Ics20WithdrawalFeeComponentsStorage::from(fees))
             .serialize()
@@ -450,7 +451,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_init_bridge_account_fees(&mut self, fees: InitBridgeAccountFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::InitBridgeAccountFeeComponentsStorage::from(fees))
             .serialize()
@@ -459,7 +460,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_bridge_lock_fees(&mut self, fees: BridgeLockFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::BridgeLockFeeComponentsStorage::from(fees))
             .serialize()
@@ -468,7 +469,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_bridge_unlock_fees(&mut self, fees: BridgeUnlockFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::BridgeUnlockFeeComponentsStorage::from(fees))
             .serialize()
@@ -477,7 +478,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_bridge_sudo_change_fees(&mut self, fees: BridgeSudoChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::BridgeSudoChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -486,7 +487,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_ibc_relay_fees(&mut self, fees: IbcRelayFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::IbcRelayFeeComponentsStorage::from(fees))
             .serialize()
@@ -495,7 +496,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_validator_update_fees(&mut self, fees: ValidatorUpdateFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::ValidatorUpdateFeeComponentsStorage::from(fees))
             .serialize()
@@ -504,7 +505,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_fee_asset_change_fees(&mut self, fees: FeeAssetChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::FeeAssetChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -513,7 +514,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_fee_change_fees(&mut self, fees: FeeChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::FeeChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -522,7 +523,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_ibc_relayer_change_fees(&mut self, fees: IbcRelayerChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::IbcRelayerChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -531,7 +532,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_sudo_address_change_fees(&mut self, fees: SudoAddressChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::SudoAddressChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -540,7 +541,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_ibc_sudo_change_fees(&mut self, fees: IbcSudoChangeFeeComponents) -> Result<()> {
         let bytes = StoredValue::from(storage::IbcSudoChangeFeeComponentsStorage::from(fees))
             .serialize()
@@ -557,7 +558,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         self.delete(keys::allowed_asset(asset));
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     fn put_allowed_fee_asset<'a, TAsset>(&mut self, asset: &'a TAsset) -> Result<()>
     where
         &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
diff --git a/crates/astria-sequencer/src/grpc/state_ext.rs b/crates/astria-sequencer/src/grpc/state_ext.rs
index 05f53352fc..0f9a2f3a45 100644
--- a/crates/astria-sequencer/src/grpc/state_ext.rs
+++ b/crates/astria-sequencer/src/grpc/state_ext.rs
@@ -33,7 +33,7 @@ use crate::storage::StoredValue;
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all, fields(%height), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(%height), err(level = Level::WARN))]
     async fn get_block_hash_by_height(&self, height: u64) -> Result<[u8; 32]> {
         let Some(bytes) = self
             .nonverifiable_get_raw(keys::block_hash_by_height(height).as_bytes())
@@ -48,7 +48,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid block hash bytes")
     }
 
-    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::WARN))]
     async fn get_sequencer_block_header_by_hash(
         &self,
         hash: &[u8; 32],
@@ -68,7 +68,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid sequencer block header bytes")
     }
 
-    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::WARN))]
     async fn get_rollup_ids_by_block_hash(&self, hash: &[u8; 32]) -> Result<Vec<RollupId>> {
         let Some(bytes) = self
             .nonverifiable_get_raw(keys::rollup_ids_by_hash(hash).as_bytes())
@@ -94,7 +94,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("failed to get sequencer block by hash")
     }
 
-    #[instrument(skip_all, fields(hash = %hex::encode(hash), %rollup_id), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash), %rollup_id), err(level = Level::WARN))]
     async fn get_rollup_data(
         &self,
         hash: &[u8; 32],
@@ -119,7 +119,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid rollup transactions bytes")
     }
 
-    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::WARN))]
     async fn get_rollup_transactions_proof_by_block_hash(
         &self,
         hash: &[u8; 32],
@@ -137,7 +137,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid rollup transactions proof bytes")
     }
 
-    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(hash = %hex::encode(hash)), err(level = Level::WARN))]
     async fn get_rollup_ids_proof_by_block_hash(&self, hash: &[u8; 32]) -> Result<merkle::Proof> {
         let Some(bytes) = self
             .nonverifiable_get_raw(keys::rollup_ids_proof_by_hash(hash).as_bytes())
diff --git a/crates/astria-sequencer/src/ibc/ibc_relayer_change.rs b/crates/astria-sequencer/src/ibc/ibc_relayer_change.rs
index dd87409268..39347f2bdd 100644
--- a/crates/astria-sequencer/src/ibc/ibc_relayer_change.rs
+++ b/crates/astria-sequencer/src/ibc/ibc_relayer_change.rs
@@ -27,7 +27,7 @@ impl ActionHandler for IbcRelayerChange {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/ibc/ics20_transfer.rs b/crates/astria-sequencer/src/ibc/ics20_transfer.rs
index 377eb31cd8..e2181bb10d 100644
--- a/crates/astria-sequencer/src/ibc/ics20_transfer.rs
+++ b/crates/astria-sequencer/src/ibc/ics20_transfer.rs
@@ -305,7 +305,7 @@ impl AppHandlerCheck for Ics20Transfer {
     }
 }
 
-#[instrument(skip_all, fields(%source_port, %source_channel), err(level = Level::INFO))]
+#[instrument(skip_all, fields(%source_port, %source_channel), err(level = Level::DEBUG))]
 async fn refund_tokens_check<S: StateRead>(
     state: S,
     data: &[u8],
@@ -358,7 +358,7 @@ impl AppHandlerExecute for Ics20Transfer {
 
     async fn chan_close_init_execute<S: StateWrite>(_: S, _: &MsgChannelCloseInit) {}
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn recv_packet_execute<S: StateWrite>(
         mut state: S,
         msg: &MsgRecvPacket,
@@ -384,7 +384,7 @@ impl AppHandlerExecute for Ics20Transfer {
             .context("failed to write acknowledgement")
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn timeout_packet_execute<S: StateWrite>(
         mut state: S,
         msg: &MsgTimeout,
@@ -394,7 +394,7 @@ impl AppHandlerExecute for Ics20Transfer {
         })
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn acknowledge_packet_execute<S: StateWrite>(
         mut state: S,
         msg: &MsgAcknowledgement,
@@ -586,7 +586,7 @@ fn does_failed_transfer_come_from_rollup(
     serde_json::from_str::<Ics20WithdrawalFromRollup>(&packet_data.memo).ok()
 }
 
-#[instrument(skip_all, fields(%recipient, %asset, amount), err(level = Level::INFO))]
+#[instrument(skip_all, fields(%recipient, %asset, amount), err(level = Level::DEBUG))]
 async fn refund_tokens_to_sequencer_address<S: StateWrite>(
     mut state: S,
     recipient: &Address,
@@ -673,7 +673,7 @@ async fn parse_address_on_sequencer<S: StateRead>(state: &S, input: &str) -> Res
 
 /// Emits a deposit event signaling to the rollup that funds
 /// were added to `bridge_address`.
-#[instrument(skip_all, fields(%bridge_address, %asset, amount, memo), err(level = Level::INFO))]
+#[instrument(skip_all, fields(%bridge_address, %asset, amount, memo), err(level = Level::DEBUG))]
 async fn emit_bridge_lock_deposit<S: StateWrite>(
     mut state: S,
     bridge_address: Address,
@@ -704,7 +704,7 @@ async fn emit_bridge_lock_deposit<S: StateWrite>(
     .await
 }
 
-#[instrument(skip_all, fields(%bridge_address, destination_chain_address, %asset, amount), err(level = Level::INFO))]
+#[instrument(skip_all, fields(%bridge_address, destination_chain_address, %asset, amount), err(level = Level::DEBUG))]
 async fn emit_deposit<S: StateWrite>(
     mut state: S,
     bridge_address: &Address,
diff --git a/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs b/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs
index 55b6b35150..97fd087e94 100644
--- a/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs
+++ b/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs
@@ -150,7 +150,7 @@ async fn establish_withdrawal_target<'a, S: StateRead>(
 #[async_trait::async_trait]
 impl ActionHandler for action::Ics20Withdrawal {
     // TODO(https://github.com/astriaorg/astria/issues/1430): move checks to the `Ics20Withdrawal` parsing.
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_stateless(&self) -> Result<()> {
         ensure!(self.timeout_time() != 0, "timeout time must be non-zero",);
         ensure!(self.amount() > 0, "amount must be greater than zero",);
@@ -186,7 +186,7 @@ impl ActionHandler for action::Ics20Withdrawal {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/ibc/state_ext.rs b/crates/astria-sequencer/src/ibc/state_ext.rs
index 95f93bda21..cb9a908078 100644
--- a/crates/astria-sequencer/src/ibc/state_ext.rs
+++ b/crates/astria-sequencer/src/ibc/state_ext.rs
@@ -39,7 +39,7 @@ use crate::{
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
-    #[instrument(skip_all, fields(%channel, %asset), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(%channel, %asset), err(level = Level::WARN))]
     async fn get_ibc_channel_balance<'a, TAsset>(
         &self,
         channel: &ChannelId,
@@ -63,7 +63,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid ibc channel balance bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn get_ibc_sudo_address(&self) -> Result<[u8; ADDRESS_LEN]> {
         let Some(bytes) = self
             .get_raw(keys::IBC_SUDO)
@@ -79,7 +79,7 @@ pub(crate) trait StateReadExt: StateRead {
             .wrap_err("invalid ibc sudo address bytes")
     }
 
-    #[instrument(skip_all, err(level = Level::DEBUG))]
+    #[instrument(skip_all, err(level = Level::WARN))]
     async fn is_ibc_relayer<T: AddressBytes>(&self, address: T) -> Result<bool> {
         Ok(self
             .get_raw(&keys::ibc_relayer(&address))
@@ -94,7 +94,7 @@ impl<T: StateRead + ?Sized> StateReadExt for T {}
 
 #[async_trait]
 pub(crate) trait StateWriteExt: StateWrite {
-    #[instrument(skip_all, fields(%channel, %asset, balance), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(%channel, %asset, balance), err(level = Level::WARN))]
     fn put_ibc_channel_balance<'a, TAsset>(
         &mut self,
         channel: &ChannelId,
diff --git a/crates/astria-sequencer/src/transaction/checks.rs b/crates/astria-sequencer/src/transaction/checks.rs
index 7ff27db732..0f06140fcd 100644
--- a/crates/astria-sequencer/src/transaction/checks.rs
+++ b/crates/astria-sequencer/src/transaction/checks.rs
@@ -27,7 +27,7 @@ use crate::{
     fees::query::get_fees_for_transaction,
 };
 
-#[instrument(skip_all, fields(tx_hash = %tx.id()), err(level = Level::INFO))]
+#[instrument(skip_all, fields(tx_hash = %tx.id()), err(level = Level::DEBUG))]
 pub(crate) async fn check_chain_id_mempool<S: StateRead>(
     tx: &Transaction,
     state: &S,
@@ -42,7 +42,7 @@ pub(crate) async fn check_chain_id_mempool<S: StateRead>(
 
 // Checks that the account has enough balance to cover the total fees and transferred values
 // for all actions in the transaction.
-#[instrument(skip_all, fields(tx_hash = %tx.id()), err(level = Level::INFO))]
+#[instrument(skip_all, fields(tx_hash = %tx.id()), err(level = Level::DEBUG))]
 pub(crate) async fn check_balance_for_total_fees_and_transfers<S: StateRead>(
     tx: &Transaction,
     state: &S,
diff --git a/crates/astria-sequencer/src/transaction/mod.rs b/crates/astria-sequencer/src/transaction/mod.rs
index 21b911d839..911d5fa86d 100644
--- a/crates/astria-sequencer/src/transaction/mod.rs
+++ b/crates/astria-sequencer/src/transaction/mod.rs
@@ -87,7 +87,7 @@ impl std::error::Error for InvalidNonce {}
 
 #[async_trait::async_trait]
 impl ActionHandler for Transaction {
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_stateless(&self) -> Result<()> {
         ensure!(!self.actions().is_empty(), "must have at least one action");
 
@@ -160,7 +160,7 @@ impl ActionHandler for Transaction {
         Ok(())
     }
 
-    #[instrument(skip_all, err(level = Level::INFO))]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         // Add the current signed transaction into the ephemeral state in case
         // downstream actions require access to it.

From 4d730434cfc71b4e739121364facf70d93f9b4c9 Mon Sep 17 00:00:00 2001
From: ethanoroshiba <ethan@astria.org>
Date: Wed, 4 Dec 2024 09:31:27 -0600
Subject: [PATCH 4/5] changes from main

---
 crates/astria-sequencer/src/accounts/action.rs             | 0
 .../src/action_handler/impls/bridge_lock.rs                | 5 +++++
 .../src/action_handler/impls/fee_asset_change.rs           | 5 +++++
 .../src/action_handler/impls/fee_change.rs                 | 5 +++++
 .../src/action_handler/impls/ibc_sudo_change.rs            | 5 +++++
 .../src/action_handler/impls/ics20_withdrawal.rs           | 6 ++++++
 .../src/action_handler/impls/rollup_data_submission.rs     | 5 +++++
 .../src/action_handler/impls/sudo_address_change.rs        | 5 +++++
 .../src/action_handler/impls/transaction.rs                | 7 ++++++-
 .../astria-sequencer/src/action_handler/impls/transfer.rs  | 5 +++++
 .../src/action_handler/impls/validator_update.rs           | 5 +++++
 crates/astria-sequencer/src/authority/action.rs            | 0
 crates/astria-sequencer/src/bridge/bridge_lock_action.rs   | 0
 13 files changed, 52 insertions(+), 1 deletion(-)
 delete mode 100644 crates/astria-sequencer/src/accounts/action.rs
 delete mode 100644 crates/astria-sequencer/src/authority/action.rs
 delete mode 100644 crates/astria-sequencer/src/bridge/bridge_lock_action.rs

diff --git a/crates/astria-sequencer/src/accounts/action.rs b/crates/astria-sequencer/src/accounts/action.rs
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/crates/astria-sequencer/src/action_handler/impls/bridge_lock.rs b/crates/astria-sequencer/src/action_handler/impls/bridge_lock.rs
index 3be717fc61..38c61520c6 100644
--- a/crates/astria-sequencer/src/action_handler/impls/bridge_lock.rs
+++ b/crates/astria-sequencer/src/action_handler/impls/bridge_lock.rs
@@ -13,6 +13,10 @@ use astria_eyre::eyre::{
 };
 use async_trait::async_trait;
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     action_handler::{
@@ -36,6 +40,7 @@ impl ActionHandler for BridgeLock {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/action_handler/impls/fee_asset_change.rs b/crates/astria-sequencer/src/action_handler/impls/fee_asset_change.rs
index c92161e751..fabbe3247c 100644
--- a/crates/astria-sequencer/src/action_handler/impls/fee_asset_change.rs
+++ b/crates/astria-sequencer/src/action_handler/impls/fee_asset_change.rs
@@ -8,6 +8,10 @@ use async_trait::async_trait;
 use cnidarium::StateWrite;
 use futures::StreamExt as _;
 use tokio::pin;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     action_handler::ActionHandler,
@@ -25,6 +29,7 @@ impl ActionHandler for FeeAssetChange {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> eyre::Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/action_handler/impls/fee_change.rs b/crates/astria-sequencer/src/action_handler/impls/fee_change.rs
index d83cf2ed61..47529e6a18 100644
--- a/crates/astria-sequencer/src/action_handler/impls/fee_change.rs
+++ b/crates/astria-sequencer/src/action_handler/impls/fee_change.rs
@@ -6,6 +6,10 @@ use astria_eyre::eyre::{
 };
 use async_trait::async_trait;
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     action_handler::ActionHandler,
@@ -22,6 +26,7 @@ impl ActionHandler for FeeChange {
 
     /// check that the signer of the transaction is the current sudo address,
     /// as only that address can change the fee
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> eyre::Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/action_handler/impls/ibc_sudo_change.rs b/crates/astria-sequencer/src/action_handler/impls/ibc_sudo_change.rs
index f82af648fc..487f71b4e6 100644
--- a/crates/astria-sequencer/src/action_handler/impls/ibc_sudo_change.rs
+++ b/crates/astria-sequencer/src/action_handler/impls/ibc_sudo_change.rs
@@ -6,6 +6,10 @@ use astria_eyre::eyre::{
 };
 use async_trait::async_trait;
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     action_handler::ActionHandler,
@@ -21,6 +25,7 @@ impl ActionHandler for IbcSudoChange {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/action_handler/impls/ics20_withdrawal.rs b/crates/astria-sequencer/src/action_handler/impls/ics20_withdrawal.rs
index 35d1523ece..3e0b677344 100644
--- a/crates/astria-sequencer/src/action_handler/impls/ics20_withdrawal.rs
+++ b/crates/astria-sequencer/src/action_handler/impls/ics20_withdrawal.rs
@@ -37,6 +37,10 @@ use penumbra_ibc::component::packet::{
     SendPacketWrite as _,
     Unchecked,
 };
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     accounts::{
@@ -60,6 +64,7 @@ use crate::{
 #[async_trait]
 impl ActionHandler for action::Ics20Withdrawal {
     // TODO(https://github.com/astriaorg/astria/issues/1430): move checks to the `Ics20Withdrawal` parsing.
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_stateless(&self) -> Result<()> {
         ensure!(self.timeout_time() != 0, "timeout time must be non-zero",);
         ensure!(self.amount() > 0, "amount must be greater than zero",);
@@ -95,6 +100,7 @@ impl ActionHandler for action::Ics20Withdrawal {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/action_handler/impls/rollup_data_submission.rs b/crates/astria-sequencer/src/action_handler/impls/rollup_data_submission.rs
index 3881e221bf..23be358129 100644
--- a/crates/astria-sequencer/src/action_handler/impls/rollup_data_submission.rs
+++ b/crates/astria-sequencer/src/action_handler/impls/rollup_data_submission.rs
@@ -5,11 +5,16 @@ use astria_eyre::eyre::{
 };
 use async_trait::async_trait;
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::action_handler::ActionHandler;
 
 #[async_trait]
 impl ActionHandler for RollupDataSubmission {
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_stateless(&self) -> Result<()> {
         // TODO: do we want to place a maximum on the size of the data?
         // https://github.com/astriaorg/astria/issues/222
diff --git a/crates/astria-sequencer/src/action_handler/impls/sudo_address_change.rs b/crates/astria-sequencer/src/action_handler/impls/sudo_address_change.rs
index 7c7cb2e5e2..eb3f4f771a 100644
--- a/crates/astria-sequencer/src/action_handler/impls/sudo_address_change.rs
+++ b/crates/astria-sequencer/src/action_handler/impls/sudo_address_change.rs
@@ -6,6 +6,10 @@ use astria_eyre::eyre::{
 };
 use async_trait::async_trait;
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     action_handler::ActionHandler,
@@ -25,6 +29,7 @@ impl ActionHandler for SudoAddressChange {
 
     /// check that the signer of the transaction is the current sudo address,
     /// as only that address can change the sudo address
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/action_handler/impls/transaction.rs b/crates/astria-sequencer/src/action_handler/impls/transaction.rs
index 29df7cc10a..305c50819f 100644
--- a/crates/astria-sequencer/src/action_handler/impls/transaction.rs
+++ b/crates/astria-sequencer/src/action_handler/impls/transaction.rs
@@ -14,6 +14,10 @@ use astria_eyre::{
     },
 };
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     accounts::{
@@ -69,6 +73,7 @@ impl std::error::Error for InvalidNonce {}
 
 #[async_trait::async_trait]
 impl ActionHandler for Transaction {
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_stateless(&self) -> Result<()> {
         ensure!(!self.actions().is_empty(), "must have at least one action");
 
@@ -144,7 +149,7 @@ impl ActionHandler for Transaction {
     // FIXME (https://github.com/astriaorg/astria/issues/1584): because most lines come from delegating (and error wrapping) to the
     // individual actions. This could be tidied up by implementing `ActionHandler for Action`
     // and letting it delegate.
-    #[expect(clippy::too_many_lines, reason = "should be refactored")]
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         // Add the current signed transaction into the ephemeral state in case
         // downstream actions require access to it.
diff --git a/crates/astria-sequencer/src/action_handler/impls/transfer.rs b/crates/astria-sequencer/src/action_handler/impls/transfer.rs
index 27d955bca3..75735e8df4 100644
--- a/crates/astria-sequencer/src/action_handler/impls/transfer.rs
+++ b/crates/astria-sequencer/src/action_handler/impls/transfer.rs
@@ -6,6 +6,10 @@ use astria_eyre::eyre::{
 };
 use async_trait::async_trait;
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     action_handler::{
@@ -23,6 +27,7 @@ impl ActionHandler for Transfer {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/action_handler/impls/validator_update.rs b/crates/astria-sequencer/src/action_handler/impls/validator_update.rs
index 4bd0d72c3c..5ad1ceab06 100644
--- a/crates/astria-sequencer/src/action_handler/impls/validator_update.rs
+++ b/crates/astria-sequencer/src/action_handler/impls/validator_update.rs
@@ -7,6 +7,10 @@ use astria_eyre::eyre::{
 };
 use async_trait::async_trait;
 use cnidarium::StateWrite;
+use tracing::{
+    instrument,
+    Level,
+};
 
 use crate::{
     action_handler::ActionHandler,
@@ -23,6 +27,7 @@ impl ActionHandler for ValidatorUpdate {
         Ok(())
     }
 
+    #[instrument(skip_all, err(level = Level::DEBUG))]
     async fn check_and_execute<S: StateWrite>(&self, mut state: S) -> Result<()> {
         let from = state
             .get_transaction_context()
diff --git a/crates/astria-sequencer/src/authority/action.rs b/crates/astria-sequencer/src/authority/action.rs
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/crates/astria-sequencer/src/bridge/bridge_lock_action.rs b/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
deleted file mode 100644
index e69de29bb2..0000000000

From 66e1b84d0fc88d5e7cb15299f401e08e3e0fd171 Mon Sep 17 00:00:00 2001
From: ethanoroshiba <ethan@astria.org>
Date: Wed, 18 Dec 2024 12:46:26 -0600
Subject: [PATCH 5/5] requested changes

---
 crates/astria-sequencer/src/bridge/state_ext.rs      |  9 +++++++--
 crates/astria-sequencer/src/mempool/mod.rs           |  2 +-
 .../src/mempool/transactions_container.rs            |  2 +-
 crates/astria-sequencer/src/sequencer.rs             | 12 ++++++------
 4 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/crates/astria-sequencer/src/bridge/state_ext.rs b/crates/astria-sequencer/src/bridge/state_ext.rs
index 99f5b67dec..e405d505fe 100644
--- a/crates/astria-sequencer/src/bridge/state_ext.rs
+++ b/crates/astria-sequencer/src/bridge/state_ext.rs
@@ -41,7 +41,7 @@ use crate::{
 
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
-    #[instrument(skip_all, fields(address = %address.display_address()), err(level = Level::DEBUG))]
+    #[instrument(skip_all, fields(address = %address.display_address()))]
     async fn is_a_bridge_account<T: AddressBytes>(&self, address: &T) -> Result<bool> {
         let maybe_id = self.get_bridge_account_rollup_id(address).await?;
         Ok(maybe_id.is_some())
@@ -250,7 +250,12 @@ pub(crate) trait StateWriteExt: StateWrite {
         Ok(())
     }
 
-    #[instrument(skip_all, fields(block_hash = %address.display_address(), withdrawal_event_id, block_num), err(level = Level::DEBUG))]
+    #[instrument(
+        skip_all,
+        fields(address = %address.display_address(),
+        withdrawal_event_id, block_num),
+        err(level = Level::DEBUG)
+    )]
     async fn check_and_set_withdrawal_event_block_for_bridge_account<T: AddressBytes>(
         &mut self,
         address: &T,
diff --git a/crates/astria-sequencer/src/mempool/mod.rs b/crates/astria-sequencer/src/mempool/mod.rs
index 75ca65ee62..e3391df888 100644
--- a/crates/astria-sequencer/src/mempool/mod.rs
+++ b/crates/astria-sequencer/src/mempool/mod.rs
@@ -485,7 +485,7 @@ impl Mempool {
     /// does not take into account gapped nonces in the parked queue. For example, if the
     /// pending queue for an account has nonces [0,1] and the parked queue has [3], [1] will be
     /// returned.
-    #[instrument(skip_all, fields(address = %hex::encode(address)))]
+    #[instrument(skip_all, fields(address = %telemetry::display::base64(address)))]
     pub(crate) async fn pending_nonce(&self, address: &[u8; 20]) -> Option<u32> {
         self.pending.read().await.pending_nonce(address)
     }
diff --git a/crates/astria-sequencer/src/mempool/transactions_container.rs b/crates/astria-sequencer/src/mempool/transactions_container.rs
index 4366aca10a..9dc2b5198c 100644
--- a/crates/astria-sequencer/src/mempool/transactions_container.rs
+++ b/crates/astria-sequencer/src/mempool/transactions_container.rs
@@ -573,7 +573,7 @@ pub(super) trait TransactionsContainer<T: TransactionsForAccount> {
     /// Recosts transactions for an account.
     ///
     /// Logs an error if fails to recost a transaction.
-    #[instrument(skip_all, fields(address = %hex::encode(address)))]
+    #[instrument(skip_all, fields(address = %telemetry::display::base64(address)))]
     async fn recost_transactions<S: accounts::StateReadExt>(
         &mut self,
         address: &[u8; 20],
diff --git a/crates/astria-sequencer/src/sequencer.rs b/crates/astria-sequencer/src/sequencer.rs
index f96aa3ac6a..92df49d470 100644
--- a/crates/astria-sequencer/src/sequencer.rs
+++ b/crates/astria-sequencer/src/sequencer.rs
@@ -52,20 +52,21 @@ impl Sequencer {
         cnidarium::register_metrics();
         register_histogram_global("cnidarium_get_raw_duration_seconds");
         register_histogram_global("cnidarium_nonverifiable_get_raw_duration_seconds");
+        let span = info_span!("Sequencer::run_until_stopped");
 
         if config
             .db_filepath
             .try_exists()
             .context("failed checking for existence of db storage file")?
         {
-            info_span!("Sequencer::run_until_stopped").in_scope(|| {
+            span.in_scope(|| {
                 info!(
                     path = %config.db_filepath.display(),
                     "opening storage db"
                 );
             });
         } else {
-            info_span!("Sequencer::run_until_stopped").in_scope(|| {
+            span.in_scope(|| {
                 info!(
                     path = %config.db_filepath.display(),
                     "creating storage db"
@@ -124,8 +125,7 @@ impl Sequencer {
             .wrap_err("failed to parse grpc_addr address")?;
         let grpc_server_handle = start_grpc_server(&storage, mempool, grpc_addr, shutdown_rx);
 
-        info_span!("Sequencer::run_until_stopped")
-            .in_scope(|| info!(config.listen_addr, "starting sequencer"));
+        span.in_scope(|| info!(config.listen_addr, "starting sequencer"));
         let server_handle = tokio::spawn(async move {
             match server.listen_tcp(&config.listen_addr).await {
                 Ok(()) => {
@@ -142,11 +142,11 @@ impl Sequencer {
 
         select! {
             _ = signals.stop_rx.changed() => {
-                info_span!("Sequencer::run_until_stopped").in_scope(|| info!("shutting down sequencer"));
+                span.in_scope(|| info!("shutting down sequencer"));
             }
 
             _ = server_exit_rx => {
-                error_span!("Sequencer::run_until_stopped").in_scope(|| error!("ABCI server task exited, this shouldn't happen"));
+                span.in_scope(|| error!("ABCI server task exited, this shouldn't happen"));
             }
         }