refactor(ibc): remove dependency on penumbra-chain specific state keys

Cargo.toml

@@ -48,6 +48,7 @@ members = [
   "crates/misc/tct-visualize",
   "crates/bench",
   "tools/summonerd",
+  "crates/util/wrapper-derive",
 ]
 
 # Optimize for small binaries in just the wasm crate.

crates/bin/pd/Cargo.toml

@@ -23,6 +23,7 @@ download-proving-keys = ["penumbra-proof-params/download-proving-keys"]
 # Workspace dependencies
 penumbra-proto = { path = "../../proto" }
 cnidarium = { path = "../../cnidarium", features = ["migration", "rpc"] }
+cnidarium-component = { path = "../../cnidarium-component" }
 penumbra-asset = { path = "../../core/asset" }
 penumbra-keys = { path = "../../core/keys" }
 penumbra-shielded-pool = { path = "../../core/component/shielded-pool", features = [
@@ -44,6 +45,7 @@ penumbra-app = { path = "../../core/app" }
 penumbra-custody = { path = "../../custody" }
 penumbra-tower-trace = { path = "../../util/tower-trace" }
 penumbra-tendermint-proxy = { path = "../../util/tendermint-proxy" }
+wrapper-derive = { path = "../../util/wrapper-derive" }
 
 # Penumbra dependencies
 decaf377 = { version = "0.5", features = ["parallel"] }

crates/bin/pd/src/ibc.rs

@@ -0,0 +1,32 @@
+use anyhow::Result;
+use cnidarium::StateRead;
+use cnidarium::Storage;
+use cnidarium_component::ChainStateReadExt;
+use ibc_types::core::commitment::MerkleProof;
+// implemented by [`SnapshotWrapper`]
+use penumbra_chain::component::StateReadExt as _;
+
+#[derive(wrapper_derive::StateRead, wrapper_derive::ChainStateReadExt, Clone)]
+pub struct SnapshotWrapper<S: StateRead>(S);
+
+#[async_trait::async_trait]
+impl penumbra_ibc::component::rpc::Snapshot for SnapshotWrapper<cnidarium::Snapshot> {
+    fn version(&self) -> u64 {
+        self.0.version()
+    }
+
+    async fn get_with_proof(&self, key: Vec<u8>) -> Result<(Option<Vec<u8>>, MerkleProof)> {
+        self.0.get_with_proof(key).await
+    }
+}
+
+#[derive(Clone)]
+pub struct StorageWrapper(pub Storage);
+
+impl penumbra_ibc::component::rpc::Storage<SnapshotWrapper<cnidarium::Snapshot>>
+    for StorageWrapper
+{
+    fn latest_snapshot(&self) -> SnapshotWrapper<cnidarium::Snapshot> {
+        SnapshotWrapper(self.0.latest_snapshot())
+    }
+}

crates/bin/pd/src/lib.rs

@@ -4,6 +4,7 @@
 #![recursion_limit = "512"]
 
 mod consensus;
+mod ibc;
 mod info;
 mod mempool;
 mod metrics;
@@ -16,6 +17,7 @@ pub mod upgrade;
 
 pub use crate::metrics::register_metrics;
 pub use consensus::Consensus;
+pub use ibc::{SnapshotWrapper, StorageWrapper};
 pub use info::Info;
 pub use mempool::Mempool;
 pub use penumbra_app::app::App;

crates/bin/pd/src/main.rs

@@ -372,7 +372,8 @@ async fn main() -> anyhow::Result<()> {
                 )
                 .expect("failed to spawn abci server");
 
-            let ibc = penumbra_ibc::component::rpc::IbcQuery::new(storage.clone());
+            let ibc =
+                penumbra_ibc::component::rpc::IbcQuery::new(pd::StorageWrapper(storage.clone()));
 
             // TODO: Once we migrate to Tonic 0.10.0, we'll be able to use the
             // `Routes` structure to have each component define a method that

crates/cnidarium-component/src/chain_state_read_ext.rs

@@ -0,0 +1,11 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use cnidarium::StateRead;
+
+#[async_trait]
+pub trait ChainStateReadExt: StateRead {
+    async fn get_chain_id(&self) -> Result<String>;
+    async fn get_revision_number(&self) -> Result<u64>;
+    async fn get_block_height(&self) -> Result<u64>;
+    async fn get_block_timestamp(&self) -> Result<tendermint::Time>;
+}

crates/cnidarium-component/src/lib.rs

@@ -39,7 +39,9 @@
 #![deny(clippy::unwrap_used)]
 
 mod action_handler;
+mod chain_state_read_ext;
 mod component;
 
 pub use action_handler::ActionHandler;
+pub use chain_state_read_ext::ChainStateReadExt;
 pub use component::Component;

crates/core/app/Cargo.toml

@@ -30,6 +30,7 @@ penumbra-ibc = { path = "../component/ibc", features = ["component"] }
 penumbra-distributions = { path = "../component/distributions" }
 penumbra-compact-block = { path = "../component/compact-block" }
 penumbra-transaction = { path = "../transaction", features = ["parallel"] }
+wrapper-derive = { path = "../../util/wrapper-derive" }
 
 # Penumbra dependencies
 decaf377 = { version = "0.5" }

crates/core/app/src/action_handler/actions.rs

@@ -10,6 +10,8 @@ use penumbra_txhash::TransactionContext;
 
 mod submit;
 
+use crate::state_delta_wrapper::StateDeltaWrapper;
+
 use super::ActionHandler;
 use cnidarium_component::ActionHandler as _;
 
@@ -109,10 +111,12 @@ impl ActionHandler for Action {
             Action::Spend(action) => action.execute(state).await,
             Action::Output(action) => action.execute(state).await,
             Action::IbcRelay(action) => {
+                let mut state = state;
+                let wrapper = StateDeltaWrapper(&mut state);
                 action
                     .clone()
                     .with_handler::<Ics20Transfer>()
-                    .execute(state)
+                    .execute(wrapper)
                     .await
             }
             Action::Ics20Withdrawal(action) => action.execute(state).await,

crates/core/app/src/app/mod.rs

@@ -29,6 +29,7 @@ use tracing::Instrument;
 
 use crate::action_handler::ActionHandler;
 use crate::params::AppParameters;
+use crate::state_delta_wrapper::ArcStateDeltaWrapper;
 use crate::{genesis, CommunityPoolStateReadExt};
 
 pub mod state_key;
@@ -213,11 +214,11 @@ impl App {
             }
         }
 
-        // Run each of the begin block handlers for each component, in sequence:
+        // Run each of the begin block handlers for each component, in sequence.
         let mut arc_state_tx = Arc::new(state_tx);
         ShieldedPool::begin_block(&mut arc_state_tx, begin_block).await;
         Distributions::begin_block(&mut arc_state_tx, begin_block).await;
-        IBCComponent::begin_block(&mut arc_state_tx, begin_block).await;
+        IBCComponent::begin_block(&mut ArcStateDeltaWrapper(&mut arc_state_tx), begin_block).await;
         Governance::begin_block(&mut arc_state_tx, begin_block).await;
         Staking::begin_block(&mut arc_state_tx, begin_block).await;
         Fee::begin_block(&mut arc_state_tx, begin_block).await;

crates/core/app/src/lib.rs

@@ -2,6 +2,7 @@
 mod action_handler;
 mod community_pool_ext;
 mod mock_client;
+mod state_delta_wrapper;
 mod temp_storage_ext;
 
 pub use action_handler::ActionHandler;

crates/core/app/src/state_delta_wrapper.rs

@@ -0,0 +1,17 @@
+use anyhow::Result;
+use cnidarium::StateRead;
+use cnidarium::StateWrite;
+use cnidarium_component::ChainStateReadExt;
+use penumbra_chain::component::StateReadExt;
+
+#[derive(
+    wrapper_derive::StateRead, wrapper_derive::StateWrite, wrapper_derive::ChainStateReadExt,
+)]
+pub(crate) struct StateDeltaWrapper<'a, S: StateRead + StateWrite>(pub(crate) &'a mut S);
+
+#[derive(
+    wrapper_derive::StateRead, wrapper_derive::StateWrite, wrapper_derive::ChainStateReadExt,
+)]
+pub(crate) struct ArcStateDeltaWrapper<'a, S: StateRead + StateWrite>(
+    pub(crate) &'a mut std::sync::Arc<S>,
+);

