diff --git a/Cargo.lock b/Cargo.lock
index 5995e436cb..063e3a9d2b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -795,6 +795,7 @@ dependencies = [
  "astria-merkle",
  "astria-telemetry",
  "async-trait",
+ "base64 0.21.7",
  "borsh",
  "bytes",
  "cnidarium",
diff --git a/crates/astria-core/src/primitive/v1/asset/denom.rs b/crates/astria-core/src/primitive/v1/asset/denom.rs
index ec685dba7d..6913f2321b 100644
--- a/crates/astria-core/src/primitive/v1/asset/denom.rs
+++ b/crates/astria-core/src/primitive/v1/asset/denom.rs
@@ -1,4 +1,5 @@
 use std::{
+    borrow::Cow,
     collections::VecDeque,
     str::FromStr,
 };
@@ -140,6 +141,27 @@ impl<'a> From<&'a IbcPrefixed> for IbcPrefixed {
     }
 }
 
+impl<'a> From<&'a IbcPrefixed> for Cow<'a, IbcPrefixed> {
+    fn from(ibc_prefixed: &'a IbcPrefixed) -> Self {
+        Cow::Borrowed(ibc_prefixed)
+    }
+}
+
+impl<'a> From<&'a TracePrefixed> for Cow<'a, IbcPrefixed> {
+    fn from(trace_prefixed: &'a TracePrefixed) -> Self {
+        Cow::Owned(trace_prefixed.to_ibc_prefixed())
+    }
+}
+
+impl<'a> From<&'a Denom> for Cow<'a, IbcPrefixed> {
+    fn from(value: &'a Denom) -> Self {
+        match value {
+            Denom::TracePrefixed(trace_prefixed) => Cow::from(trace_prefixed),
+            Denom::IbcPrefixed(ibc_prefixed) => Cow::from(ibc_prefixed),
+        }
+    }
+}
+
 impl FromStr for Denom {
     type Err = ParseDenomError;
 
@@ -543,20 +565,22 @@ pub struct IbcPrefixed {
 }
 
 impl IbcPrefixed {
+    pub const ENCODED_HASH_LEN: usize = 32;
+
     #[must_use]
-    pub fn new(id: [u8; 32]) -> Self {
+    pub const fn new(id: [u8; Self::ENCODED_HASH_LEN]) -> Self {
         Self {
             id,
         }
     }
 
     #[must_use]
-    pub fn as_bytes(&self) -> &[u8; 32] {
+    pub const fn as_bytes(&self) -> &[u8; Self::ENCODED_HASH_LEN] {
         &self.id
     }
 
     #[must_use]
-    pub fn display_len(&self) -> usize {
+    pub const fn display_len(&self) -> usize {
         68 // "ibc/" + 64 hex characters
     }
 }
@@ -586,7 +610,7 @@ impl FromStr for IbcPrefixed {
         if segments.next().is_some() {
             return Err(ParseIbcPrefixedError::too_many_segments());
         }
-        let id = <[u8; 32]>::from_hex(hex).map_err(Self::Err::hex)?;
+        let id = <[u8; Self::ENCODED_HASH_LEN]>::from_hex(hex).map_err(Self::Err::hex)?;
         Ok(Self {
             id,
         })
diff --git a/crates/astria-core/src/primitive/v1/mod.rs b/crates/astria-core/src/primitive/v1/mod.rs
index 531ebe8f72..36d3f0d583 100644
--- a/crates/astria-core/src/primitive/v1/mod.rs
+++ b/crates/astria-core/src/primitive/v1/mod.rs
@@ -8,7 +8,7 @@ use std::{
 
 use base64::{
     display::Base64Display,
-    prelude::BASE64_STANDARD,
+    prelude::BASE64_URL_SAFE,
 };
 use bytes::Bytes;
 use sha2::{
@@ -231,7 +231,7 @@ impl From<&RollupId> for RollupId {
 
 impl std::fmt::Display for RollupId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Base64Display::new(self.as_ref(), &BASE64_STANDARD).fmt(f)
+        Base64Display::new(self.as_ref(), &BASE64_URL_SAFE).fmt(f)
     }
 }
 
diff --git a/crates/astria-sequencer/Cargo.toml b/crates/astria-sequencer/Cargo.toml
index a31c86ac27..5f5f2cec24 100644
--- a/crates/astria-sequencer/Cargo.toml
+++ b/crates/astria-sequencer/Cargo.toml
@@ -47,6 +47,7 @@ tower-actor = "0.1.0"
 tower-http = { version = "0.4", features = ["cors"] }
 
 async-trait = { workspace = true }
+base64 = { workspace = true }
 bytes = { workspace = true }
 divan = { workspace = true, optional = true }
 futures = { workspace = true }
diff --git a/crates/astria-sequencer/src/accounts/action.rs b/crates/astria-sequencer/src/accounts/action.rs
index b248bc3624..32b2a482b0 100644
--- a/crates/astria-sequencer/src/accounts/action.rs
+++ b/crates/astria-sequencer/src/accounts/action.rs
@@ -1,7 +1,4 @@
-use astria_core::{
-    protocol::transaction::v1alpha1::action::Transfer,
-    Protobuf as _,
-};
+use astria_core::protocol::transaction::v1alpha1::action::Transfer;
 use astria_eyre::eyre::{
     ensure,
     OptionExt as _,
@@ -71,7 +68,7 @@ where
         .await
         .wrap_err("failed to get transfer base fee")?;
     state
-        .get_and_increase_block_fees(&action.fee_asset, fee, Transfer::full_name())
+        .get_and_increase_block_fees::<Transfer, _>(&action.fee_asset, fee)
         .await
         .wrap_err("failed to add to block fees")?;
 
diff --git a/crates/astria-sequencer/src/accounts/snapshots/astria_sequencer__accounts__state_ext__tests__storage_keys_have_not_changed-2.snap b/crates/astria-sequencer/src/accounts/snapshots/astria_sequencer__accounts__state_ext__tests__storage_keys_have_not_changed-2.snap
deleted file mode 100644
index 9b2ee0652b..0000000000
--- a/crates/astria-sequencer/src/accounts/snapshots/astria_sequencer__accounts__state_ext__tests__storage_keys_have_not_changed-2.snap
+++ /dev/null
@@ -1,6 +0,0 @@
----
-source: crates/astria-sequencer/src/accounts/state_ext.rs
-assertion_line: 855
-expression: nonce_storage_key(&address)
----
-accounts/1c0c490f1b5528d8173c5de46d131160e4b2c0c3/nonce
diff --git a/crates/astria-sequencer/src/accounts/snapshots/astria_sequencer__accounts__state_ext__tests__storage_keys_have_not_changed.snap b/crates/astria-sequencer/src/accounts/snapshots/astria_sequencer__accounts__state_ext__tests__storage_keys_have_not_changed.snap
deleted file mode 100644
index 9125e1ba51..0000000000
--- a/crates/astria-sequencer/src/accounts/snapshots/astria_sequencer__accounts__state_ext__tests__storage_keys_have_not_changed.snap
+++ /dev/null
@@ -1,6 +0,0 @@
----
-source: crates/astria-sequencer/src/accounts/state_ext.rs
-assertion_line: 854
-expression: "balance_storage_key(&address, &asset)"
----
-accounts/1c0c490f1b5528d8173c5de46d131160e4b2c0c3/balance/be429a02d00837245167a2616674a979a2ac6f9806468b48a975b156ad711320
diff --git a/crates/astria-sequencer/src/accounts/state_ext.rs b/crates/astria-sequencer/src/accounts/state_ext.rs
index 1aca12616c..5348d0ee2d 100644
--- a/crates/astria-sequencer/src/accounts/state_ext.rs
+++ b/crates/astria-sequencer/src/accounts/state_ext.rs
@@ -1,4 +1,5 @@
 use std::{
+    borrow::Cow,
     fmt::Display,
     pin::Pin,
     task::{
@@ -27,44 +28,18 @@ use futures::Stream;
 use pin_project_lite::pin_project;
 use tracing::instrument;
 
-use super::storage;
+use super::storage::{
+    self,
+    keys::{
+        self,
+        extract_asset_from_key,
+    },
+};
 use crate::{
     accounts::AddressBytes,
     storage::StoredValue,
 };
 
-const ACCOUNTS_PREFIX: &str = "accounts";
-const TRANSFER_BASE_FEE_STORAGE_KEY: &str = "transferfee";
-
-struct StorageKey<'a, T>(&'a T);
-impl<'a, T: AddressBytes> std::fmt::Display for StorageKey<'a, T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(ACCOUNTS_PREFIX)?;
-        f.write_str("/")?;
-        for byte in self.0.address_bytes() {
-            f.write_fmt(format_args!("{byte:02x}"))?;
-        }
-        Ok(())
-    }
-}
-
-fn balance_storage_key<'a, TAddress, TAsset>(address: &TAddress, asset: &'a TAsset) -> String
-where
-    TAddress: AddressBytes,
-    asset::IbcPrefixed: From<&'a TAsset>,
-{
-    let asset: asset::IbcPrefixed = asset.into();
-    format!(
-        "{}/balance/{}",
-        StorageKey(address),
-        crate::storage_keys::hunks::Asset::from(asset)
-    )
-}
-
-fn nonce_storage_key<T: AddressBytes>(address: &T) -> String {
-    format!("{}/nonce", StorageKey(address))
-}
-
 pin_project! {
     /// A stream of IBC prefixed assets for a given account.
     pub(crate) struct AccountAssetsStream<St> {
@@ -141,15 +116,6 @@ where
     }
 }
 
-fn extract_asset_from_key(s: &str) -> Result<asset::IbcPrefixed> {
-    Ok(s.strip_prefix("accounts/")
-        .and_then(|s| s.split_once("/balance/").map(|(_, asset)| asset))
-        .ok_or_eyre("failed to strip prefix from account balance key")?
-        .parse::<crate::storage_keys::hunks::Asset>()
-        .context("failed to parse storage key suffix as address hunk")?
-        .get())
-}
-
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead + crate::assets::StateReadExt {
     #[instrument(skip_all)]
@@ -157,7 +123,7 @@ pub(crate) trait StateReadExt: StateRead + crate::assets::StateReadExt {
         &self,
         address: &T,
     ) -> AccountAssetsStream<Self::PrefixKeysStream> {
-        let prefix = format!("{}/balance/", StorageKey(address));
+        let prefix = keys::balance_prefix(address);
         AccountAssetsStream {
             underlying: self.prefix_keys(&prefix),
         }
@@ -168,7 +134,7 @@ pub(crate) trait StateReadExt: StateRead + crate::assets::StateReadExt {
         &self,
         address: &T,
     ) -> AccountAssetBalancesStream<Self::PrefixRawStream> {
-        let prefix = format!("{}/balance/", StorageKey(address));
+        let prefix = keys::balance_prefix(address);
         AccountAssetBalancesStream {
             underlying: self.prefix_raw(&prefix),
         }
@@ -183,10 +149,10 @@ pub(crate) trait StateReadExt: StateRead + crate::assets::StateReadExt {
     where
         TAddress: AddressBytes,
         TAsset: Sync + Display,
-        asset::IbcPrefixed: From<&'a TAsset> + Send + Sync,
+        &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
     {
         let Some(bytes) = self
-            .get_raw(&balance_storage_key(address, asset))
+            .get_raw(&keys::balance(address, asset))
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw account balance from state")?
@@ -201,7 +167,7 @@ pub(crate) trait StateReadExt: StateRead + crate::assets::StateReadExt {
     #[instrument(skip_all)]
     async fn get_account_nonce<T: AddressBytes>(&self, address: &T) -> Result<u32> {
         let bytes = self
-            .get_raw(&nonce_storage_key(address))
+            .get_raw(&keys::nonce(address))
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw account nonce from state")?;
@@ -217,7 +183,7 @@ pub(crate) trait StateReadExt: StateRead + crate::assets::StateReadExt {
     #[instrument(skip_all)]
     async fn get_transfer_base_fee(&self) -> Result<u128> {
         let bytes = self
-            .get_raw(TRANSFER_BASE_FEE_STORAGE_KEY)
+            .get_raw(keys::TRANSFER_BASE_FEE)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw transfer base fee from state")?;
@@ -244,12 +210,12 @@ pub(crate) trait StateWriteExt: StateWrite {
     where
         TAddress: AddressBytes,
         TAsset: Display,
-        asset::IbcPrefixed: From<&'a TAsset> + Send,
+        &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
     {
         let bytes = StoredValue::from(storage::Balance::from(balance))
             .serialize()
             .wrap_err("failed to serialize balance")?;
-        self.put_raw(balance_storage_key(address, asset), bytes);
+        self.put_raw(keys::balance(address, asset), bytes);
         Ok(())
     }
 
@@ -258,7 +224,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::Nonce::from(nonce))
             .serialize()
             .wrap_err("failed to serialize nonce")?;
-        self.put_raw(nonce_storage_key(address), bytes);
+        self.put_raw(keys::nonce(address), bytes);
         Ok(())
     }
 
@@ -272,7 +238,7 @@ pub(crate) trait StateWriteExt: StateWrite {
     where
         TAddress: AddressBytes,
         TAsset: Sync + Display,
-        asset::IbcPrefixed: From<&'a TAsset> + Send,
+        &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
     {
         let balance = self
             .get_account_balance(address, asset)
@@ -299,7 +265,7 @@ pub(crate) trait StateWriteExt: StateWrite {
     where
         TAddress: AddressBytes,
         TAsset: Sync + Display,
-        asset::IbcPrefixed: From<&'a TAsset> + Send,
+        &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
     {
         let balance = self
             .get_account_balance(address, asset)
@@ -321,7 +287,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::Fee::from(fee))
             .serialize()
             .wrap_err("failed to serialize fee")?;
-        self.put_raw(TRANSFER_BASE_FEE_STORAGE_KEY.to_string(), bytes);
+        self.put_raw(keys::TRANSFER_BASE_FEE.to_string(), bytes);
         Ok(())
     }
 }
@@ -330,17 +296,10 @@ impl<T: StateWrite> StateWriteExt for T {}
 
 #[cfg(test)]
 mod tests {
-    use astria_core::primitive::v1::Address;
     use cnidarium::StateDelta;
     use futures::TryStreamExt as _;
-    use insta::assert_snapshot;
 
-    use super::{
-        balance_storage_key,
-        nonce_storage_key,
-        StateReadExt as _,
-        StateWriteExt as _,
-    };
+    use super::*;
     use crate::{
         assets::{
             StateReadExt as _,
@@ -352,14 +311,15 @@ mod tests {
         },
     };
 
-    fn asset_0() -> astria_core::primitive::v1::asset::Denom {
+    fn asset_0() -> asset::Denom {
         "asset_0".parse().unwrap()
     }
 
-    fn asset_1() -> astria_core::primitive::v1::asset::Denom {
+    fn asset_1() -> asset::Denom {
         "asset_1".parse().unwrap()
     }
-    fn asset_2() -> astria_core::primitive::v1::asset::Denom {
+
+    fn asset_2() -> asset::Denom {
         "asset_2".parse().unwrap()
     }
 
@@ -834,20 +794,4 @@ mod tests {
         let retrieved_fee = state.get_transfer_base_fee().await.unwrap();
         assert_eq!(retrieved_fee, 123);
     }
-
-    #[test]
-    fn storage_keys_have_not_changed() {
-        let address: Address = "astria1rsxyjrcm255ds9euthjx6yc3vrjt9sxrm9cfgm"
-            .parse()
-            .unwrap();
-        let asset = "an/asset/with/a/prefix"
-            .parse::<astria_core::primitive::v1::asset::Denom>()
-            .unwrap();
-        assert_eq!(
-            balance_storage_key(&address, &asset),
-            balance_storage_key(&address, &asset.to_ibc_prefixed())
-        );
-        assert_snapshot!(balance_storage_key(&address, &asset));
-        assert_snapshot!(nonce_storage_key(&address));
-    }
 }
diff --git a/crates/astria-sequencer/src/accounts/storage/keys.rs b/crates/astria-sequencer/src/accounts/storage/keys.rs
new file mode 100644
index 0000000000..e23e368bcf
--- /dev/null
+++ b/crates/astria-sequencer/src/accounts/storage/keys.rs
@@ -0,0 +1,113 @@
+use std::borrow::Cow;
+
+use astria_core::primitive::v1::asset::IbcPrefixed;
+use astria_eyre::eyre::{
+    OptionExt as _,
+    Result,
+    WrapErr as _,
+};
+
+use crate::{
+    accounts::AddressBytes,
+    storage::keys::{
+        AccountPrefixer,
+        Asset,
+    },
+};
+
+pub(in crate::accounts) const TRANSFER_BASE_FEE: &str = "accounts/transfer_base_fee";
+const COMPONENT_PREFIX: &str = "accounts/";
+const BALANCE_PREFIX: &str = "balance/";
+const NONCE: &str = "nonce";
+
+/// Example: `accounts/gGhH....zZ4=/balance/`.
+///                   |base64 chars|
+pub(in crate::accounts) fn balance_prefix<TAddress: AddressBytes>(address: &TAddress) -> String {
+    format!(
+        "{}/{BALANCE_PREFIX}",
+        AccountPrefixer::new(COMPONENT_PREFIX, address)
+    )
+}
+
+/// Example: `accounts/gGhH....zZ4=/balance/0202....0202`.
+///                   |base64 chars|       |64 hex chars|
+pub(in crate::accounts) fn balance<'a, TAddress, TAsset>(
+    address: &TAddress,
+    asset: &'a TAsset,
+) -> String
+where
+    TAddress: AddressBytes,
+    &'a TAsset: Into<Cow<'a, IbcPrefixed>>,
+{
+    format!(
+        "{}/{BALANCE_PREFIX}{}",
+        AccountPrefixer::new(COMPONENT_PREFIX, address),
+        Asset::from(asset)
+    )
+}
+
+/// Example: `accounts/gGhH....zZ4=/nonce`.
+///                   |base64 chars|
+pub(in crate::accounts) fn nonce<TAddress: AddressBytes>(address: &TAddress) -> String {
+    format!(
+        "{}/{NONCE}",
+        AccountPrefixer::new(COMPONENT_PREFIX, address)
+    )
+}
+
+pub(in crate::accounts) fn extract_asset_from_key(key: &str) -> Result<IbcPrefixed> {
+    Ok(key
+        .strip_prefix(COMPONENT_PREFIX)
+        .and_then(|s| s.split_once(BALANCE_PREFIX).map(|(_, asset)| asset))
+        .ok_or_eyre("failed to strip prefix from account balance key")?
+        .parse::<Asset>()
+        .wrap_err("failed to parse storage key suffix as address hunk")?
+        .get())
+}
+
+#[cfg(test)]
+mod tests {
+    use astria_core::primitive::v1::{
+        asset::Denom,
+        Address,
+    };
+
+    use super::*;
+
+    fn address() -> Address {
+        "astria1rsxyjrcm255ds9euthjx6yc3vrjt9sxrm9cfgm"
+            .parse()
+            .unwrap()
+    }
+
+    fn asset() -> Denom {
+        "an/asset/with/a/prefix".parse().unwrap()
+    }
+
+    #[test]
+    fn keys_should_not_change() {
+        insta::assert_snapshot!(TRANSFER_BASE_FEE);
+        insta::assert_snapshot!(balance(&address(), &asset()));
+        insta::assert_snapshot!(nonce(&address()));
+    }
+
+    #[test]
+    fn keys_should_have_component_prefix() {
+        assert!(TRANSFER_BASE_FEE.starts_with(COMPONENT_PREFIX));
+        assert!(balance(&address(), &asset()).starts_with(COMPONENT_PREFIX));
+        assert!(nonce(&address()).starts_with(COMPONENT_PREFIX));
+    }
+
+    #[test]
+    fn balance_prefix_should_be_prefix_of_balance_key() {
+        assert!(balance(&address(), &asset()).starts_with(&balance_prefix(&address())));
+    }
+
+    #[test]
+    fn should_extract_asset_from_key() {
+        let asset = IbcPrefixed::new([2; 32]);
+        let key = balance(&[1; 20], &asset);
+        let recovered_asset = extract_asset_from_key(&key).unwrap();
+        assert_eq!(asset, recovered_asset);
+    }
+}
diff --git a/crates/astria-sequencer/src/accounts/storage/mod.rs b/crates/astria-sequencer/src/accounts/storage/mod.rs
index 5fb23de750..8d61ec9f93 100644
--- a/crates/astria-sequencer/src/accounts/storage/mod.rs
+++ b/crates/astria-sequencer/src/accounts/storage/mod.rs
@@ -1,3 +1,4 @@
+pub(super) mod keys;
 mod values;
 
 pub(crate) use values::Value;
diff --git a/crates/astria-sequencer/src/accounts/storage/snapshots/astria_sequencer__accounts__storage__keys__tests__keys_should_not_change-2.snap b/crates/astria-sequencer/src/accounts/storage/snapshots/astria_sequencer__accounts__storage__keys__tests__keys_should_not_change-2.snap
new file mode 100644
index 0000000000..f3ff1952e1
--- /dev/null
+++ b/crates/astria-sequencer/src/accounts/storage/snapshots/astria_sequencer__accounts__storage__keys__tests__keys_should_not_change-2.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/accounts/storage/keys.rs
+assertion_line: 90
+expression: "balance(&address(), &asset())"
+---
+accounts/HAxJDxtVKNgXPF3kbRMRYOSywMM=/balance/ibc/be429a02d00837245167a2616674a979a2ac6f9806468b48a975b156ad711320
diff --git a/crates/astria-sequencer/src/accounts/storage/snapshots/astria_sequencer__accounts__storage__keys__tests__keys_should_not_change-3.snap b/crates/astria-sequencer/src/accounts/storage/snapshots/astria_sequencer__accounts__storage__keys__tests__keys_should_not_change-3.snap
new file mode 100644
index 0000000000..6febfe41e9
--- /dev/null
+++ b/crates/astria-sequencer/src/accounts/storage/snapshots/astria_sequencer__accounts__storage__keys__tests__keys_should_not_change-3.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/accounts/storage/keys.rs
+assertion_line: 91
+expression: nonce(&address())
+---
+accounts/HAxJDxtVKNgXPF3kbRMRYOSywMM=/nonce
diff --git a/crates/astria-sequencer/src/accounts/storage/snapshots/astria_sequencer__accounts__storage__keys__tests__keys_should_not_change.snap b/crates/astria-sequencer/src/accounts/storage/snapshots/astria_sequencer__accounts__storage__keys__tests__keys_should_not_change.snap
new file mode 100644
index 0000000000..a57562a2da
--- /dev/null
+++ b/crates/astria-sequencer/src/accounts/storage/snapshots/astria_sequencer__accounts__storage__keys__tests__keys_should_not_change.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/accounts/storage/keys.rs
+assertion_line: 79
+expression: TRANSFER_BASE_FEE_KEY
+---
+accounts/transfer_base_fee
diff --git a/crates/astria-sequencer/src/address/state_ext.rs b/crates/astria-sequencer/src/address/state_ext.rs
index a0c074777b..0f5cd5bf30 100644
--- a/crates/astria-sequencer/src/address/state_ext.rs
+++ b/crates/astria-sequencer/src/address/state_ext.rs
@@ -18,12 +18,12 @@ use cnidarium::{
 };
 use tracing::instrument;
 
-use super::storage;
+use super::storage::{
+    self,
+    keys,
+};
 use crate::storage::StoredValue;
 
-const BASE_PREFIX_KEY: &str = "prefixes/base";
-const IBC_COMPAT_PREFIX_KEY: &str = "prefixes/ibc-compat";
-
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
     async fn ensure_base_prefix(&self, address: &Address<Bech32m>) -> Result<()> {
@@ -54,7 +54,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all, err)]
     async fn get_base_prefix(&self) -> Result<String> {
         let Some(bytes) = self
-            .get_raw(BASE_PREFIX_KEY)
+            .get_raw(keys::BASE_PREFIX)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading address base prefix from state")?
@@ -69,7 +69,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all, err)]
     async fn get_ibc_compat_prefix(&self) -> Result<String> {
         let Some(bytes) = self
-            .get_raw(IBC_COMPAT_PREFIX_KEY)
+            .get_raw(keys::IBC_COMPAT_PREFIX)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading address ibc compat prefix from state")?
@@ -91,7 +91,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::AddressPrefix::from(prefix.as_str()))
             .serialize()
             .context("failed to serialize base prefix")?;
-        self.put_raw(BASE_PREFIX_KEY.to_string(), bytes);
+        self.put_raw(keys::BASE_PREFIX.to_string(), bytes);
         Ok(())
     }
 
@@ -100,7 +100,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::AddressPrefix::from(prefix.as_str()))
             .serialize()
             .context("failed to serialize ibc-compat prefix")?;
-        self.put_raw(IBC_COMPAT_PREFIX_KEY.to_string(), bytes);
+        self.put_raw(keys::IBC_COMPAT_PREFIX.to_string(), bytes);
         Ok(())
     }
 }
@@ -111,10 +111,7 @@ impl<T: StateWrite> StateWriteExt for T {}
 mod tests {
     use cnidarium::StateDelta;
 
-    use super::{
-        StateReadExt as _,
-        StateWriteExt as _,
-    };
+    use super::*;
 
     #[tokio::test]
     async fn put_and_get_base_prefix() {
diff --git a/crates/astria-sequencer/src/address/storage/keys.rs b/crates/astria-sequencer/src/address/storage/keys.rs
new file mode 100644
index 0000000000..af58a1d79f
--- /dev/null
+++ b/crates/astria-sequencer/src/address/storage/keys.rs
@@ -0,0 +1,21 @@
+pub(in crate::address) const BASE_PREFIX: &str = "address/prefixes/base";
+pub(in crate::address) const IBC_COMPAT_PREFIX: &str = "address/prefixes/ibc_compat";
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const COMPONENT_PREFIX: &str = "address/";
+
+    #[test]
+    fn keys_should_not_change() {
+        insta::assert_snapshot!(BASE_PREFIX);
+        insta::assert_snapshot!(IBC_COMPAT_PREFIX);
+    }
+
+    #[test]
+    fn keys_should_have_component_prefix() {
+        assert!(BASE_PREFIX.starts_with(COMPONENT_PREFIX));
+        assert!(IBC_COMPAT_PREFIX.starts_with(COMPONENT_PREFIX));
+    }
+}
diff --git a/crates/astria-sequencer/src/address/storage/mod.rs b/crates/astria-sequencer/src/address/storage/mod.rs
index 9d97b02d12..66527bffe6 100644
--- a/crates/astria-sequencer/src/address/storage/mod.rs
+++ b/crates/astria-sequencer/src/address/storage/mod.rs
@@ -1,3 +1,4 @@
+pub(super) mod keys;
 mod values;
 
 pub(super) use values::AddressPrefix;
diff --git a/crates/astria-sequencer/src/address/storage/snapshots/astria_sequencer__address__storage__keys__tests__keys_should_not_change-2.snap b/crates/astria-sequencer/src/address/storage/snapshots/astria_sequencer__address__storage__keys__tests__keys_should_not_change-2.snap
new file mode 100644
index 0000000000..78e5051afb
--- /dev/null
+++ b/crates/astria-sequencer/src/address/storage/snapshots/astria_sequencer__address__storage__keys__tests__keys_should_not_change-2.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/address/storage/keys.rs
+assertion_line: 11
+expression: IBC_COMPAT_PREFIX_KEY
+---
+address/prefixes/ibc_compat
diff --git a/crates/astria-sequencer/src/address/storage/snapshots/astria_sequencer__address__storage__keys__tests__keys_should_not_change.snap b/crates/astria-sequencer/src/address/storage/snapshots/astria_sequencer__address__storage__keys__tests__keys_should_not_change.snap
new file mode 100644
index 0000000000..d0121e06ae
--- /dev/null
+++ b/crates/astria-sequencer/src/address/storage/snapshots/astria_sequencer__address__storage__keys__tests__keys_should_not_change.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/address/storage/keys.rs
+assertion_line: 10
+expression: BASE_PREFIX_KEY
+---
+address/prefixes/base
diff --git a/crates/astria-sequencer/src/app/snapshots/astria_sequencer__app__tests_breaking_changes__app_execute_transaction_with_every_action_snapshot.snap b/crates/astria-sequencer/src/app/snapshots/astria_sequencer__app__tests_breaking_changes__app_execute_transaction_with_every_action_snapshot.snap
index ce1e424533..00738ae01d 100644
--- a/crates/astria-sequencer/src/app/snapshots/astria_sequencer__app__tests_breaking_changes__app_execute_transaction_with_every_action_snapshot.snap
+++ b/crates/astria-sequencer/src/app/snapshots/astria_sequencer__app__tests_breaking_changes__app_execute_transaction_with_every_action_snapshot.snap
@@ -4,36 +4,36 @@ assertion_line: 350
 expression: app.app_hash.as_bytes()
 ---
 [
-  152,
-  102,
+  65,
+  106,
+  222,
+  239,
+  12,
   37,
-  231,
-  116,
+  108,
+  130,
   83,
-  54,
-  99,
-  99,
-  61,
+  78,
+  58,
+  50,
+  178,
+  164,
+  93,
+  245,
   18,
-  167,
-  133,
-  246,
-  157,
-  153,
-  240,
   12,
-  160,
-  204,
-  116,
-  164,
-  109,
-  125,
-  163,
-  141,
-  253,
-  161,
-  54,
-  116,
-  76,
-  131
+  205,
+  129,
+  14,
+  158,
+  134,
+  107,
+  50,
+  190,
+  88,
+  71,
+  110,
+  9,
+  148,
+  233
 ]
diff --git a/crates/astria-sequencer/src/app/snapshots/astria_sequencer__app__tests_breaking_changes__app_finalize_block_snapshot.snap b/crates/astria-sequencer/src/app/snapshots/astria_sequencer__app__tests_breaking_changes__app_finalize_block_snapshot.snap
index 991e89c41c..e36d49f879 100644
--- a/crates/astria-sequencer/src/app/snapshots/astria_sequencer__app__tests_breaking_changes__app_finalize_block_snapshot.snap
+++ b/crates/astria-sequencer/src/app/snapshots/astria_sequencer__app__tests_breaking_changes__app_finalize_block_snapshot.snap
@@ -1,39 +1,39 @@
 ---
 source: crates/astria-sequencer/src/app/tests_breaking_changes.rs
-assertion_line: 159
+assertion_line: 157
 expression: app.app_hash.as_bytes()
 ---
 [
-  185,
-  5,
-  77,
-  15,
-  122,
-  4,
-  105,
+  65,
+  14,
+  103,
+  92,
+  219,
+  56,
+  251,
+  135,
+  182,
+  207,
+  215,
+  245,
+  234,
+  148,
+  33,
   34,
-  166,
-  43,
-  138,
-  143,
-  70,
-  189,
-  121,
-  106,
-  150,
-  128,
-  112,
+  179,
+  40,
+  146,
+  17,
+  236,
+  227,
+  125,
+  197,
+  76,
   142,
-  173,
-  98,
-  148,
-  152,
-  2,
-  3,
-  100,
-  153,
-  98,
-  154,
-  77,
-  199
+  194,
+  180,
+  9,
+  157,
+  73,
+  63
 ]
diff --git a/crates/astria-sequencer/src/app/snapshots/astria_sequencer__app__tests_breaking_changes__app_genesis_snapshot.snap b/crates/astria-sequencer/src/app/snapshots/astria_sequencer__app__tests_breaking_changes__app_genesis_snapshot.snap
index 30a896d96f..d1fd6ce989 100644
--- a/crates/astria-sequencer/src/app/snapshots/astria_sequencer__app__tests_breaking_changes__app_genesis_snapshot.snap
+++ b/crates/astria-sequencer/src/app/snapshots/astria_sequencer__app__tests_breaking_changes__app_genesis_snapshot.snap
@@ -1,39 +1,39 @@
 ---
 source: crates/astria-sequencer/src/app/tests_breaking_changes.rs
-assertion_line: 78
+assertion_line: 77
 expression: app.app_hash.as_bytes()
 ---
 [
-  216,
-  255,
-  55,
-  240,
+  66,
+  163,
+  122,
   253,
-  150,
-  85,
-  195,
-  135,
-  107,
-  242,
-  140,
-  90,
-  79,
-  175,
-  169,
-  15,
-  89,
-  132,
   159,
-  196,
-  65,
-  113,
-  174,
-  207,
-  46,
-  107,
-  126,
-  6,
+  247,
+  85,
+  105,
+  254,
+  245,
+  230,
+  91,
+  25,
+  173,
+  179,
+  227,
+  231,
+  2,
+  69,
+  165,
   1,
-  239,
-  84
+  169,
+  100,
+  210,
+  97,
+  33,
+  91,
+  87,
+  140,
+  222,
+  83,
+  57
 ]
diff --git a/crates/astria-sequencer/src/app/state_ext.rs b/crates/astria-sequencer/src/app/state_ext.rs
index cd51110c84..b9a2e3b78e 100644
--- a/crates/astria-sequencer/src/app/state_ext.rs
+++ b/crates/astria-sequencer/src/app/state_ext.rs
@@ -14,24 +14,18 @@ use cnidarium::{
 use tendermint::Time;
 use tracing::instrument;
 
-use super::storage;
+use super::storage::{
+    self,
+    keys,
+};
 use crate::storage::StoredValue;
 
-const CHAIN_ID_KEY: &str = "chain_id";
-const REVISION_NUMBER_KEY: &str = "revision_number";
-const BLOCK_HEIGHT_KEY: &str = "block_height";
-const BLOCK_TIMESTAMP_KEY: &str = "block_timestamp";
-
-fn storage_version_by_height_key(height: u64) -> Vec<u8> {
-    format!("storage_version/{height}").into()
-}
-
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_chain_id(&self) -> Result<tendermint::chain::Id> {
         let Some(bytes) = self
-            .get_raw(CHAIN_ID_KEY)
+            .get_raw(keys::CHAIN_ID)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read raw chain_id from state")?
@@ -46,7 +40,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_revision_number(&self) -> Result<u64> {
         let Some(bytes) = self
-            .get_raw(REVISION_NUMBER_KEY)
+            .get_raw(keys::REVISION_NUMBER)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read raw revision number from state")?
@@ -61,7 +55,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_block_height(&self) -> Result<u64> {
         let Some(bytes) = self
-            .get_raw(BLOCK_HEIGHT_KEY)
+            .get_raw(keys::BLOCK_HEIGHT)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read raw block_height from state")?
@@ -76,7 +70,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_block_timestamp(&self) -> Result<Time> {
         let Some(bytes) = self
-            .get_raw(BLOCK_TIMESTAMP_KEY)
+            .get_raw(keys::BLOCK_TIMESTAMP)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read raw block_timestamp from state")?
@@ -92,9 +86,9 @@ pub(crate) trait StateReadExt: StateRead {
     async fn get_storage_version_by_height(&self, height: u64) -> Result<u64> {
         use astria_eyre::eyre::WrapErr as _;
 
-        let key = storage_version_by_height_key(height);
+        let key = keys::storage_version_by_height(height);
         let Some(bytes) = self
-            .nonverifiable_get_raw(&key)
+            .nonverifiable_get_raw(key.as_bytes())
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read raw storage_version from state")?
@@ -117,7 +111,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::ChainId::from(&chain_id))
             .serialize()
             .context("failed to serialize chain id")?;
-        self.put_raw(CHAIN_ID_KEY.into(), bytes);
+        self.put_raw(keys::CHAIN_ID.into(), bytes);
         self.put_revision_number(revision_number)
     }
 
@@ -126,7 +120,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::RevisionNumber::from(revision_number))
             .serialize()
             .context("failed to serialize revision number")?;
-        self.put_raw(REVISION_NUMBER_KEY.into(), bytes);
+        self.put_raw(keys::REVISION_NUMBER.into(), bytes);
         Ok(())
     }
 
@@ -135,7 +129,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::BlockHeight::from(height))
             .serialize()
             .context("failed to serialize block height")?;
-        self.put_raw(BLOCK_HEIGHT_KEY.into(), bytes);
+        self.put_raw(keys::BLOCK_HEIGHT.into(), bytes);
         Ok(())
     }
 
@@ -144,7 +138,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::BlockTimestamp::from(timestamp))
             .serialize()
             .context("failed to serialize block timestamp")?;
-        self.put_raw(BLOCK_TIMESTAMP_KEY.into(), bytes);
+        self.put_raw(keys::BLOCK_TIMESTAMP.into(), bytes);
         Ok(())
     }
 
@@ -153,7 +147,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::StorageVersion::from(version))
             .serialize()
             .context("failed to serialize storage version")?;
-        self.nonverifiable_put_raw(storage_version_by_height_key(height), bytes);
+        self.nonverifiable_put_raw(keys::storage_version_by_height(height).into_bytes(), bytes);
         Ok(())
     }
 }
@@ -180,13 +174,8 @@ fn revision_number_from_chain_id(chain_id: &str) -> u64 {
 #[cfg(test)]
 mod tests {
     use cnidarium::StateDelta;
-    use tendermint::Time;
 
-    use super::{
-        revision_number_from_chain_id,
-        StateReadExt as _,
-        StateWriteExt as _,
-    };
+    use super::*;
 
     #[test]
     fn revision_number_from_chain_id_regex() {
diff --git a/crates/astria-sequencer/src/app/storage/keys.rs b/crates/astria-sequencer/src/app/storage/keys.rs
new file mode 100644
index 0000000000..564fab2cdf
--- /dev/null
+++ b/crates/astria-sequencer/src/app/storage/keys.rs
@@ -0,0 +1,33 @@
+pub(in crate::app) const CHAIN_ID: &str = "app/chain_id";
+pub(in crate::app) const REVISION_NUMBER: &str = "app/revision_number";
+pub(in crate::app) const BLOCK_HEIGHT: &str = "app/block_height";
+pub(in crate::app) const BLOCK_TIMESTAMP: &str = "app/block_timestamp";
+
+pub(in crate::app) fn storage_version_by_height(height: u64) -> String {
+    format!("app/storage_version/{height}")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const COMPONENT_PREFIX: &str = "app/";
+
+    #[test]
+    fn keys_should_not_change() {
+        insta::assert_snapshot!(CHAIN_ID);
+        insta::assert_snapshot!(REVISION_NUMBER);
+        insta::assert_snapshot!(BLOCK_HEIGHT);
+        insta::assert_snapshot!(BLOCK_TIMESTAMP);
+        insta::assert_snapshot!(storage_version_by_height(42));
+    }
+
+    #[test]
+    fn keys_should_have_component_prefix() {
+        assert!(CHAIN_ID.starts_with(COMPONENT_PREFIX));
+        assert!(REVISION_NUMBER.starts_with(COMPONENT_PREFIX));
+        assert!(BLOCK_HEIGHT.starts_with(COMPONENT_PREFIX));
+        assert!(BLOCK_TIMESTAMP.starts_with(COMPONENT_PREFIX));
+        assert!(storage_version_by_height(42).starts_with(COMPONENT_PREFIX));
+    }
+}
diff --git a/crates/astria-sequencer/src/app/storage/mod.rs b/crates/astria-sequencer/src/app/storage/mod.rs
index 34b0d24cda..964bad6a6f 100644
--- a/crates/astria-sequencer/src/app/storage/mod.rs
+++ b/crates/astria-sequencer/src/app/storage/mod.rs
@@ -1,3 +1,4 @@
+pub(super) mod keys;
 mod values;
 
 pub(crate) use values::Value;
diff --git a/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change-2.snap b/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change-2.snap
new file mode 100644
index 0000000000..5ef5391478
--- /dev/null
+++ b/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change-2.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/app/storage/keys.rs
+assertion_line: 21
+expression: REVISION_NUMBER_KEY
+---
+app/revision_number
diff --git a/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change-3.snap b/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change-3.snap
new file mode 100644
index 0000000000..4c70738ab6
--- /dev/null
+++ b/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change-3.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/app/storage/keys.rs
+assertion_line: 22
+expression: BLOCK_HEIGHT_KEY
+---
+app/block_height
diff --git a/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change-4.snap b/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change-4.snap
new file mode 100644
index 0000000000..ac8904c633
--- /dev/null
+++ b/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change-4.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/app/storage/keys.rs
+assertion_line: 23
+expression: BLOCK_TIMESTAMP_KEY
+---
+app/block_timestamp
diff --git a/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change-5.snap b/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change-5.snap
new file mode 100644
index 0000000000..2129ee5473
--- /dev/null
+++ b/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change-5.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/app/storage/keys.rs
+assertion_line: 22
+expression: storage_version_by_height(42)
+---
+app/storage_version/42
diff --git a/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change.snap b/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change.snap
new file mode 100644
index 0000000000..d90a517589
--- /dev/null
+++ b/crates/astria-sequencer/src/app/storage/snapshots/astria_sequencer__app__storage__keys__tests__keys_should_not_change.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/app/storage/keys.rs
+assertion_line: 18
+expression: CHAIN_ID_KEY
+---
+app/chain_id
diff --git a/crates/astria-sequencer/src/assets/snapshots/astria_sequencer__assets__state_ext__tests__storage_keys_are_unchanged-2.snap b/crates/astria-sequencer/src/assets/snapshots/astria_sequencer__assets__state_ext__tests__storage_keys_are_unchanged-2.snap
deleted file mode 100644
index 8c31993c79..0000000000
--- a/crates/astria-sequencer/src/assets/snapshots/astria_sequencer__assets__state_ext__tests__storage_keys_are_unchanged-2.snap
+++ /dev/null
@@ -1,5 +0,0 @@
----
-source: crates/astria-sequencer/src/assets/state_ext.rs
-expression: block_fees_key(&trace_prefixed)
----
-block_fees/ce072174ebc356c6ead681d61ab417ee72fdedd8155eb76478ece374bb04dc1d
diff --git a/crates/astria-sequencer/src/assets/snapshots/astria_sequencer__assets__state_ext__tests__storage_keys_are_unchanged-3.snap b/crates/astria-sequencer/src/assets/snapshots/astria_sequencer__assets__state_ext__tests__storage_keys_are_unchanged-3.snap
deleted file mode 100644
index a3e273ee76..0000000000
--- a/crates/astria-sequencer/src/assets/snapshots/astria_sequencer__assets__state_ext__tests__storage_keys_are_unchanged-3.snap
+++ /dev/null
@@ -1,5 +0,0 @@
----
-source: crates/astria-sequencer/src/assets/state_ext.rs
-expression: fee_asset_key(trace_prefixed)
----
-fee_asset/ce072174ebc356c6ead681d61ab417ee72fdedd8155eb76478ece374bb04dc1d
diff --git a/crates/astria-sequencer/src/assets/snapshots/astria_sequencer__assets__state_ext__tests__storage_keys_are_unchanged.snap b/crates/astria-sequencer/src/assets/snapshots/astria_sequencer__assets__state_ext__tests__storage_keys_are_unchanged.snap
deleted file mode 100644
index 3ad210d6a2..0000000000
--- a/crates/astria-sequencer/src/assets/snapshots/astria_sequencer__assets__state_ext__tests__storage_keys_are_unchanged.snap
+++ /dev/null
@@ -1,5 +0,0 @@
----
-source: crates/astria-sequencer/src/assets/state_ext.rs
-expression: asset_storage_key(asset)
----
-asset/be429a02d00837245167a2616674a979a2ac6f9806468b48a975b156ad711320
diff --git a/crates/astria-sequencer/src/assets/state_ext.rs b/crates/astria-sequencer/src/assets/state_ext.rs
index a8cea703cd..0597bc5801 100644
--- a/crates/astria-sequencer/src/assets/state_ext.rs
+++ b/crates/astria-sequencer/src/assets/state_ext.rs
@@ -1,4 +1,12 @@
-use astria_core::primitive::v1::asset;
+use std::{
+    borrow::Cow,
+    fmt::Display,
+};
+
+use astria_core::{
+    primitive::v1::asset,
+    Protobuf,
+};
 use astria_eyre::{
     anyhow_to_eyre,
     eyre::{
@@ -20,52 +28,24 @@ use tendermint::abci::{
 };
 use tracing::instrument;
 
-use super::storage;
+use super::storage::{
+    self,
+    keys::{
+        self,
+        extract_asset_from_block_fees_key,
+        extract_asset_from_fee_asset_key,
+    },
+};
 use crate::storage::StoredValue;
 
-const BLOCK_FEES_PREFIX: &str = "block_fees/";
-const FEE_ASSET_PREFIX: &str = "fee_asset/";
-const NATIVE_ASSET_KEY: &str = "nativeasset";
-
-fn asset_storage_key<'a, TAsset>(asset: &'a TAsset) -> String
-where
-    asset::IbcPrefixed: From<&'a TAsset>,
-{
-    format!("asset/{}", crate::storage_keys::hunks::Asset::from(asset))
-}
-
-fn block_fees_key<'a, TAsset>(asset: &'a TAsset) -> String
-where
-    asset::IbcPrefixed: From<&'a TAsset>,
-{
-    format!(
-        "{BLOCK_FEES_PREFIX}{}",
-        crate::storage_keys::hunks::Asset::from(asset)
-    )
-}
-
-fn fee_asset_key<'a, TAsset>(asset: &'a TAsset) -> String
-where
-    asset::IbcPrefixed: From<&'a TAsset>,
-{
-    format!(
-        "{FEE_ASSET_PREFIX}{}",
-        crate::storage_keys::hunks::Asset::from(asset)
-    )
-}
-
 /// Creates `abci::Event` of kind `tx.fees` for sequencer fee reporting
-fn construct_tx_fee_event<T: std::fmt::Display>(
-    asset: &T,
-    fee_amount: u128,
-    action_type: String,
-) -> Event {
+fn construct_tx_fee_event<P: Protobuf, T: Display>(asset: &T, fee_amount: u128) -> Event {
     Event::new(
         "tx.fees",
         [
             ("asset", asset.to_string()).index(),
             ("feeAmount", fee_amount.to_string()).index(),
-            ("actionType", action_type).index(),
+            ("actionType", P::full_name()).index(),
         ],
     )
 }
@@ -75,7 +55,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_native_asset(&self) -> Result<asset::TracePrefixed> {
         let Some(bytes) = self
-            .get_raw(NATIVE_ASSET_KEY)
+            .get_raw(keys::NATIVE_ASSET)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read raw native asset from state")?
@@ -93,10 +73,10 @@ pub(crate) trait StateReadExt: StateRead {
     async fn has_ibc_asset<'a, TAsset>(&self, asset: &'a TAsset) -> Result<bool>
     where
         TAsset: Sync,
-        asset::IbcPrefixed: From<&'a TAsset>,
+        &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
     {
         Ok(self
-            .get_raw(&asset_storage_key(asset))
+            .get_raw(&keys::asset(asset))
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw asset from state")?
@@ -109,7 +89,7 @@ pub(crate) trait StateReadExt: StateRead {
         asset: &asset::IbcPrefixed,
     ) -> Result<Option<asset::TracePrefixed>> {
         let Some(bytes) = self
-            .get_raw(&asset_storage_key(asset))
+            .get_raw(&keys::asset(asset))
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw asset from state")?
@@ -129,18 +109,10 @@ pub(crate) trait StateReadExt: StateRead {
         let mut fees = Vec::new();
 
         let mut stream =
-            std::pin::pin!(self.nonverifiable_prefix_raw(BLOCK_FEES_PREFIX.as_bytes()));
+            std::pin::pin!(self.nonverifiable_prefix_raw(keys::BLOCK_FEES_PREFIX.as_bytes()));
         while let Some(Ok((key, bytes))) = stream.next().await {
-            // if the key isn't of the form `block_fees/{asset_id}`, then we have a bug
-            // in `put_block_fees`
-            let suffix = key
-                .strip_prefix(BLOCK_FEES_PREFIX.as_bytes())
-                .expect("prefix must always be present");
-            let asset = std::str::from_utf8(suffix)
-                .wrap_err("key suffix was not utf8 encoded; this should not happen")?
-                .parse::<crate::storage_keys::hunks::Asset>()
-                .wrap_err("failed to parse storage key suffix as address hunk")?
-                .get();
+            let asset =
+                extract_asset_from_block_fees_key(&key).wrap_err("failed to extract asset")?;
 
             let fee = StoredValue::deserialize(&bytes)
                 .and_then(|value| storage::Fee::try_from(value).map(u128::from))
@@ -156,10 +128,10 @@ pub(crate) trait StateReadExt: StateRead {
     async fn is_allowed_fee_asset<'a, TAsset>(&self, asset: &'a TAsset) -> Result<bool>
     where
         TAsset: Sync,
-        asset::IbcPrefixed: From<&'a TAsset>,
+        &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
     {
         Ok(self
-            .nonverifiable_get_raw(fee_asset_key(asset).as_bytes())
+            .nonverifiable_get_raw(keys::fee_asset(asset).as_bytes())
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read raw fee asset from state")?
@@ -170,18 +142,11 @@ pub(crate) trait StateReadExt: StateRead {
     async fn get_allowed_fee_assets(&self) -> Result<Vec<asset::IbcPrefixed>> {
         let mut assets = Vec::new();
 
-        let mut stream = std::pin::pin!(self.nonverifiable_prefix_raw(FEE_ASSET_PREFIX.as_bytes()));
+        let mut stream =
+            std::pin::pin!(self.nonverifiable_prefix_raw(keys::FEE_ASSET_PREFIX.as_bytes()));
         while let Some(Ok((key, _))) = stream.next().await {
-            // if the key isn't of the form `fee_asset/{asset_id}`, then we have a bug
-            // in `put_allowed_fee_asset`
-            let suffix = key
-                .strip_prefix(FEE_ASSET_PREFIX.as_bytes())
-                .expect("prefix must always be present");
-            let asset = std::str::from_utf8(suffix)
-                .wrap_err("key suffix was not utf8 encoded; this should not happen")?
-                .parse::<crate::storage_keys::hunks::Asset>()
-                .wrap_err("failed to parse storage key suffix as address hunk")?
-                .get();
+            let asset =
+                extract_asset_from_fee_asset_key(&key).wrap_err("failed to extract asset")?;
             assets.push(asset);
         }
 
@@ -198,13 +163,13 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::TracePrefixedDenom::from(&asset))
             .serialize()
             .context("failed to serialize native asset")?;
-        self.put_raw(NATIVE_ASSET_KEY.to_string(), bytes);
+        self.put_raw(keys::NATIVE_ASSET.to_string(), bytes);
         Ok(())
     }
 
     #[instrument(skip_all)]
     fn put_ibc_asset(&mut self, asset: asset::TracePrefixed) -> Result<()> {
-        let key = asset_storage_key(&asset);
+        let key = keys::asset(&asset);
         let bytes = StoredValue::from(storage::TracePrefixedDenom::from(&asset))
             .serialize()
             .wrap_err("failed to serialize ibc asset")?;
@@ -214,18 +179,18 @@ pub(crate) trait StateWriteExt: StateWrite {
 
     /// Adds `amount` to the block fees for `asset`.
     #[instrument(skip_all)]
-    async fn get_and_increase_block_fees<'a, TAsset>(
+    async fn get_and_increase_block_fees<'a, P, TAsset>(
         &mut self,
         asset: &'a TAsset,
         amount: u128,
-        action_type: String,
     ) -> Result<()>
     where
-        TAsset: Sync + std::fmt::Display,
-        asset::IbcPrefixed: From<&'a TAsset>,
+        TAsset: Sync + Display,
+        &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
+        P: Protobuf,
     {
-        let tx_fee_event = construct_tx_fee_event(asset, amount, action_type);
-        let block_fees_key = block_fees_key(asset);
+        let tx_fee_event = construct_tx_fee_event::<P, _>(asset, amount);
+        let block_fees_key = keys::block_fees(asset);
 
         let current_amount = self
             .nonverifiable_get_raw(block_fees_key.as_bytes())
@@ -246,7 +211,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::Fee::from(new_amount))
             .serialize()
             .wrap_err("failed to serialize block fees")?;
-        self.nonverifiable_put_raw(block_fees_key.into(), bytes);
+        self.nonverifiable_put_raw(block_fees_key.into_bytes(), bytes);
 
         self.record(tx_fee_event);
 
@@ -256,7 +221,7 @@ pub(crate) trait StateWriteExt: StateWrite {
     #[instrument(skip_all)]
     async fn clear_block_fees(&mut self) {
         let mut stream =
-            std::pin::pin!(self.nonverifiable_prefix_raw(BLOCK_FEES_PREFIX.as_bytes()));
+            std::pin::pin!(self.nonverifiable_prefix_raw(keys::BLOCK_FEES_PREFIX.as_bytes()));
         while let Some(Ok((key, _))) = stream.next().await {
             self.nonverifiable_delete(key);
         }
@@ -265,20 +230,20 @@ pub(crate) trait StateWriteExt: StateWrite {
     #[instrument(skip_all)]
     fn delete_allowed_fee_asset<'a, TAsset>(&mut self, asset: &'a TAsset)
     where
-        asset::IbcPrefixed: From<&'a TAsset>,
+        &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
     {
-        self.nonverifiable_delete(fee_asset_key(asset).into());
+        self.nonverifiable_delete(keys::fee_asset(asset).into_bytes());
     }
 
     #[instrument(skip_all)]
     fn put_allowed_fee_asset<'a, TAsset>(&mut self, asset: &'a TAsset) -> Result<()>
     where
-        asset::IbcPrefixed: From<&'a TAsset>,
+        &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
     {
         let bytes = StoredValue::Unit
             .serialize()
             .context("failed to serialize unit for allowed fee asset")?;
-        self.nonverifiable_put_raw(fee_asset_key(asset).into(), bytes);
+        self.nonverifiable_put_raw(keys::fee_asset(asset).into_bytes(), bytes);
         Ok(())
     }
 }
@@ -289,16 +254,10 @@ impl<T: StateWrite> StateWriteExt for T {}
 mod tests {
     use std::collections::HashSet;
 
-    use astria_core::primitive::v1::asset;
+    use astria_core::protocol::transaction::v1alpha1::action::Transfer;
     use cnidarium::StateDelta;
 
-    use super::{
-        asset_storage_key,
-        block_fees_key,
-        fee_asset_key,
-        StateReadExt as _,
-        StateWriteExt as _,
-    };
+    use super::*;
 
     fn asset() -> asset::Denom {
         "asset".parse().unwrap()
@@ -363,7 +322,7 @@ mod tests {
         let asset = asset_0();
         let amount = 100u128;
         state
-            .get_and_increase_block_fees(&asset, amount, "test".into())
+            .get_and_increase_block_fees::<Transfer, _>(&asset, amount)
             .await
             .unwrap();
 
@@ -389,11 +348,11 @@ mod tests {
         let amount_second = 200u128;
 
         state
-            .get_and_increase_block_fees(&asset_first, amount_first, "test".into())
+            .get_and_increase_block_fees::<Transfer, _>(&asset_first, amount_first)
             .await
             .unwrap();
         state
-            .get_and_increase_block_fees(&asset_second, amount_second, "test".into())
+            .get_and_increase_block_fees::<Transfer, _>(&asset_second, amount_second)
             .await
             .unwrap();
         // holds expected
@@ -643,31 +602,4 @@ mod tests {
             "delete for allowed fee asset did not behave as expected"
         );
     }
-
-    #[test]
-    fn storage_keys_are_unchanged() {
-        let asset = "an/asset/with/a/prefix"
-            .parse::<astria_core::primitive::v1::asset::Denom>()
-            .unwrap();
-        assert_eq!(
-            asset_storage_key(&asset),
-            asset_storage_key(&asset.to_ibc_prefixed()),
-        );
-        insta::assert_snapshot!(asset_storage_key(&asset));
-
-        let trace_prefixed = "a/denom/with/a/prefix"
-            .parse::<astria_core::primitive::v1::asset::Denom>()
-            .unwrap();
-        assert_eq!(
-            block_fees_key(&trace_prefixed),
-            block_fees_key(&trace_prefixed.to_ibc_prefixed()),
-        );
-        insta::assert_snapshot!(block_fees_key(&trace_prefixed));
-
-        assert_eq!(
-            fee_asset_key(&trace_prefixed),
-            fee_asset_key(&trace_prefixed.to_ibc_prefixed()),
-        );
-        insta::assert_snapshot!(fee_asset_key(&trace_prefixed));
-    }
 }
diff --git a/crates/astria-sequencer/src/assets/storage/keys.rs b/crates/astria-sequencer/src/assets/storage/keys.rs
new file mode 100644
index 0000000000..028678f0cd
--- /dev/null
+++ b/crates/astria-sequencer/src/assets/storage/keys.rs
@@ -0,0 +1,106 @@
+use std::borrow::Cow;
+
+use astria_core::primitive::v1::asset::IbcPrefixed;
+use astria_eyre::eyre::{
+    eyre,
+    Result,
+    WrapErr as _,
+};
+
+use crate::storage::keys::Asset;
+
+pub(in crate::assets) const NATIVE_ASSET: &str = "assets/native_asset";
+pub(in crate::assets) const BLOCK_FEES_PREFIX: &str = "assets/block_fees/";
+pub(in crate::assets) const FEE_ASSET_PREFIX: &str = "assets/fee_asset/";
+
+/// Example: `assets/ibc/0101....0101`.
+///                     |64 hex chars|
+pub(in crate::assets) fn asset<'a, TAsset>(asset: &'a TAsset) -> String
+where
+    &'a TAsset: Into<Cow<'a, IbcPrefixed>>,
+{
+    format!("assets/{}", Asset::from(asset))
+}
+
+pub(in crate::assets) fn fee_asset<'a, TAsset>(asset: &'a TAsset) -> String
+where
+    &'a TAsset: Into<Cow<'a, IbcPrefixed>>,
+{
+    format!("{FEE_ASSET_PREFIX}{}", Asset::from(asset))
+}
+
+pub(in crate::assets) fn block_fees<'a, TAsset>(asset: &'a TAsset) -> String
+where
+    &'a TAsset: Into<Cow<'a, IbcPrefixed>>,
+{
+    format!("{BLOCK_FEES_PREFIX}{}", Asset::from(asset))
+}
+
+pub(in crate::assets) fn extract_asset_from_fee_asset_key(key: &[u8]) -> Result<IbcPrefixed> {
+    extract_asset_from_key(key, FEE_ASSET_PREFIX)
+        .wrap_err("failed to extract asset from fee asset key")
+}
+
+pub(in crate::assets) fn extract_asset_from_block_fees_key(key: &[u8]) -> Result<IbcPrefixed> {
+    extract_asset_from_key(key, BLOCK_FEES_PREFIX)
+        .wrap_err("failed to extract asset from fee asset key")
+}
+
+fn extract_asset_from_key(key: &[u8], prefix: &str) -> Result<IbcPrefixed> {
+    let key_str = std::str::from_utf8(key)
+        .wrap_err_with(|| format!("key `{}` not valid utf8", telemetry::display::hex(key),))?;
+    let suffix = key_str
+        .strip_prefix(prefix)
+        .ok_or_else(|| eyre!("key `{key_str}` did not have prefix `{prefix}`"))?;
+    suffix.parse().wrap_err_with(|| {
+        format!("failed to parse suffix `{suffix}` of key `{key_str}` as an ibc-prefixed asset",)
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use astria_core::primitive::v1::asset::Denom;
+
+    use super::*;
+
+    const COMPONENT_PREFIX: &str = "assets/";
+
+    fn test_asset() -> Denom {
+        "an/asset/with/a/prefix".parse().unwrap()
+    }
+
+    #[test]
+    fn keys_should_not_change() {
+        insta::assert_snapshot!(NATIVE_ASSET);
+        insta::assert_snapshot!(asset(&test_asset()));
+        insta::assert_snapshot!(fee_asset(&test_asset()));
+        insta::assert_snapshot!(block_fees(&test_asset()));
+    }
+
+    #[test]
+    fn keys_should_have_component_prefix() {
+        assert!(NATIVE_ASSET.starts_with(COMPONENT_PREFIX));
+        assert!(asset(&test_asset()).starts_with(COMPONENT_PREFIX));
+        assert!(fee_asset(&test_asset()).starts_with(COMPONENT_PREFIX));
+        assert!(block_fees(&test_asset()).starts_with(COMPONENT_PREFIX));
+    }
+
+    #[test]
+    fn prefixes_should_be_prefixes_of_relevant_keys() {
+        assert!(fee_asset(&test_asset()).starts_with(FEE_ASSET_PREFIX));
+        assert!(block_fees(&test_asset()).starts_with(BLOCK_FEES_PREFIX));
+    }
+
+    #[test]
+    fn should_extract_asset_from_key() {
+        let asset = IbcPrefixed::new([1; 32]);
+
+        let key = fee_asset(&asset);
+        let recovered_asset = extract_asset_from_fee_asset_key(key.as_bytes()).unwrap();
+        assert_eq!(asset, recovered_asset);
+
+        let key = block_fees(&asset);
+        let recovered_asset = extract_asset_from_block_fees_key(key.as_bytes()).unwrap();
+        assert_eq!(asset, recovered_asset);
+    }
+}
diff --git a/crates/astria-sequencer/src/assets/storage/mod.rs b/crates/astria-sequencer/src/assets/storage/mod.rs
index 84bbe13ac8..8551a44c91 100644
--- a/crates/astria-sequencer/src/assets/storage/mod.rs
+++ b/crates/astria-sequencer/src/assets/storage/mod.rs
@@ -1,3 +1,4 @@
+pub(super) mod keys;
 mod values;
 
 pub(crate) use values::Value;
diff --git a/crates/astria-sequencer/src/assets/storage/snapshots/astria_sequencer__assets__storage__keys__tests__keys_should_not_change-2.snap b/crates/astria-sequencer/src/assets/storage/snapshots/astria_sequencer__assets__storage__keys__tests__keys_should_not_change-2.snap
new file mode 100644
index 0000000000..f2b86e3f42
--- /dev/null
+++ b/crates/astria-sequencer/src/assets/storage/snapshots/astria_sequencer__assets__storage__keys__tests__keys_should_not_change-2.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/assets/storage/keys.rs
+assertion_line: 87
+expression: asset(&test_asset())
+---
+assets/ibc/be429a02d00837245167a2616674a979a2ac6f9806468b48a975b156ad711320
diff --git a/crates/astria-sequencer/src/assets/storage/snapshots/astria_sequencer__assets__storage__keys__tests__keys_should_not_change-3.snap b/crates/astria-sequencer/src/assets/storage/snapshots/astria_sequencer__assets__storage__keys__tests__keys_should_not_change-3.snap
new file mode 100644
index 0000000000..af4e0a2517
--- /dev/null
+++ b/crates/astria-sequencer/src/assets/storage/snapshots/astria_sequencer__assets__storage__keys__tests__keys_should_not_change-3.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/assets/storage/keys.rs
+assertion_line: 78
+expression: fee_asset(&test_asset())
+---
+assets/fee_asset/ibc/be429a02d00837245167a2616674a979a2ac6f9806468b48a975b156ad711320
diff --git a/crates/astria-sequencer/src/assets/storage/snapshots/astria_sequencer__assets__storage__keys__tests__keys_should_not_change-4.snap b/crates/astria-sequencer/src/assets/storage/snapshots/astria_sequencer__assets__storage__keys__tests__keys_should_not_change-4.snap
new file mode 100644
index 0000000000..632ba4055e
--- /dev/null
+++ b/crates/astria-sequencer/src/assets/storage/snapshots/astria_sequencer__assets__storage__keys__tests__keys_should_not_change-4.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/assets/storage/keys.rs
+assertion_line: 79
+expression: block_fees(&test_asset())
+---
+assets/block_fees/ibc/be429a02d00837245167a2616674a979a2ac6f9806468b48a975b156ad711320
diff --git a/crates/astria-sequencer/src/assets/storage/snapshots/astria_sequencer__assets__storage__keys__tests__keys_should_not_change.snap b/crates/astria-sequencer/src/assets/storage/snapshots/astria_sequencer__assets__storage__keys__tests__keys_should_not_change.snap
new file mode 100644
index 0000000000..b7c28d8f3f
--- /dev/null
+++ b/crates/astria-sequencer/src/assets/storage/snapshots/astria_sequencer__assets__storage__keys__tests__keys_should_not_change.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/assets/storage/keys.rs
+assertion_line: 84
+expression: NATIVE_ASSET_KEY
+---
+assets/native_asset
diff --git a/crates/astria-sequencer/src/authority/state_ext.rs b/crates/astria-sequencer/src/authority/state_ext.rs
index 38df2f7c5b..080a91bd82 100644
--- a/crates/astria-sequencer/src/authority/state_ext.rs
+++ b/crates/astria-sequencer/src/authority/state_ext.rs
@@ -17,7 +17,10 @@ use cnidarium::{
 use tracing::instrument;
 
 use super::{
-    storage,
+    storage::{
+        self,
+        keys,
+    },
     ValidatorSet,
 };
 use crate::{
@@ -25,16 +28,12 @@ use crate::{
     storage::StoredValue,
 };
 
-const SUDO_STORAGE_KEY: &str = "sudo";
-const VALIDATOR_SET_STORAGE_KEY: &str = "valset";
-const VALIDATOR_UPDATES_KEY: &[u8] = b"valupdates";
-
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_sudo_address(&self) -> Result<[u8; ADDRESS_LEN]> {
         let Some(bytes) = self
-            .get_raw(SUDO_STORAGE_KEY)
+            .get_raw(keys::SUDO)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw sudo key from state")?
@@ -50,7 +49,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_validator_set(&self) -> Result<ValidatorSet> {
         let Some(bytes) = self
-            .get_raw(VALIDATOR_SET_STORAGE_KEY)
+            .get_raw(keys::VALIDATOR_SET)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw validator set from state")?
@@ -66,7 +65,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_validator_updates(&self) -> Result<ValidatorSet> {
         let Some(bytes) = self
-            .nonverifiable_get_raw(VALIDATOR_UPDATES_KEY)
+            .nonverifiable_get_raw(keys::VALIDATOR_UPDATES.as_bytes())
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw validator updates from state")?
@@ -89,7 +88,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::AddressBytes::from(&address))
             .serialize()
             .wrap_err("failed to serialize sudo address")?;
-        self.put_raw(SUDO_STORAGE_KEY.to_string(), bytes);
+        self.put_raw(keys::SUDO.to_string(), bytes);
         Ok(())
     }
 
@@ -98,7 +97,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::ValidatorSet::from(&validator_set))
             .serialize()
             .wrap_err("failed to serialize validator set")?;
-        self.put_raw(VALIDATOR_SET_STORAGE_KEY.to_string(), bytes);
+        self.put_raw(keys::VALIDATOR_SET.to_string(), bytes);
         Ok(())
     }
 
@@ -107,13 +106,13 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::ValidatorSet::from(&validator_updates))
             .serialize()
             .wrap_err("failed to serialize validator updates")?;
-        self.nonverifiable_put_raw(VALIDATOR_UPDATES_KEY.to_vec(), bytes);
+        self.nonverifiable_put_raw(keys::VALIDATOR_UPDATES.into(), bytes);
         Ok(())
     }
 
     #[instrument(skip_all)]
     fn clear_validator_updates(&mut self) {
-        self.nonverifiable_delete(VALIDATOR_UPDATES_KEY.to_vec());
+        self.nonverifiable_delete(keys::VALIDATOR_UPDATES.into());
     }
 }
 
@@ -121,19 +120,12 @@ impl<T: StateWrite> StateWriteExt for T {}
 
 #[cfg(test)]
 mod tests {
-    use astria_core::{
-        primitive::v1::ADDRESS_LEN,
-        protocol::transaction::v1alpha1::action::ValidatorUpdate,
-    };
+    use astria_core::protocol::transaction::v1alpha1::action::ValidatorUpdate;
     use cnidarium::StateDelta;
 
-    use super::{
-        StateReadExt as _,
-        StateWriteExt as _,
-    };
+    use super::*;
     use crate::{
         address::StateWriteExt as _,
-        authority::ValidatorSet,
         test_utils::{
             verification_key,
             ASTRIA_PREFIX,
diff --git a/crates/astria-sequencer/src/authority/storage/keys.rs b/crates/astria-sequencer/src/authority/storage/keys.rs
new file mode 100644
index 0000000000..0120a0b425
--- /dev/null
+++ b/crates/astria-sequencer/src/authority/storage/keys.rs
@@ -0,0 +1,24 @@
+pub(in crate::authority) const SUDO: &str = "authority/sudo";
+pub(in crate::authority) const VALIDATOR_SET: &str = "authority/validator_set";
+pub(in crate::authority) const VALIDATOR_UPDATES: &str = "authority/validator_updates";
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const COMPONENT_PREFIX: &str = "authority/";
+
+    #[test]
+    fn keys_should_not_change() {
+        insta::assert_snapshot!(SUDO);
+        insta::assert_snapshot!(VALIDATOR_SET);
+        insta::assert_snapshot!(VALIDATOR_UPDATES);
+    }
+
+    #[test]
+    fn keys_should_have_component_prefix() {
+        assert!(SUDO.starts_with(COMPONENT_PREFIX));
+        assert!(VALIDATOR_SET.starts_with(COMPONENT_PREFIX));
+        assert!(VALIDATOR_UPDATES.starts_with(COMPONENT_PREFIX));
+    }
+}
diff --git a/crates/astria-sequencer/src/authority/storage/mod.rs b/crates/astria-sequencer/src/authority/storage/mod.rs
index 9d81d20d1a..cb52a74a3d 100644
--- a/crates/astria-sequencer/src/authority/storage/mod.rs
+++ b/crates/astria-sequencer/src/authority/storage/mod.rs
@@ -1,3 +1,4 @@
+pub(super) mod keys;
 mod values;
 
 pub(crate) use values::Value;
diff --git a/crates/astria-sequencer/src/authority/storage/snapshots/astria_sequencer__authority__storage__keys__tests__keys_should_not_change-2.snap b/crates/astria-sequencer/src/authority/storage/snapshots/astria_sequencer__authority__storage__keys__tests__keys_should_not_change-2.snap
new file mode 100644
index 0000000000..2bbd4fa8d0
--- /dev/null
+++ b/crates/astria-sequencer/src/authority/storage/snapshots/astria_sequencer__authority__storage__keys__tests__keys_should_not_change-2.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/authority/storage/keys.rs
+assertion_line: 16
+expression: VALIDATOR_SET_STORAGE_KEY
+---
+authority/validator_set
diff --git a/crates/astria-sequencer/src/authority/storage/snapshots/astria_sequencer__authority__storage__keys__tests__keys_should_not_change-3.snap b/crates/astria-sequencer/src/authority/storage/snapshots/astria_sequencer__authority__storage__keys__tests__keys_should_not_change-3.snap
new file mode 100644
index 0000000000..1a0f29c99f
--- /dev/null
+++ b/crates/astria-sequencer/src/authority/storage/snapshots/astria_sequencer__authority__storage__keys__tests__keys_should_not_change-3.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/authority/storage/keys.rs
+assertion_line: 15
+expression: VALIDATOR_UPDATES
+---
+authority/validator_updates
diff --git a/crates/astria-sequencer/src/authority/storage/snapshots/astria_sequencer__authority__storage__keys__tests__keys_should_not_change.snap b/crates/astria-sequencer/src/authority/storage/snapshots/astria_sequencer__authority__storage__keys__tests__keys_should_not_change.snap
new file mode 100644
index 0000000000..a046006094
--- /dev/null
+++ b/crates/astria-sequencer/src/authority/storage/snapshots/astria_sequencer__authority__storage__keys__tests__keys_should_not_change.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/authority/storage/keys.rs
+assertion_line: 15
+expression: SUDO_STORAGE_KEY
+---
+authority/sudo
diff --git a/crates/astria-sequencer/src/bridge/bridge_lock_action.rs b/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
index f5270901ed..4adffe9172 100644
--- a/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
+++ b/crates/astria-sequencer/src/bridge/bridge_lock_action.rs
@@ -4,7 +4,6 @@ use astria_core::{
         Transfer,
     },
     sequencerblock::v1alpha1::block::Deposit,
-    Protobuf as _,
 };
 use astria_eyre::eyre::{
     ensure,
@@ -132,7 +131,7 @@ impl ActionHandler for BridgeLock {
         let fee = byte_cost_multiplier
             .saturating_mul(calculate_base_deposit_fee(&deposit).unwrap_or(u128::MAX));
         state
-            .get_and_increase_block_fees(&self.fee_asset, fee, Self::full_name())
+            .get_and_increase_block_fees::<Self, _>(&self.fee_asset, fee)
             .await
             .wrap_err("failed to add to block fees")?;
         state
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 68ff190ad9..ce2047d372 100644
--- a/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs
+++ b/crates/astria-sequencer/src/bridge/bridge_sudo_change_action.rs
@@ -1,7 +1,4 @@
-use astria_core::{
-    protocol::transaction::v1alpha1::action::BridgeSudoChange,
-    Protobuf as _,
-};
+use astria_core::protocol::transaction::v1alpha1::action::BridgeSudoChange;
 use astria_eyre::eyre::{
     bail,
     ensure,
@@ -81,7 +78,7 @@ impl ActionHandler for BridgeSudoChange {
             .await
             .wrap_err("failed to get bridge sudo change fee")?;
         state
-            .get_and_increase_block_fees(&self.fee_asset, fee, Self::full_name())
+            .get_and_increase_block_fees::<Self, _>(&self.fee_asset, fee)
             .await
             .wrap_err("failed to add to block fees")?;
         state
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 9f4138289b..5422e89fa1 100644
--- a/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs
+++ b/crates/astria-sequencer/src/bridge/init_bridge_account_action.rs
@@ -1,7 +1,6 @@
 use astria_core::{
     primitive::v1::Address,
     protocol::transaction::v1alpha1::action::InitBridgeAccount,
-    Protobuf as _,
 };
 use astria_eyre::eyre::{
     bail,
@@ -109,7 +108,7 @@ impl ActionHandler for InitBridgeAccount {
             )
             .wrap_err("failed to put bridge account withdrawer address")?;
         state
-            .get_and_increase_block_fees(&self.fee_asset, fee, Self::full_name())
+            .get_and_increase_block_fees::<Self, _>(&self.fee_asset, fee)
             .await
             .wrap_err("failed to get and increase block fees")?;
         state
diff --git a/crates/astria-sequencer/src/bridge/snapshots/astria_sequencer__bridge__state_ext__tests__storage_keys_have_not_changed-2.snap b/crates/astria-sequencer/src/bridge/snapshots/astria_sequencer__bridge__state_ext__tests__storage_keys_have_not_changed-2.snap
deleted file mode 100644
index ff90ccd2fd..0000000000
--- a/crates/astria-sequencer/src/bridge/snapshots/astria_sequencer__bridge__state_ext__tests__storage_keys_have_not_changed-2.snap
+++ /dev/null
@@ -1,6 +0,0 @@
----
-source: crates/astria-sequencer/src/bridge/state_ext.rs
-assertion_line: 812
-expression: asset_id_storage_key(&address)
----
-bridgeacc/1c0c490f1b5528d8173c5de46d131160e4b2c0c3/assetid
diff --git a/crates/astria-sequencer/src/bridge/snapshots/astria_sequencer__bridge__state_ext__tests__storage_keys_have_not_changed-3.snap b/crates/astria-sequencer/src/bridge/snapshots/astria_sequencer__bridge__state_ext__tests__storage_keys_have_not_changed-3.snap
deleted file mode 100644
index 0ce9c34aab..0000000000
--- a/crates/astria-sequencer/src/bridge/snapshots/astria_sequencer__bridge__state_ext__tests__storage_keys_have_not_changed-3.snap
+++ /dev/null
@@ -1,6 +0,0 @@
----
-source: crates/astria-sequencer/src/bridge/state_ext.rs
-assertion_line: 813
-expression: bridge_account_sudo_address_storage_key(&address)
----
-bsudo/1c0c490f1b5528d8173c5de46d131160e4b2c0c3
diff --git a/crates/astria-sequencer/src/bridge/snapshots/astria_sequencer__bridge__state_ext__tests__storage_keys_have_not_changed-4.snap b/crates/astria-sequencer/src/bridge/snapshots/astria_sequencer__bridge__state_ext__tests__storage_keys_have_not_changed-4.snap
deleted file mode 100644
index 408ac4f2d5..0000000000
--- a/crates/astria-sequencer/src/bridge/snapshots/astria_sequencer__bridge__state_ext__tests__storage_keys_have_not_changed-4.snap
+++ /dev/null
@@ -1,6 +0,0 @@
----
-source: crates/astria-sequencer/src/bridge/state_ext.rs
-assertion_line: 814
-expression: bridge_account_withdrawer_address_storage_key(&address)
----
-bwithdrawer/1c0c490f1b5528d8173c5de46d131160e4b2c0c3
diff --git a/crates/astria-sequencer/src/bridge/snapshots/astria_sequencer__bridge__state_ext__tests__storage_keys_have_not_changed.snap b/crates/astria-sequencer/src/bridge/snapshots/astria_sequencer__bridge__state_ext__tests__storage_keys_have_not_changed.snap
deleted file mode 100644
index 8f75044410..0000000000
--- a/crates/astria-sequencer/src/bridge/snapshots/astria_sequencer__bridge__state_ext__tests__storage_keys_have_not_changed.snap
+++ /dev/null
@@ -1,6 +0,0 @@
----
-source: crates/astria-sequencer/src/bridge/state_ext.rs
-assertion_line: 811
-expression: rollup_id_storage_key(&address)
----
-bridgeacc/1c0c490f1b5528d8173c5de46d131160e4b2c0c3/rollupid
diff --git a/crates/astria-sequencer/src/bridge/state_ext.rs b/crates/astria-sequencer/src/bridge/state_ext.rs
index 867ac9ecdd..c00b6f14d0 100644
--- a/crates/astria-sequencer/src/bridge/state_ext.rs
+++ b/crates/astria-sequencer/src/bridge/state_ext.rs
@@ -28,111 +28,16 @@ use tracing::{
     instrument,
 };
 
-use super::storage;
+use super::storage::{
+    self,
+    keys,
+};
 use crate::{
     accounts::AddressBytes,
     address,
     storage::StoredValue,
 };
 
-const BRIDGE_ACCOUNT_PREFIX: &str = "bridgeacc";
-const BRIDGE_ACCOUNT_SUDO_PREFIX: &str = "bsudo";
-const BRIDGE_ACCOUNT_WITHDRAWER_PREFIX: &str = "bwithdrawer";
-const DEPOSITS_EPHEMERAL_KEY: &str = "deposits";
-const DEPOSIT_PREFIX: &[u8] = b"deposit/";
-const INIT_BRIDGE_ACCOUNT_BASE_FEE_STORAGE_KEY: &str = "initbridgeaccfee";
-const BRIDGE_LOCK_BYTE_COST_MULTIPLIER_STORAGE_KEY: &str = "bridgelockmultiplier";
-const BRIDGE_SUDO_CHANGE_FEE_STORAGE_KEY: &str = "bridgesudofee";
-
-struct BridgeAccountKey<'a, T> {
-    prefix: &'static str,
-    address: &'a T,
-}
-
-impl<'a, T> std::fmt::Display for BridgeAccountKey<'a, T>
-where
-    T: AddressBytes,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.prefix)?;
-        f.write_str("/")?;
-        for byte in self.address.address_bytes() {
-            f.write_fmt(format_args!("{byte:02x}"))?;
-        }
-        Ok(())
-    }
-}
-
-fn rollup_id_storage_key<T: AddressBytes>(address: &T) -> String {
-    format!(
-        "{}/rollupid",
-        BridgeAccountKey {
-            prefix: BRIDGE_ACCOUNT_PREFIX,
-            address
-        }
-    )
-}
-
-fn asset_id_storage_key<T: AddressBytes>(address: &T) -> String {
-    format!(
-        "{}/assetid",
-        BridgeAccountKey {
-            prefix: BRIDGE_ACCOUNT_PREFIX,
-            address
-        }
-    )
-}
-
-fn deposit_storage_key(block_hash: &[u8; 32], rollup_id: &RollupId) -> Vec<u8> {
-    [DEPOSIT_PREFIX, block_hash, rollup_id.as_ref()].concat()
-}
-
-fn bridge_account_sudo_address_storage_key<T: AddressBytes>(address: &T) -> String {
-    format!(
-        "{}",
-        BridgeAccountKey {
-            prefix: BRIDGE_ACCOUNT_SUDO_PREFIX,
-            address
-        }
-    )
-}
-
-fn bridge_account_withdrawer_address_storage_key<T: AddressBytes>(address: &T) -> String {
-    format!(
-        "{}",
-        BridgeAccountKey {
-            prefix: BRIDGE_ACCOUNT_WITHDRAWER_PREFIX,
-            address
-        }
-    )
-}
-
-fn bridge_account_withdrawal_event_storage_key<T: AddressBytes>(
-    address: &T,
-    withdrawal_event_id: &str,
-) -> String {
-    format!(
-        "{}/withdrawalevent/{}",
-        BridgeAccountKey {
-            prefix: BRIDGE_ACCOUNT_PREFIX,
-            address
-        },
-        withdrawal_event_id
-    )
-}
-
-fn last_transaction_id_for_bridge_account_storage_key<T: AddressBytes>(address: &T) -> Vec<u8> {
-    format!(
-        "{}/lasttx",
-        BridgeAccountKey {
-            prefix: BRIDGE_ACCOUNT_PREFIX,
-            address
-        }
-    )
-    .as_bytes()
-    .to_vec()
-}
-
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
     #[instrument(skip_all)]
@@ -147,7 +52,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
         address: &T,
     ) -> Result<Option<RollupId>> {
         let Some(bytes) = self
-            .get_raw(&rollup_id_storage_key(address))
+            .get_raw(&keys::rollup_id(address))
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw account rollup ID from state")?
@@ -169,7 +74,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
         address: &T,
     ) -> Result<asset::IbcPrefixed> {
         let bytes = self
-            .get_raw(&asset_id_storage_key(address))
+            .get_raw(&keys::asset_id(address))
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw bridge account asset ID from state")?
@@ -187,7 +92,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
         bridge_address: &T,
     ) -> Result<Option<[u8; ADDRESS_LEN]>> {
         let Some(bytes) = self
-            .get_raw(&bridge_account_sudo_address_storage_key(bridge_address))
+            .get_raw(&keys::bridge_account_sudo_address(bridge_address))
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw bridge account sudo address from state")?
@@ -210,9 +115,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
         bridge_address: &T,
     ) -> Result<Option<[u8; ADDRESS_LEN]>> {
         let Some(bytes) = self
-            .get_raw(&bridge_account_withdrawer_address_storage_key(
-                bridge_address,
-            ))
+            .get_raw(&keys::bridge_account_withdrawer_address(bridge_address))
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw bridge account withdrawer address from state")?
@@ -231,7 +134,8 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
 
     #[instrument(skip_all)]
     fn get_cached_block_deposits(&self) -> HashMap<RollupId, Vec<Deposit>> {
-        self.object_get(DEPOSITS_EPHEMERAL_KEY).unwrap_or_default()
+        self.object_get(keys::DEPOSITS_EPHEMERAL)
+            .unwrap_or_default()
     }
 
     #[instrument(skip_all)]
@@ -241,7 +145,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
         rollup_id: &RollupId,
     ) -> Result<Vec<Deposit>> {
         let Some(bytes) = self
-            .nonverifiable_get_raw(&deposit_storage_key(block_hash, rollup_id))
+            .nonverifiable_get_raw(keys::deposit(block_hash, rollup_id).as_bytes())
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw deposits from state")?
@@ -256,7 +160,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
     #[instrument(skip_all)]
     async fn get_init_bridge_account_base_fee(&self) -> Result<u128> {
         let bytes = self
-            .get_raw(INIT_BRIDGE_ACCOUNT_BASE_FEE_STORAGE_KEY)
+            .get_raw(keys::INIT_BRIDGE_ACCOUNT_BASE_FEE)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw init bridge account base fee from state")?
@@ -269,7 +173,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
     #[instrument(skip_all)]
     async fn get_bridge_lock_byte_cost_multiplier(&self) -> Result<u128> {
         let bytes = self
-            .get_raw(BRIDGE_LOCK_BYTE_COST_MULTIPLIER_STORAGE_KEY)
+            .get_raw(keys::BRIDGE_LOCK_BYTE_COST_MULTIPLIER)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw bridge lock byte cost multiplier from state")?
@@ -282,7 +186,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
     #[instrument(skip_all)]
     async fn get_bridge_sudo_change_base_fee(&self) -> Result<u128> {
         let bytes = self
-            .get_raw(BRIDGE_SUDO_CHANGE_FEE_STORAGE_KEY)
+            .get_raw(keys::BRIDGE_SUDO_CHANGE_FEE)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw bridge sudo change fee from state")?
@@ -298,7 +202,7 @@ pub(crate) trait StateReadExt: StateRead + address::StateReadExt {
         address: &T,
     ) -> Result<Option<TransactionId>> {
         let Some(bytes) = self
-            .nonverifiable_get_raw(&last_transaction_id_for_bridge_account_storage_key(address))
+            .nonverifiable_get_raw(keys::last_transaction_id_for_bridge_account(address).as_bytes())
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw last transaction hash for bridge account from state")?
@@ -325,7 +229,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::RollupId::from(&rollup_id))
             .serialize()
             .context("failed to serialize bridge account rollup id")?;
-        self.put_raw(rollup_id_storage_key(address), bytes);
+        self.put_raw(keys::rollup_id(address), bytes);
         Ok(())
     }
 
@@ -343,7 +247,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::IbcPrefixedDenom::from(&ibc))
             .serialize()
             .wrap_err("failed to serialize asset ids")?;
-        self.put_raw(asset_id_storage_key(address), bytes);
+        self.put_raw(keys::asset_id(address), bytes);
         Ok(())
     }
 
@@ -360,10 +264,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::AddressBytes::from(&sudo_address))
             .serialize()
             .context("failed to serialize bridge account sudo address")?;
-        self.put_raw(
-            bridge_account_sudo_address_storage_key(bridge_address),
-            bytes,
-        );
+        self.put_raw(keys::bridge_account_sudo_address(bridge_address), bytes);
         Ok(())
     }
 
@@ -381,7 +282,7 @@ pub(crate) trait StateWriteExt: StateWrite {
             .serialize()
             .context("failed to serialize bridge account sudo address")?;
         self.put_raw(
-            bridge_account_withdrawer_address_storage_key(bridge_address),
+            keys::bridge_account_withdrawer_address(bridge_address),
             bytes,
         );
         Ok(())
@@ -394,7 +295,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         withdrawal_event_id: &str,
         block_num: u64,
     ) -> Result<()> {
-        let key = bridge_account_withdrawal_event_storage_key(address, withdrawal_event_id);
+        let key = keys::bridge_account_withdrawal_event(address, withdrawal_event_id);
 
         // Check if the withdrawal ID has already been used, if so return an error.
         let bytes = self
@@ -428,7 +329,7 @@ pub(crate) trait StateWriteExt: StateWrite {
             .entry(deposit.rollup_id)
             .or_default()
             .push(deposit);
-        self.object_put(DEPOSITS_EPHEMERAL_KEY, cached_deposits);
+        self.object_put(keys::DEPOSITS_EPHEMERAL, cached_deposits);
     }
 
     #[instrument(skip_all, err)]
@@ -438,11 +339,11 @@ pub(crate) trait StateWriteExt: StateWrite {
         all_deposits: HashMap<RollupId, Vec<Deposit>>,
     ) -> Result<()> {
         for (rollup_id, deposits) in all_deposits {
-            let key = deposit_storage_key(block_hash, &rollup_id);
+            let key = keys::deposit(block_hash, &rollup_id);
             let bytes = StoredValue::from(storage::Deposits::from(deposits.iter()))
                 .serialize()
                 .context("failed to serialize bridge deposit")?;
-            self.nonverifiable_put_raw(key, bytes);
+            self.nonverifiable_put_raw(key.into_bytes(), bytes);
         }
         Ok(())
     }
@@ -452,7 +353,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::Fee::from(fee))
             .serialize()
             .context("failed to serialize bridge account base fee")?;
-        self.put_raw(INIT_BRIDGE_ACCOUNT_BASE_FEE_STORAGE_KEY.to_string(), bytes);
+        self.put_raw(keys::INIT_BRIDGE_ACCOUNT_BASE_FEE.to_string(), bytes);
         Ok(())
     }
 
@@ -461,10 +362,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::Fee::from(fee))
             .serialize()
             .context("failed to serialize bridge lock byte cost multiplier")?;
-        self.put_raw(
-            BRIDGE_LOCK_BYTE_COST_MULTIPLIER_STORAGE_KEY.to_string(),
-            bytes,
-        );
+        self.put_raw(keys::BRIDGE_LOCK_BYTE_COST_MULTIPLIER.to_string(), bytes);
         Ok(())
     }
 
@@ -473,7 +371,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::Fee::from(fee))
             .serialize()
             .context("failed to serialize bridge sudo change base fee")?;
-        self.put_raw(BRIDGE_SUDO_CHANGE_FEE_STORAGE_KEY.to_string(), bytes);
+        self.put_raw(keys::BRIDGE_SUDO_CHANGE_FEE.to_string(), bytes);
         Ok(())
     }
 
@@ -487,7 +385,7 @@ pub(crate) trait StateWriteExt: StateWrite {
             .serialize()
             .context("failed to serialize transaction hash for bridge account")?;
         self.nonverifiable_put_raw(
-            last_transaction_id_for_bridge_account_storage_key(address),
+            keys::last_transaction_id_for_bridge_account(address).into(),
             bytes,
         );
         Ok(())
@@ -498,17 +396,7 @@ impl<T: StateWrite> StateWriteExt for T {}
 
 #[cfg(test)]
 mod tests {
-    use astria_core::{
-        primitive::v1::{
-            asset,
-            Address,
-            RollupId,
-            TransactionId,
-        },
-        sequencerblock::v1alpha1::block::Deposit,
-    };
     use cnidarium::StateDelta;
-    use insta::assert_snapshot;
 
     use super::*;
     use crate::test_utils::astria_address;
@@ -876,16 +764,4 @@ mod tests {
             .unwrap();
         assert_eq!(retrieved_tx_hash, Some(tx_hash));
     }
-
-    #[test]
-    fn storage_keys_have_not_changed() {
-        let address: Address = "astria1rsxyjrcm255ds9euthjx6yc3vrjt9sxrm9cfgm"
-            .parse()
-            .unwrap();
-
-        assert_snapshot!(rollup_id_storage_key(&address));
-        assert_snapshot!(asset_id_storage_key(&address));
-        assert_snapshot!(bridge_account_sudo_address_storage_key(&address));
-        assert_snapshot!(bridge_account_withdrawer_address_storage_key(&address));
-    }
 }
diff --git a/crates/astria-sequencer/src/bridge/storage/keys.rs b/crates/astria-sequencer/src/bridge/storage/keys.rs
new file mode 100644
index 0000000000..028d06eaea
--- /dev/null
+++ b/crates/astria-sequencer/src/bridge/storage/keys.rs
@@ -0,0 +1,141 @@
+use astria_core::primitive::v1::RollupId;
+use base64::{
+    display::Base64Display,
+    engine::general_purpose::URL_SAFE,
+};
+
+use crate::{
+    accounts::AddressBytes,
+    storage::keys::AccountPrefixer,
+};
+
+pub(in crate::bridge) const INIT_BRIDGE_ACCOUNT_BASE_FEE: &str = "bridge/init_account_fee";
+pub(in crate::bridge) const BRIDGE_LOCK_BYTE_COST_MULTIPLIER: &str =
+    "bridge/lock_byte_cost_multiplier";
+pub(in crate::bridge) const BRIDGE_SUDO_CHANGE_FEE: &str = "bridge/sudo_change_fee";
+
+pub(in crate::bridge) const BRIDGE_ACCOUNT_PREFIX: &str = "bridge/account/";
+const BRIDGE_ACCOUNT_SUDO_PREFIX: &str = "bridge/sudo/";
+const BRIDGE_ACCOUNT_WITHDRAWER_PREFIX: &str = "bridge/withdrawer/";
+
+pub(in crate::bridge) const DEPOSITS_EPHEMERAL: &str = "bridge/deposits";
+const DEPOSIT_PREFIX: &str = "bridge/deposit/";
+
+/// Example: `bridge/account/gGhH....zZ4=/rollup_id`.
+///                         |base64 chars|
+pub(in crate::bridge) fn rollup_id<T: AddressBytes>(address: &T) -> String {
+    format!(
+        "{}/rollup_id",
+        AccountPrefixer::new(BRIDGE_ACCOUNT_PREFIX, address)
+    )
+}
+
+/// Example: `bridge/account/gGhH....zZ4=/asset_id`.
+///                         |base64 chars|
+pub(in crate::bridge) fn asset_id<T: AddressBytes>(address: &T) -> String {
+    format!(
+        "{}/asset_id",
+        AccountPrefixer::new(BRIDGE_ACCOUNT_PREFIX, address)
+    )
+}
+
+/// Example: `bridge/sudo/gGhH....zZ4=`.
+///                      |base64 chars|
+pub(in crate::bridge) fn bridge_account_sudo_address<T: AddressBytes>(address: &T) -> String {
+    AccountPrefixer::new(BRIDGE_ACCOUNT_SUDO_PREFIX, address).to_string()
+}
+
+/// Example: `bridge/withdrawer/gGhH....zZ4=`.
+///                            |base64 chars|
+pub(in crate::bridge) fn bridge_account_withdrawer_address<T: AddressBytes>(address: &T) -> String {
+    AccountPrefixer::new(BRIDGE_ACCOUNT_WITHDRAWER_PREFIX, address).to_string()
+}
+
+/// Example: `bridge/account/gGhH....zZ4=/withdrawal_event/<event id>`.
+///                         |base64 chars|                |UTF-8 chars|
+pub(in crate::bridge) fn bridge_account_withdrawal_event<T: AddressBytes>(
+    address: &T,
+    withdrawal_event_id: &str,
+) -> String {
+    format!(
+        "{}/withdrawal_event/{}",
+        AccountPrefixer::new(BRIDGE_ACCOUNT_PREFIX, address),
+        withdrawal_event_id
+    )
+}
+
+pub(in crate::bridge) fn deposit(block_hash: &[u8; 32], rollup_id: &RollupId) -> String {
+    format!(
+        "{DEPOSIT_PREFIX}{}/{rollup_id}",
+        Base64Display::new(block_hash, &URL_SAFE),
+    )
+}
+
+pub(in crate::bridge) fn last_transaction_id_for_bridge_account<T: AddressBytes>(
+    address: &T,
+) -> String {
+    format!(
+        "{BRIDGE_ACCOUNT_PREFIX}{}/last_tx",
+        Base64Display::new(address.address_bytes(), &URL_SAFE)
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use astria_core::primitive::v1::Address;
+
+    use super::*;
+
+    const COMPONENT_PREFIX: &str = "bridge/";
+
+    fn address() -> Address {
+        "astria1rsxyjrcm255ds9euthjx6yc3vrjt9sxrm9cfgm"
+            .parse()
+            .unwrap()
+    }
+
+    #[test]
+    fn keys_should_not_change() {
+        insta::assert_snapshot!(INIT_BRIDGE_ACCOUNT_BASE_FEE);
+        insta::assert_snapshot!(BRIDGE_LOCK_BYTE_COST_MULTIPLIER);
+        insta::assert_snapshot!(BRIDGE_SUDO_CHANGE_FEE);
+        insta::assert_snapshot!(DEPOSITS_EPHEMERAL);
+        insta::assert_snapshot!(rollup_id(&address()));
+        insta::assert_snapshot!(asset_id(&address()));
+        insta::assert_snapshot!(bridge_account_sudo_address(&address()));
+        insta::assert_snapshot!(bridge_account_withdrawer_address(&address()));
+        insta::assert_snapshot!(bridge_account_withdrawal_event(&address(), "the-event"));
+        insta::assert_snapshot!(deposit(&[1; 32], &RollupId::new([2; 32])));
+        insta::assert_snapshot!(last_transaction_id_for_bridge_account(&address()));
+    }
+
+    #[test]
+    fn keys_should_have_component_prefix() {
+        assert!(INIT_BRIDGE_ACCOUNT_BASE_FEE.starts_with(COMPONENT_PREFIX));
+        assert!(BRIDGE_LOCK_BYTE_COST_MULTIPLIER.starts_with(COMPONENT_PREFIX));
+        assert!(BRIDGE_SUDO_CHANGE_FEE.starts_with(COMPONENT_PREFIX));
+        assert!(DEPOSITS_EPHEMERAL.starts_with(COMPONENT_PREFIX));
+        assert!(rollup_id(&address()).starts_with(COMPONENT_PREFIX));
+        assert!(asset_id(&address()).starts_with(COMPONENT_PREFIX));
+        assert!(bridge_account_sudo_address(&address()).starts_with(COMPONENT_PREFIX));
+        assert!(bridge_account_withdrawer_address(&address()).starts_with(COMPONENT_PREFIX));
+        assert!(
+            bridge_account_withdrawal_event(&address(), "the-event").starts_with(COMPONENT_PREFIX)
+        );
+        assert!(deposit(&[1; 32], &RollupId::new([2; 32])).starts_with(COMPONENT_PREFIX));
+        assert!(last_transaction_id_for_bridge_account(&address()).starts_with(COMPONENT_PREFIX));
+    }
+
+    #[test]
+    fn bridge_account_prefix_should_be_prefix_of_relevant_keys() {
+        assert!(rollup_id(&address()).starts_with(BRIDGE_ACCOUNT_PREFIX));
+        assert!(asset_id(&address()).starts_with(BRIDGE_ACCOUNT_PREFIX));
+        assert!(
+            bridge_account_withdrawal_event(&address(), "the-event")
+                .starts_with(BRIDGE_ACCOUNT_PREFIX)
+        );
+        assert!(
+            last_transaction_id_for_bridge_account(&address()).starts_with(BRIDGE_ACCOUNT_PREFIX)
+        );
+    }
+}
diff --git a/crates/astria-sequencer/src/bridge/storage/mod.rs b/crates/astria-sequencer/src/bridge/storage/mod.rs
index 8478b8c98f..c52ffe69e2 100644
--- a/crates/astria-sequencer/src/bridge/storage/mod.rs
+++ b/crates/astria-sequencer/src/bridge/storage/mod.rs
@@ -1,3 +1,4 @@
+pub(super) mod keys;
 mod values;
 
 pub(crate) use values::Value;
diff --git a/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-10.snap b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-10.snap
new file mode 100644
index 0000000000..298911134f
--- /dev/null
+++ b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-10.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/bridge/storage/keys.rs
+assertion_line: 103
+expression: "deposit(&[1; 32], &RollupId::new([2; 32]))"
+---
+bridge/deposit/AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=/AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI=
diff --git a/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-11.snap b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-11.snap
new file mode 100644
index 0000000000..280571eaf4
--- /dev/null
+++ b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-11.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/bridge/storage/keys.rs
+assertion_line: 104
+expression: last_transaction_id_for_bridge_account(&address())
+---
+bridge/account/HAxJDxtVKNgXPF3kbRMRYOSywMM=/last_tx
diff --git a/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-2.snap b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-2.snap
new file mode 100644
index 0000000000..8fdfb69d89
--- /dev/null
+++ b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-2.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/bridge/storage/keys.rs
+assertion_line: 96
+expression: BRIDGE_LOCK_BYTE_COST_MULTIPLIER_KEY
+---
+bridge/lock_byte_cost_multiplier
diff --git a/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-3.snap b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-3.snap
new file mode 100644
index 0000000000..9b95261abd
--- /dev/null
+++ b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-3.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/bridge/storage/keys.rs
+assertion_line: 97
+expression: BRIDGE_SUDO_CHANGE_FEE_KEY
+---
+bridge/sudo_change_fee
diff --git a/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-4.snap b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-4.snap
new file mode 100644
index 0000000000..5be3e6da08
--- /dev/null
+++ b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-4.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/bridge/storage/keys.rs
+assertion_line: 98
+expression: DEPOSITS_EPHEMERAL_KEY
+---
+bridge/deposits
diff --git a/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-5.snap b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-5.snap
new file mode 100644
index 0000000000..6d98ac4b82
--- /dev/null
+++ b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-5.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/bridge/storage/keys.rs
+assertion_line: 99
+expression: rollup_id(&address())
+---
+bridge/account/HAxJDxtVKNgXPF3kbRMRYOSywMM=/rollup_id
diff --git a/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-6.snap b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-6.snap
new file mode 100644
index 0000000000..3cb63bc740
--- /dev/null
+++ b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-6.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/bridge/storage/keys.rs
+assertion_line: 100
+expression: asset_id(&address())
+---
+bridge/account/HAxJDxtVKNgXPF3kbRMRYOSywMM=/asset_id
diff --git a/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-7.snap b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-7.snap
new file mode 100644
index 0000000000..71464a1920
--- /dev/null
+++ b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-7.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/bridge/storage/keys.rs
+assertion_line: 101
+expression: bridge_account_sudo_address(&address())
+---
+bridge/sudo/HAxJDxtVKNgXPF3kbRMRYOSywMM=
diff --git a/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-8.snap b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-8.snap
new file mode 100644
index 0000000000..a1385b069f
--- /dev/null
+++ b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-8.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/bridge/storage/keys.rs
+assertion_line: 102
+expression: bridge_account_withdrawer_address(&address())
+---
+bridge/withdrawer/HAxJDxtVKNgXPF3kbRMRYOSywMM=
diff --git a/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-9.snap b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-9.snap
new file mode 100644
index 0000000000..225942477f
--- /dev/null
+++ b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change-9.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/bridge/storage/keys.rs
+assertion_line: 103
+expression: "bridge_account_withdrawal_event(&address(), \"the-event\")"
+---
+bridge/account/HAxJDxtVKNgXPF3kbRMRYOSywMM=/withdrawal_event/the-event
diff --git a/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change.snap b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change.snap
new file mode 100644
index 0000000000..2ab66a494a
--- /dev/null
+++ b/crates/astria-sequencer/src/bridge/storage/snapshots/astria_sequencer__bridge__storage__keys__tests__keys_should_not_change.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/bridge/storage/keys.rs
+assertion_line: 95
+expression: INIT_BRIDGE_ACCOUNT_BASE_FEE_KEY
+---
+bridge/init_account_fee
diff --git a/crates/astria-sequencer/src/grpc/state_ext.rs b/crates/astria-sequencer/src/grpc/state_ext.rs
index fffc906d20..86182aae59 100644
--- a/crates/astria-sequencer/src/grpc/state_ext.rs
+++ b/crates/astria-sequencer/src/grpc/state_ext.rs
@@ -22,39 +22,18 @@ use cnidarium::{
 };
 use tracing::instrument;
 
-use super::storage;
+use super::storage::{
+    self,
+    keys,
+};
 use crate::storage::StoredValue;
 
-fn block_hash_by_height_key(height: u64) -> Vec<u8> {
-    [b"blockhash/".as_slice(), &height.to_le_bytes()].concat()
-}
-
-fn sequencer_block_header_by_hash_key(hash: &[u8; 32]) -> Vec<u8> {
-    [b"blockheader/", hash.as_slice()].concat()
-}
-
-fn rollup_data_by_hash_and_rollup_id_key(hash: &[u8; 32], rollup_id: &RollupId) -> Vec<u8> {
-    [b"rollupdata/", hash.as_slice(), rollup_id.as_ref()].concat()
-}
-
-fn rollup_ids_by_hash_key(hash: &[u8; 32]) -> Vec<u8> {
-    [b"rollupids/", hash.as_slice()].concat()
-}
-
-fn rollup_transactions_proof_by_hash_key(hash: &[u8; 32]) -> Vec<u8> {
-    [b"rolluptxsproof/", hash.as_slice()].concat()
-}
-
-fn rollup_ids_proof_by_hash_key(hash: &[u8; 32]) -> Vec<u8> {
-    [b"rollupidsproof/", hash.as_slice()].concat()
-}
-
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_block_hash_by_height(&self, height: u64) -> Result<[u8; 32]> {
         let Some(bytes) = self
-            .nonverifiable_get_raw(&block_hash_by_height_key(height))
+            .nonverifiable_get_raw(keys::block_hash_by_height(height).as_bytes())
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read block hash by height from state")?
@@ -72,7 +51,7 @@ pub(crate) trait StateReadExt: StateRead {
         hash: &[u8; 32],
     ) -> Result<SequencerBlockHeader> {
         let Some(bytes) = self
-            .nonverifiable_get_raw(&sequencer_block_header_by_hash_key(hash))
+            .nonverifiable_get_raw(keys::sequencer_block_header_by_hash(hash).as_bytes())
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read raw sequencer block from state")?
@@ -89,7 +68,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_rollup_ids_by_block_hash(&self, hash: &[u8; 32]) -> Result<Vec<RollupId>> {
         let Some(bytes) = self
-            .nonverifiable_get_raw(&rollup_ids_by_hash_key(hash))
+            .nonverifiable_get_raw(keys::rollup_ids_by_hash(hash).as_bytes())
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read rollup IDs by block hash from state")?
@@ -119,7 +98,9 @@ pub(crate) trait StateReadExt: StateRead {
         rollup_id: &RollupId,
     ) -> Result<RollupTransactions> {
         let Some(bytes) = self
-            .nonverifiable_get_raw(&rollup_data_by_hash_and_rollup_id_key(hash, rollup_id))
+            .nonverifiable_get_raw(
+                keys::rollup_data_by_hash_and_rollup_id(hash, rollup_id).as_bytes(),
+            )
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err(
@@ -141,7 +122,7 @@ pub(crate) trait StateReadExt: StateRead {
         hash: &[u8; 32],
     ) -> Result<merkle::Proof> {
         let Some(bytes) = self
-            .nonverifiable_get_raw(&rollup_transactions_proof_by_hash_key(hash))
+            .nonverifiable_get_raw(keys::rollup_transactions_proof_by_hash(hash).as_bytes())
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read rollup transactions proof by block hash from state")?
@@ -156,7 +137,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_rollup_ids_proof_by_block_hash(&self, hash: &[u8; 32]) -> Result<merkle::Proof> {
         let Some(bytes) = self
-            .nonverifiable_get_raw(&rollup_ids_proof_by_hash_key(hash))
+            .nonverifiable_get_raw(keys::rollup_ids_proof_by_hash(hash).as_bytes())
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read rollup IDs proof by block hash from state")?
@@ -252,7 +233,10 @@ fn put_block_hash<S: StateWrite + ?Sized>(
     let bytes = StoredValue::from(storage::BlockHash::from(&block_hash))
         .serialize()
         .context("failed to serialize block hash")?;
-    state.nonverifiable_put_raw(block_hash_by_height_key(block_height.into()), bytes);
+    state.nonverifiable_put_raw(
+        keys::block_hash_by_height(block_height.into()).into(),
+        bytes,
+    );
     Ok(())
 }
 
@@ -265,7 +249,7 @@ fn put_rollup_ids<S: StateWrite + ?Sized, I: Iterator<Item = RollupId>>(
     let bytes = StoredValue::from(storage::RollupIds::from(rollup_ids.iter()))
         .serialize()
         .context("failed to serialize rollup ids")?;
-    state.nonverifiable_put_raw(rollup_ids_by_hash_key(block_hash), bytes);
+    state.nonverifiable_put_raw(keys::rollup_ids_by_hash(block_hash).into(), bytes);
     Ok(())
 }
 
@@ -281,7 +265,10 @@ fn put_block_header<S: StateWrite + ?Sized>(
     let bytes = StoredValue::from(storage::SequencerBlockHeader::from(&block_header))
         .serialize()
         .context("failed to serialize sequencer block header")?;
-    state.nonverifiable_put_raw(sequencer_block_header_by_hash_key(block_hash), bytes);
+    state.nonverifiable_put_raw(
+        keys::sequencer_block_header_by_hash(block_hash).into(),
+        bytes,
+    );
     Ok(())
 }
 
@@ -299,7 +286,10 @@ where
         let bytes = StoredValue::from(storage::RollupTransactions::from(rollup_txs))
             .serialize()
             .context("failed to serialize rollup transactions")?;
-        state.nonverifiable_put_raw(rollup_data_by_hash_and_rollup_id_key(block_hash, id), bytes);
+        state.nonverifiable_put_raw(
+            keys::rollup_data_by_hash_and_rollup_id(block_hash, id).into(),
+            bytes,
+        );
         Ok(())
     })
 }
@@ -316,7 +306,10 @@ fn put_rollups_transactions_proof<S: StateWrite + ?Sized>(
     let bytes = StoredValue::from(storage::Proof::from(&proof))
         .serialize()
         .context("failed to serialize rollups transactions proof")?;
-    state.nonverifiable_put_raw(rollup_transactions_proof_by_hash_key(block_hash), bytes);
+    state.nonverifiable_put_raw(
+        keys::rollup_transactions_proof_by_hash(block_hash).into(),
+        bytes,
+    );
     Ok(())
 }
 
@@ -332,7 +325,7 @@ fn put_rollup_ids_proof<S: StateWrite + ?Sized>(
     let bytes = StoredValue::from(storage::Proof::from(&proof))
         .serialize()
         .context("failed to serialize rollup ids proof")?;
-    state.nonverifiable_put_raw(rollup_ids_proof_by_hash_key(block_hash), bytes);
+    state.nonverifiable_put_raw(keys::rollup_ids_proof_by_hash(block_hash).into(), bytes);
     Ok(())
 }
 
diff --git a/crates/astria-sequencer/src/grpc/storage/keys.rs b/crates/astria-sequencer/src/grpc/storage/keys.rs
new file mode 100644
index 0000000000..3c5280fe7f
--- /dev/null
+++ b/crates/astria-sequencer/src/grpc/storage/keys.rs
@@ -0,0 +1,70 @@
+use astria_core::primitive::v1::RollupId;
+use base64::{
+    display::Base64Display,
+    engine::general_purpose::URL_SAFE,
+};
+
+pub(in crate::grpc) fn block_hash_by_height(height: u64) -> String {
+    format!("grpc/block_hash/{height}")
+}
+
+pub(in crate::grpc) fn sequencer_block_header_by_hash(hash: &[u8; 32]) -> String {
+    format!("grpc/block_header/{}", Base64Display::new(hash, &URL_SAFE))
+}
+
+pub(in crate::grpc) fn rollup_data_by_hash_and_rollup_id(
+    hash: &[u8; 32],
+    rollup_id: &RollupId,
+) -> String {
+    format!(
+        "grpc/rollup_data/{}/{rollup_id}",
+        Base64Display::new(hash, &URL_SAFE),
+    )
+}
+
+pub(in crate::grpc) fn rollup_ids_by_hash(hash: &[u8; 32]) -> String {
+    format!("grpc/rollup_ids/{}", Base64Display::new(hash, &URL_SAFE))
+}
+
+pub(in crate::grpc) fn rollup_transactions_proof_by_hash(hash: &[u8; 32]) -> String {
+    format!(
+        "grpc/rollup_txs_proof/{}",
+        Base64Display::new(hash, &URL_SAFE)
+    )
+}
+
+pub(in crate::grpc) fn rollup_ids_proof_by_hash(hash: &[u8; 32]) -> String {
+    format!(
+        "grpc/rollup_ids_proof/{}",
+        Base64Display::new(hash, &URL_SAFE)
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const COMPONENT_PREFIX: &str = "grpc/";
+    const HASH: [u8; 32] = [1; 32];
+    const ROLLUP_ID: RollupId = RollupId::new([2; 32]);
+
+    #[test]
+    fn keys_should_not_change() {
+        insta::assert_snapshot!(block_hash_by_height(42));
+        insta::assert_snapshot!(sequencer_block_header_by_hash(&HASH));
+        insta::assert_snapshot!(rollup_data_by_hash_and_rollup_id(&HASH, &ROLLUP_ID));
+        insta::assert_snapshot!(rollup_ids_by_hash(&HASH));
+        insta::assert_snapshot!(rollup_transactions_proof_by_hash(&HASH));
+        insta::assert_snapshot!(rollup_ids_proof_by_hash(&HASH));
+    }
+
+    #[test]
+    fn keys_should_have_component_prefix() {
+        assert!(block_hash_by_height(42).starts_with(COMPONENT_PREFIX));
+        assert!(sequencer_block_header_by_hash(&HASH).starts_with(COMPONENT_PREFIX));
+        assert!(rollup_data_by_hash_and_rollup_id(&HASH, &ROLLUP_ID).starts_with(COMPONENT_PREFIX));
+        assert!(rollup_ids_by_hash(&HASH).starts_with(COMPONENT_PREFIX));
+        assert!(rollup_transactions_proof_by_hash(&HASH).starts_with(COMPONENT_PREFIX));
+        assert!(rollup_ids_proof_by_hash(&HASH).starts_with(COMPONENT_PREFIX));
+    }
+}
diff --git a/crates/astria-sequencer/src/grpc/storage/mod.rs b/crates/astria-sequencer/src/grpc/storage/mod.rs
index 28d353e151..d1c28b1264 100644
--- a/crates/astria-sequencer/src/grpc/storage/mod.rs
+++ b/crates/astria-sequencer/src/grpc/storage/mod.rs
@@ -1,3 +1,4 @@
+pub(super) mod keys;
 mod values;
 
 pub(crate) use values::Value;
diff --git a/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-2.snap b/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-2.snap
new file mode 100644
index 0000000000..018d0b55f2
--- /dev/null
+++ b/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-2.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/grpc/storage/keys.rs
+assertion_line: 45
+expression: sequencer_block_header_by_hash(&HASH)
+---
+grpc/block_header/AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=
diff --git a/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-3.snap b/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-3.snap
new file mode 100644
index 0000000000..bef72d21bd
--- /dev/null
+++ b/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-3.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/grpc/storage/keys.rs
+assertion_line: 46
+expression: "rollup_data_by_hash_and_rollup_id(&HASH, &ROLLUP_ID)"
+---
+grpc/rollup_data/AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=/AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI=
diff --git a/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-4.snap b/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-4.snap
new file mode 100644
index 0000000000..5ee0401df5
--- /dev/null
+++ b/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-4.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/grpc/storage/keys.rs
+assertion_line: 49
+expression: rollup_ids_by_hash(&HASH)
+---
+grpc/rollup_ids/AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=
diff --git a/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-5.snap b/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-5.snap
new file mode 100644
index 0000000000..e221b2d469
--- /dev/null
+++ b/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-5.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/grpc/storage/keys.rs
+assertion_line: 50
+expression: rollup_transactions_proof_by_hash(&HASH)
+---
+grpc/rollup_txs_proof/AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=
diff --git a/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-6.snap b/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-6.snap
new file mode 100644
index 0000000000..cc164f9882
--- /dev/null
+++ b/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change-6.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/grpc/storage/keys.rs
+assertion_line: 51
+expression: rollup_ids_proof_by_hash(&HASH)
+---
+grpc/rollup_ids_proof/AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=
diff --git a/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change.snap b/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change.snap
new file mode 100644
index 0000000000..95b4e91a7d
--- /dev/null
+++ b/crates/astria-sequencer/src/grpc/storage/snapshots/astria_sequencer__grpc__storage__keys__tests__keys_should_not_change.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/grpc/storage/keys.rs
+assertion_line: 44
+expression: block_hash_by_height(42)
+---
+grpc/block_hash/42
diff --git a/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs b/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs
index d861ee52e3..d7093c5455 100644
--- a/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs
+++ b/crates/astria-sequencer/src/ibc/ics20_withdrawal.rs
@@ -8,7 +8,6 @@ use astria_core::{
         memos::v1alpha1::Ics20WithdrawalFromRollup,
         transaction::v1alpha1::action,
     },
-    Protobuf as _,
 };
 use astria_eyre::{
     anyhow_to_eyre,
@@ -236,7 +235,7 @@ impl ActionHandler for action::Ics20Withdrawal {
         };
 
         state
-            .get_and_increase_block_fees(self.fee_asset(), fee, Self::full_name())
+            .get_and_increase_block_fees::<Self, _>(self.fee_asset(), fee)
             .await
             .wrap_err("failed to get and increase block fees")?;
 
diff --git a/crates/astria-sequencer/src/ibc/snapshots/astria_sequencer__ibc__state_ext__tests__storage_keys_have_not_changed-2.snap b/crates/astria-sequencer/src/ibc/snapshots/astria_sequencer__ibc__state_ext__tests__storage_keys_have_not_changed-2.snap
deleted file mode 100644
index 7ba59bca3c..0000000000
--- a/crates/astria-sequencer/src/ibc/snapshots/astria_sequencer__ibc__state_ext__tests__storage_keys_have_not_changed-2.snap
+++ /dev/null
@@ -1,5 +0,0 @@
----
-source: crates/astria-sequencer/src/ibc/state_ext.rs
-expression: "channel_balance_storage_key(&channel, &asset)"
----
-ibc-data/channel-5/balance/be429a02d00837245167a2616674a979a2ac6f9806468b48a975b156ad711320
diff --git a/crates/astria-sequencer/src/ibc/snapshots/astria_sequencer__ibc__state_ext__tests__storage_keys_have_not_changed.snap b/crates/astria-sequencer/src/ibc/snapshots/astria_sequencer__ibc__state_ext__tests__storage_keys_have_not_changed.snap
deleted file mode 100644
index 2358f2e37d..0000000000
--- a/crates/astria-sequencer/src/ibc/snapshots/astria_sequencer__ibc__state_ext__tests__storage_keys_have_not_changed.snap
+++ /dev/null
@@ -1,5 +0,0 @@
----
-source: crates/astria-sequencer/src/ibc/state_ext.rs
-expression: "super::ibc_relayer_key(&address)"
----
-ibc-relayer/1c0c490f1b5528d8173c5de46d131160e4b2c0c3
diff --git a/crates/astria-sequencer/src/ibc/state_ext.rs b/crates/astria-sequencer/src/ibc/state_ext.rs
index 4ec443a9c6..2ee556d3fa 100644
--- a/crates/astria-sequencer/src/ibc/state_ext.rs
+++ b/crates/astria-sequencer/src/ibc/state_ext.rs
@@ -1,4 +1,7 @@
-use std::fmt::Display;
+use std::{
+    borrow::Cow,
+    fmt::Display,
+};
 
 use astria_core::primitive::v1::{
     asset,
@@ -24,42 +27,15 @@ use tracing::{
     instrument,
 };
 
-use super::storage;
+use super::storage::{
+    self,
+    keys,
+};
 use crate::{
     accounts::AddressBytes,
     storage::StoredValue,
 };
 
-const IBC_SUDO_STORAGE_KEY: &str = "ibcsudo";
-const ICS20_WITHDRAWAL_BASE_FEE_STORAGE_KEY: &str = "ics20withdrawalfee";
-
-struct IbcRelayerKey<'a, T>(&'a T);
-
-impl<'a, T: AddressBytes> std::fmt::Display for IbcRelayerKey<'a, T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str("ibc-relayer")?;
-        f.write_str("/")?;
-        for byte in self.0.address_bytes() {
-            f.write_fmt(format_args!("{byte:02x}"))?;
-        }
-        Ok(())
-    }
-}
-
-fn channel_balance_storage_key<'a, TAsset>(channel: &ChannelId, asset: &'a TAsset) -> String
-where
-    asset::IbcPrefixed: From<&'a TAsset>,
-{
-    format!(
-        "ibc-data/{channel}/balance/{}",
-        crate::storage_keys::hunks::Asset::from(asset),
-    )
-}
-
-fn ibc_relayer_key<T: AddressBytes>(address: &T) -> String {
-    IbcRelayerKey(address).to_string()
-}
-
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all, fields(%channel, %asset), err)]
@@ -70,10 +46,10 @@ pub(crate) trait StateReadExt: StateRead {
     ) -> Result<u128>
     where
         TAsset: Sync + Display,
-        asset::IbcPrefixed: From<&'a TAsset>,
+        &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
     {
         let Some(bytes) = self
-            .get_raw(&channel_balance_storage_key(channel, asset))
+            .get_raw(&keys::channel_balance(channel, asset))
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading ibc channel balance from state")?
@@ -89,7 +65,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_ibc_sudo_address(&self) -> Result<[u8; ADDRESS_LEN]> {
         let Some(bytes) = self
-            .get_raw(IBC_SUDO_STORAGE_KEY)
+            .get_raw(keys::IBC_SUDO)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw ibc sudo address from state")?
@@ -105,7 +81,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn is_ibc_relayer<T: AddressBytes>(&self, address: T) -> Result<bool> {
         Ok(self
-            .get_raw(&ibc_relayer_key(&address))
+            .get_raw(&keys::ibc_relayer(&address))
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed to read ibc relayer key from state")?
@@ -115,7 +91,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_ics20_withdrawal_base_fee(&self) -> Result<u128> {
         let Some(bytes) = self
-            .get_raw(ICS20_WITHDRAWAL_BASE_FEE_STORAGE_KEY)
+            .get_raw(keys::ICS20_WITHDRAWAL_BASE_FEE)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading ics20 withdrawal fee from state")?
@@ -141,12 +117,12 @@ pub(crate) trait StateWriteExt: StateWrite {
     ) -> Result<()>
     where
         TAsset: Display,
-        asset::IbcPrefixed: From<&'a TAsset>,
+        &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
     {
         let bytes = StoredValue::from(storage::Balance::from(balance))
             .serialize()
             .wrap_err("failed to serialize ibc channel balance")?;
-        self.put_raw(channel_balance_storage_key(channel, asset), bytes);
+        self.put_raw(keys::channel_balance(channel, asset), bytes);
         Ok(())
     }
 
@@ -159,7 +135,7 @@ pub(crate) trait StateWriteExt: StateWrite {
     ) -> Result<()>
     where
         TAsset: Sync + Display,
-        asset::IbcPrefixed: From<&'a TAsset>,
+        &'a TAsset: Into<Cow<'a, asset::IbcPrefixed>>,
     {
         let old_balance = self
             .get_ibc_channel_balance(channel, asset)
@@ -179,7 +155,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::AddressBytes::from(&address))
             .serialize()
             .wrap_err("failed to serialize ibc sudo address")?;
-        self.put_raw(IBC_SUDO_STORAGE_KEY.to_string(), bytes);
+        self.put_raw(keys::IBC_SUDO.to_string(), bytes);
         Ok(())
     }
 
@@ -188,13 +164,13 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::Unit
             .serialize()
             .wrap_err("failed to serialize unit for ibc relayer address")?;
-        self.put_raw(ibc_relayer_key(address), bytes);
+        self.put_raw(keys::ibc_relayer(address), bytes);
         Ok(())
     }
 
     #[instrument(skip_all)]
     fn delete_ibc_relayer_address<T: AddressBytes>(&mut self, address: &T) {
-        self.delete(ibc_relayer_key(address));
+        self.delete(keys::ibc_relayer(address));
     }
 
     #[instrument(skip_all)]
@@ -202,7 +178,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::Fee::from(fee))
             .serialize()
             .wrap_err("failed to serialize ics20 withdrawal base fee")?;
-        self.put_raw(ICS20_WITHDRAWAL_BASE_FEE_STORAGE_KEY.to_string(), bytes);
+        self.put_raw(keys::ICS20_WITHDRAWAL_BASE_FEE.to_string(), bytes);
         Ok(())
     }
 }
@@ -211,21 +187,11 @@ impl<T: StateWrite> StateWriteExt for T {}
 
 #[cfg(test)]
 mod tests {
-    use astria_core::primitive::v1::{
-        asset,
-        Address,
-    };
     use cnidarium::StateDelta;
-    use ibc_types::core::channel::ChannelId;
-    use insta::assert_snapshot;
 
-    use super::{
-        StateReadExt as _,
-        StateWriteExt as _,
-    };
+    use super::*;
     use crate::{
-        address::StateWriteExt,
-        ibc::state_ext::channel_balance_storage_key,
+        address::StateWriteExt as _,
         test_utils::{
             astria_address,
             ASTRIA_PREFIX,
@@ -235,6 +201,7 @@ mod tests {
     fn asset_0() -> asset::Denom {
         "asset_0".parse().unwrap()
     }
+
     fn asset_1() -> asset::Denom {
         "asset_1".parse().unwrap()
     }
@@ -517,23 +484,4 @@ mod tests {
         let retrieved_fee = state.get_ics20_withdrawal_base_fee().await.unwrap();
         assert_eq!(retrieved_fee, 123);
     }
-
-    #[test]
-    fn storage_keys_have_not_changed() {
-        let channel = ChannelId::new(5);
-        let address: Address = "astria1rsxyjrcm255ds9euthjx6yc3vrjt9sxrm9cfgm"
-            .parse()
-            .unwrap();
-
-        assert_snapshot!(super::ibc_relayer_key(&address));
-
-        let asset = "an/asset/with/a/prefix"
-            .parse::<astria_core::primitive::v1::asset::Denom>()
-            .unwrap();
-        assert_eq!(
-            channel_balance_storage_key(&channel, &asset),
-            channel_balance_storage_key(&channel, &asset.to_ibc_prefixed()),
-        );
-        assert_snapshot!(channel_balance_storage_key(&channel, &asset));
-    }
 }
diff --git a/crates/astria-sequencer/src/ibc/storage/keys.rs b/crates/astria-sequencer/src/ibc/storage/keys.rs
new file mode 100644
index 0000000000..8184c64e42
--- /dev/null
+++ b/crates/astria-sequencer/src/ibc/storage/keys.rs
@@ -0,0 +1,73 @@
+use std::borrow::Cow;
+
+use astria_core::primitive::v1::asset::IbcPrefixed;
+use ibc_types::core::channel::ChannelId;
+
+use crate::{
+    accounts::AddressBytes,
+    storage::keys::{
+        AccountPrefixer,
+        Asset,
+    },
+};
+
+pub(in crate::ibc) const IBC_SUDO: &str = "ibc/sudo";
+pub(in crate::ibc) const ICS20_WITHDRAWAL_BASE_FEE: &str = "ibc/ics20_withdrawal_base_fee";
+const IBC_RELAYER_PREFIX: &str = "ibc/relayer/";
+
+/// Example: `ibc/channel-xxx/balance/ibc/0101....0101`.
+///                      |int|           |64 hex chars|
+pub(in crate::ibc) fn channel_balance<'a, TAsset>(channel: &ChannelId, asset: &'a TAsset) -> String
+where
+    &'a TAsset: Into<Cow<'a, IbcPrefixed>>,
+{
+    format!("ibc/{channel}/balance/{}", Asset::from(asset))
+}
+
+/// Example: `ibc/relayer/gGhH....zZ4=`.
+///                      |base64 chars|
+pub(in crate::ibc) fn ibc_relayer<T: AddressBytes>(address: &T) -> String {
+    AccountPrefixer::new(IBC_RELAYER_PREFIX, address).to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use astria_core::primitive::v1::{
+        asset::Denom,
+        Address,
+    };
+
+    use super::*;
+
+    const COMPONENT_PREFIX: &str = "ibc/";
+
+    fn channel_id() -> ChannelId {
+        ChannelId::new(5)
+    }
+
+    fn address() -> Address {
+        "astria1rsxyjrcm255ds9euthjx6yc3vrjt9sxrm9cfgm"
+            .parse()
+            .unwrap()
+    }
+
+    fn asset() -> Denom {
+        "an/asset/with/a/prefix".parse().unwrap()
+    }
+
+    #[test]
+    fn keys_should_not_change() {
+        insta::assert_snapshot!(IBC_SUDO);
+        insta::assert_snapshot!(ICS20_WITHDRAWAL_BASE_FEE);
+        insta::assert_snapshot!(channel_balance(&channel_id(), &asset()));
+        insta::assert_snapshot!(ibc_relayer(&address()));
+    }
+
+    #[test]
+    fn keys_should_have_component_prefix() {
+        assert!(IBC_SUDO.starts_with(COMPONENT_PREFIX));
+        assert!(ICS20_WITHDRAWAL_BASE_FEE.starts_with(COMPONENT_PREFIX));
+        assert!(channel_balance(&channel_id(), &asset()).starts_with(COMPONENT_PREFIX));
+        assert!(ibc_relayer(&address()).starts_with(COMPONENT_PREFIX));
+    }
+}
diff --git a/crates/astria-sequencer/src/ibc/storage/mod.rs b/crates/astria-sequencer/src/ibc/storage/mod.rs
index 2cda197b89..1f76fd5b36 100644
--- a/crates/astria-sequencer/src/ibc/storage/mod.rs
+++ b/crates/astria-sequencer/src/ibc/storage/mod.rs
@@ -1,3 +1,4 @@
+pub(super) mod keys;
 mod values;
 
 pub(crate) use values::Value;
diff --git a/crates/astria-sequencer/src/ibc/storage/snapshots/astria_sequencer__ibc__storage__keys__tests__keys_should_not_change-2.snap b/crates/astria-sequencer/src/ibc/storage/snapshots/astria_sequencer__ibc__storage__keys__tests__keys_should_not_change-2.snap
new file mode 100644
index 0000000000..16047d71da
--- /dev/null
+++ b/crates/astria-sequencer/src/ibc/storage/snapshots/astria_sequencer__ibc__storage__keys__tests__keys_should_not_change-2.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/ibc/storage/keys.rs
+assertion_line: 64
+expression: ICS20_WITHDRAWAL_BASE_FEE_KEY
+---
+ibc/ics20_withdrawal_base_fee
diff --git a/crates/astria-sequencer/src/ibc/storage/snapshots/astria_sequencer__ibc__storage__keys__tests__keys_should_not_change-3.snap b/crates/astria-sequencer/src/ibc/storage/snapshots/astria_sequencer__ibc__storage__keys__tests__keys_should_not_change-3.snap
new file mode 100644
index 0000000000..43ea3e793d
--- /dev/null
+++ b/crates/astria-sequencer/src/ibc/storage/snapshots/astria_sequencer__ibc__storage__keys__tests__keys_should_not_change-3.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/ibc/storage/keys.rs
+assertion_line: 62
+expression: "channel_balance(&channel_id(), &asset())"
+---
+ibc/channel-5/balance/ibc/be429a02d00837245167a2616674a979a2ac6f9806468b48a975b156ad711320
diff --git a/crates/astria-sequencer/src/ibc/storage/snapshots/astria_sequencer__ibc__storage__keys__tests__keys_should_not_change-4.snap b/crates/astria-sequencer/src/ibc/storage/snapshots/astria_sequencer__ibc__storage__keys__tests__keys_should_not_change-4.snap
new file mode 100644
index 0000000000..a5f30b1421
--- /dev/null
+++ b/crates/astria-sequencer/src/ibc/storage/snapshots/astria_sequencer__ibc__storage__keys__tests__keys_should_not_change-4.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/ibc/storage/keys.rs
+assertion_line: 63
+expression: ibc_relayer(&address())
+---
+ibc/relayer/HAxJDxtVKNgXPF3kbRMRYOSywMM=
diff --git a/crates/astria-sequencer/src/ibc/storage/snapshots/astria_sequencer__ibc__storage__keys__tests__keys_should_not_change.snap b/crates/astria-sequencer/src/ibc/storage/snapshots/astria_sequencer__ibc__storage__keys__tests__keys_should_not_change.snap
new file mode 100644
index 0000000000..c8f53e7af2
--- /dev/null
+++ b/crates/astria-sequencer/src/ibc/storage/snapshots/astria_sequencer__ibc__storage__keys__tests__keys_should_not_change.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/ibc/storage/keys.rs
+assertion_line: 63
+expression: IBC_SUDO_KEY
+---
+ibc/sudo
diff --git a/crates/astria-sequencer/src/lib.rs b/crates/astria-sequencer/src/lib.rs
index 8322623b57..55bf2dfa5b 100644
--- a/crates/astria-sequencer/src/lib.rs
+++ b/crates/astria-sequencer/src/lib.rs
@@ -19,7 +19,6 @@ pub(crate) mod sequence;
 mod sequencer;
 pub(crate) mod service;
 pub(crate) mod storage;
-pub(crate) mod storage_keys;
 #[cfg(any(test, feature = "benchmark"))]
 pub(crate) mod test_utils;
 pub(crate) mod transaction;
diff --git a/crates/astria-sequencer/src/sequence/action.rs b/crates/astria-sequencer/src/sequence/action.rs
index dffbdeff61..ccc4728494 100644
--- a/crates/astria-sequencer/src/sequence/action.rs
+++ b/crates/astria-sequencer/src/sequence/action.rs
@@ -1,7 +1,4 @@
-use astria_core::{
-    protocol::transaction::v1alpha1::action::Sequence,
-    Protobuf as _,
-};
+use astria_core::protocol::transaction::v1alpha1::action::Sequence;
 use astria_eyre::eyre::{
     ensure,
     OptionExt as _,
@@ -60,7 +57,7 @@ impl ActionHandler for Sequence {
         ensure!(curr_balance >= fee, "insufficient funds");
 
         state
-            .get_and_increase_block_fees(&self.fee_asset, fee, Self::full_name())
+            .get_and_increase_block_fees::<Self, _>(&self.fee_asset, fee)
             .await
             .wrap_err("failed to add to block fees")?;
         state
diff --git a/crates/astria-sequencer/src/sequence/state_ext.rs b/crates/astria-sequencer/src/sequence/state_ext.rs
index 2844abb2b2..6a03abbbe2 100644
--- a/crates/astria-sequencer/src/sequence/state_ext.rs
+++ b/crates/astria-sequencer/src/sequence/state_ext.rs
@@ -13,18 +13,18 @@ use cnidarium::{
 };
 use tracing::instrument;
 
-use super::storage;
+use super::storage::{
+    self,
+    keys,
+};
 use crate::storage::StoredValue;
 
-const SEQUENCE_ACTION_BASE_FEE_STORAGE_KEY: &str = "seqbasefee";
-const SEQUENCE_ACTION_BYTE_COST_MULTIPLIER_STORAGE_KEY: &str = "seqmultiplier";
-
 #[async_trait]
 pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_sequence_action_base_fee(&self) -> Result<u128> {
         let bytes = self
-            .get_raw(SEQUENCE_ACTION_BASE_FEE_STORAGE_KEY)
+            .get_raw(keys::SEQUENCE_ACTION_BASE_FEE)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw sequence action base fee from state")?
@@ -37,7 +37,7 @@ pub(crate) trait StateReadExt: StateRead {
     #[instrument(skip_all)]
     async fn get_sequence_action_byte_cost_multiplier(&self) -> Result<u128> {
         let bytes = self
-            .get_raw(SEQUENCE_ACTION_BYTE_COST_MULTIPLIER_STORAGE_KEY)
+            .get_raw(keys::SEQUENCE_ACTION_BYTE_COST_MULTIPLIER)
             .await
             .map_err(anyhow_to_eyre)
             .wrap_err("failed reading raw sequence action byte cost multiplier from state")?
@@ -57,7 +57,7 @@ pub(crate) trait StateWriteExt: StateWrite {
         let bytes = StoredValue::from(storage::Fee::from(fee))
             .serialize()
             .context("failed to serialize sequence action base fee")?;
-        self.put_raw(SEQUENCE_ACTION_BASE_FEE_STORAGE_KEY.to_string(), bytes);
+        self.put_raw(keys::SEQUENCE_ACTION_BASE_FEE.to_string(), bytes);
         Ok(())
     }
 
@@ -67,7 +67,7 @@ pub(crate) trait StateWriteExt: StateWrite {
             .serialize()
             .context("failed to serialize sequence action byte cost multiplier")?;
         self.put_raw(
-            SEQUENCE_ACTION_BYTE_COST_MULTIPLIER_STORAGE_KEY.to_string(),
+            keys::SEQUENCE_ACTION_BYTE_COST_MULTIPLIER.to_string(),
             bytes,
         );
         Ok(())
@@ -80,10 +80,7 @@ impl<T: StateWrite> StateWriteExt for T {}
 mod tests {
     use cnidarium::StateDelta;
 
-    use super::{
-        StateReadExt as _,
-        StateWriteExt as _,
-    };
+    use super::*;
 
     #[tokio::test]
     async fn sequence_action_base_fee() {
diff --git a/crates/astria-sequencer/src/sequence/storage/keys.rs b/crates/astria-sequencer/src/sequence/storage/keys.rs
new file mode 100644
index 0000000000..de28eef30e
--- /dev/null
+++ b/crates/astria-sequencer/src/sequence/storage/keys.rs
@@ -0,0 +1,22 @@
+pub(in crate::sequence) const SEQUENCE_ACTION_BASE_FEE: &str = "sequence/base_fee";
+pub(in crate::sequence) const SEQUENCE_ACTION_BYTE_COST_MULTIPLIER: &str =
+    "sequence/byte_cost_multiplier";
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const COMPONENT_PREFIX: &str = "sequence/";
+
+    #[test]
+    fn keys_should_not_change() {
+        insta::assert_snapshot!(SEQUENCE_ACTION_BASE_FEE);
+        insta::assert_snapshot!(SEQUENCE_ACTION_BYTE_COST_MULTIPLIER);
+    }
+
+    #[test]
+    fn keys_should_have_component_prefix() {
+        assert!(SEQUENCE_ACTION_BASE_FEE.starts_with(COMPONENT_PREFIX));
+        assert!(SEQUENCE_ACTION_BYTE_COST_MULTIPLIER.starts_with(COMPONENT_PREFIX));
+    }
+}
diff --git a/crates/astria-sequencer/src/sequence/storage/mod.rs b/crates/astria-sequencer/src/sequence/storage/mod.rs
index e6fee4261d..92e06f015f 100644
--- a/crates/astria-sequencer/src/sequence/storage/mod.rs
+++ b/crates/astria-sequencer/src/sequence/storage/mod.rs
@@ -1,3 +1,4 @@
+pub(super) mod keys;
 mod values;
 
 pub(super) use values::Fee;
diff --git a/crates/astria-sequencer/src/sequence/storage/snapshots/astria_sequencer__sequence__storage__keys__tests__keys_should_not_change-2.snap b/crates/astria-sequencer/src/sequence/storage/snapshots/astria_sequencer__sequence__storage__keys__tests__keys_should_not_change-2.snap
new file mode 100644
index 0000000000..1c2afa9bca
--- /dev/null
+++ b/crates/astria-sequencer/src/sequence/storage/snapshots/astria_sequencer__sequence__storage__keys__tests__keys_should_not_change-2.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/sequence/storage/keys.rs
+assertion_line: 14
+expression: SEQUENCE_ACTION_BYTE_COST_MULTIPLIER_KEY
+---
+sequence/byte_cost_multiplier
diff --git a/crates/astria-sequencer/src/sequence/storage/snapshots/astria_sequencer__sequence__storage__keys__tests__keys_should_not_change.snap b/crates/astria-sequencer/src/sequence/storage/snapshots/astria_sequencer__sequence__storage__keys__tests__keys_should_not_change.snap
new file mode 100644
index 0000000000..d1d9fd3513
--- /dev/null
+++ b/crates/astria-sequencer/src/sequence/storage/snapshots/astria_sequencer__sequence__storage__keys__tests__keys_should_not_change.snap
@@ -0,0 +1,6 @@
+---
+source: crates/astria-sequencer/src/sequence/storage/keys.rs
+assertion_line: 13
+expression: SEQUENCE_ACTION_BASE_FEE_KEY
+---
+sequence/base_fee
diff --git a/crates/astria-sequencer/src/storage/keys.rs b/crates/astria-sequencer/src/storage/keys.rs
new file mode 100644
index 0000000000..edf0333ba8
--- /dev/null
+++ b/crates/astria-sequencer/src/storage/keys.rs
@@ -0,0 +1,91 @@
+use std::{
+    borrow::Cow,
+    fmt::{
+        self,
+        Display,
+        Formatter,
+    },
+    str::FromStr,
+};
+
+use astria_core::primitive::v1::asset::{
+    denom::ParseIbcPrefixedError,
+    IbcPrefixed,
+};
+
+use crate::accounts::AddressBytes;
+
+/// Helper struct whose `Display` impl outputs the prefix followed by the hex-encoded address.
+pub(crate) struct AccountPrefixer<'a, T> {
+    prefix: &'static str,
+    address: &'a T,
+}
+
+impl<'a, T> AccountPrefixer<'a, T> {
+    pub(crate) fn new(prefix: &'static str, address: &'a T) -> Self {
+        Self {
+            prefix,
+            address,
+        }
+    }
+}
+
+impl<'a, T: AddressBytes> Display for AccountPrefixer<'a, T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        use base64::{
+            display::Base64Display,
+            engine::general_purpose::URL_SAFE,
+        };
+        f.write_str(self.prefix)?;
+        Base64Display::new(self.address.address_bytes(), &URL_SAFE).fmt(f)
+    }
+}
+
+/// Helper struct whose `Display` impl outputs the hex-encoded ibc-prefixed address, and that can be
+/// parsed from such a hex-encoded form.
+#[cfg_attr(test, derive(Debug, PartialEq))]
+pub(crate) struct Asset<'a>(Cow<'a, IbcPrefixed>);
+
+impl<'a> Asset<'a> {
+    pub(crate) fn get(self) -> IbcPrefixed {
+        self.0.into_owned()
+    }
+}
+
+impl<'a> Display for Asset<'a> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl<'a, T> From<&'a T> for Asset<'a>
+where
+    &'a T: Into<Cow<'a, IbcPrefixed>>,
+{
+    fn from(value: &'a T) -> Self {
+        Self(value.into())
+    }
+}
+
+impl<'a> FromStr for Asset<'a> {
+    type Err = ParseIbcPrefixedError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self(Cow::Owned(s.parse()?)))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Asset;
+
+    #[test]
+    fn asset_key_to_string_parse_roundtrip() {
+        let asset = "an/asset/with/a/prefix"
+            .parse::<astria_core::primitive::v1::asset::Denom>()
+            .unwrap();
+        let expected = Asset::from(&asset);
+        let actual = expected.to_string().parse::<Asset>().unwrap();
+        assert_eq!(expected, actual);
+    }
+}
diff --git a/crates/astria-sequencer/src/storage/mod.rs b/crates/astria-sequencer/src/storage/mod.rs
index e3d45502e8..a4a1b61c98 100644
--- a/crates/astria-sequencer/src/storage/mod.rs
+++ b/crates/astria-sequencer/src/storage/mod.rs
@@ -1,3 +1,4 @@
+pub(crate) mod keys;
 mod stored_value;
 
 pub(crate) use stored_value::StoredValue;
diff --git a/crates/astria-sequencer/src/storage_keys.rs b/crates/astria-sequencer/src/storage_keys.rs
deleted file mode 100644
index 29bbe72f2a..0000000000
--- a/crates/astria-sequencer/src/storage_keys.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-pub(crate) mod hunks {
-    use std::str::FromStr;
-
-    use astria_core::primitive::v1::asset;
-
-    #[derive(Clone, Copy, Debug, PartialEq)]
-    pub(crate) struct Asset(asset::IbcPrefixed);
-
-    impl Asset {
-        pub(crate) fn get(self) -> asset::IbcPrefixed {
-            self.0
-        }
-    }
-
-    impl std::fmt::Display for Asset {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            for byte in self.get().as_bytes() {
-                f.write_fmt(format_args!("{byte:02x}"))?;
-            }
-            Ok(())
-        }
-    }
-
-    impl<T: Into<asset::IbcPrefixed>> From<T> for Asset {
-        fn from(value: T) -> Self {
-            Self(value.into())
-        }
-    }
-
-    #[derive(Debug, thiserror::Error)]
-    #[error("failed to parse input as asset key")]
-    pub(crate) struct ParseAssetKeyError {
-        #[from]
-        source: hex::FromHexError,
-    }
-
-    impl FromStr for Asset {
-        type Err = ParseAssetKeyError;
-
-        fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-            use hex::FromHex as _;
-            let bytes = <[u8; 32]>::from_hex(s)?;
-            Ok(Self(asset::IbcPrefixed::new(bytes)))
-        }
-    }
-
-    #[cfg(test)]
-    mod tests {
-        use super::Asset;
-        #[test]
-        fn asset_key_to_string_parse_roundtrip() {
-            let asset = "an/asset/with/a/prefix"
-                .parse::<astria_core::primitive::v1::asset::Denom>()
-                .unwrap();
-            let expected = Asset::from(asset);
-            let actual = expected.to_string().parse::<Asset>().unwrap();
-            assert_eq!(expected, actual);
-        }
-    }
-}