crates/core/component/chain/src/component/view.rs

@@ -17,7 +17,6 @@ use crate::{
 ///
 /// Note: the `get_` methods in this trait assume that the state store has been
 /// initialized, so they will error on an empty state.
-//#[async_trait(?Send)]
 #[async_trait]
 pub trait StateReadExt: StateRead {
     /// Indicates if the chain parameters have been updated in this block.

crates/core/component/ibc/Cargo.toml

@@ -15,17 +15,18 @@ component = [
 default = ["component", "std"]
 std = ["ibc-types/std"]
 docsrs = []
-rpc = ["dep:tonic", "ibc-proto/client", "ibc-proto/server"]
+rpc = ["dep:tonic", "dep:penumbra-chain", "dep:wrapper-derive", "ibc-proto/client", "ibc-proto/server"]
 
 [dependencies]
 # Workspace dependencies
 penumbra-proto = { path = "../../../proto", default-features = false }
 cnidarium = { path = "../../../cnidarium", optional = true }
 cnidarium-component = { path = "../../../cnidarium-component", optional = true }
-penumbra-chain = { path = "../chain", default-features = false }
 penumbra-asset = { path = "../../../core/asset", default-features = false }
 penumbra-num = { path = "../../../core/num", default-features = false }
 penumbra-keys = { path = "../../../core/keys", default-features = false }
+wrapper-derive = { path = "../../../util/wrapper-derive", optional = true }
+penumbra-chain = { path = "../chain", default-features = false, optional = true }
 penumbra-txhash = { path = "../../../core/txhash", default-features = false }
 
 # Penumbra dependencies
@@ -55,4 +56,6 @@ tonic = { version = "0.10", optional = true }
 tower = "0.4"
 
 [dev-dependencies]
+penumbra-chain = { path = "../chain", default-features = false }
 tokio = { version = "1.3", features = ["full"] }
+wrapper-derive = { path = "../../../util/wrapper-derive" }

crates/core/component/ibc/src/component/action_handler/ibc_action.rs

@@ -1,19 +1,16 @@
 use std::sync::Arc;
 
 use anyhow::{Context, Result};
-use async_trait::async_trait;
 use cnidarium::{StateRead, StateWrite};
-use cnidarium_component::ActionHandler;
+use cnidarium_component::ChainStateReadExt;
 
 use crate::{
     component::{app_handler::AppHandler, MsgHandler as _},
     IbcActionWithHandler, IbcRelay,
 };
 
-#[async_trait]
-impl<H: AppHandler> ActionHandler for IbcActionWithHandler<H> {
-    type CheckStatelessContext = ();
-    async fn check_stateless(&self, _context: ()) -> Result<()> {
+impl<H: AppHandler> IbcActionWithHandler<H> {
+    pub async fn check_stateless(&self, _context: ()) -> Result<()> {
         let action = self.action();
         match action {
             IbcRelay::CreateClient(msg) => msg.check_stateless::<H>().await?,
@@ -41,12 +38,12 @@ impl<H: AppHandler> ActionHandler for IbcActionWithHandler<H> {
         Ok(())
     }
 
-    async fn check_stateful<S: StateRead + 'static>(&self, _state: Arc<S>) -> Result<()> {
+    pub async fn check_stateful<_S: StateRead + 'static>(&self, _state: Arc<_S>) -> Result<()> {
         // No-op: IBC actions merge check_stateful and execute.
         Ok(())
     }
 
-    async fn execute<S: StateWrite>(&self, state: S) -> Result<()> {
+    pub async fn execute<S: StateWrite + ChainStateReadExt>(&self, state: S) -> Result<()> {
         let action = self.action();
         match action {
             IbcRelay::CreateClient(msg) => msg