Implement initial StarknetBuilder and StarknetBuildComponents

relayer/crates/starknet-chain-components/Cargo.toml

@@ -27,10 +27,11 @@ hermes-wasm-encoding-components     = { workspace = true }
 ibc       = { workspace = true }
 ibc-proto = { workspace = true }
 
-starknet                    = { workspace = true }
-serde_json                  = { workspace = true }
 cairo-lang-starknet-classes = { workspace = true }
-ibc-client-starknet-types   = { workspace = true }
 http                        = { workspace = true }
-tonic                       = { workspace = true }
+ibc-client-starknet-types   = { workspace = true }
 prost-types                 = { workspace = true }
+serde                       = { workspace = true }
+serde_json                  = { workspace = true }
+starknet                    = { workspace = true }
+tonic                       = { workspace = true }

relayer/crates/starknet-cli/src/types/config.rs → relayer/crates/starknet-chain-components/src/impls/types/config.rs

@@ -1,7 +1,8 @@
 use hermes_cosmos_chain_components::impls::types::config::CosmosChainConfig;
-use hermes_starknet_test_components::types::wallet::StarknetWallet;
 use serde::{Deserialize, Serialize};
 
+use crate::types::wallet::StarknetWallet;
+
 #[derive(Debug, Serialize, Deserialize)]
 pub struct StarknetRelayerConfig {
     pub cosmos_chain_config: Option<CosmosChainConfig>,

relayer/crates/starknet-chain-components/src/impls/types/mod.rs

@@ -4,6 +4,7 @@ pub mod blob;
 pub mod chain_id;
 pub mod client;
 pub mod commitment_proof;
+pub mod config;
 pub mod contract;
 pub mod denom;
 pub mod event;

relayer/crates/starknet-chain-components/src/types/mod.rs

@@ -15,3 +15,4 @@ pub mod payloads;
 pub mod register;
 pub mod status;
 pub mod tx_response;
+pub mod wallet;

relayer/crates/starknet-cli/Cargo.toml

@@ -29,9 +29,11 @@ hermes-relayer-components         = { workspace = true }
 hermes-cosmos-relayer             = { workspace = true }
 hermes-cosmos-integration-tests   = { workspace = true }
 hermes-cosmos-chain-components    = { workspace = true }
+hermes-starknet-chain-components  = { workspace = true }
+hermes-starknet-relayer           = { workspace = true }
+hermes-starknet-integration-tests = { workspace = true }
 hermes-starknet-test-components   = { workspace = true }
 hermes-test-components            = { workspace = true }
-hermes-starknet-integration-tests = { workspace = true }
 
 ibc = { workspace = true }
 

relayer/crates/starknet-cli/src/contexts/app.rs

@@ -33,6 +33,9 @@ use hermes_runtime::types::runtime::HermesRuntime;
 use hermes_runtime_components::traits::runtime::{
     HasRuntime, RuntimeGetterComponent, RuntimeTypeComponent,
 };
+use hermes_starknet_chain_components::impls::types::config::{
+    StarknetChainConfig, StarknetRelayerConfig,
+};
 use hermes_starknet_integration_tests::contexts::bootstrap::StarknetBootstrap;
 use hermes_starknet_integration_tests::contexts::chain_driver::StarknetChainDriver;
 use hermes_test_components::chain_driver::traits::config::ConfigUpdater;
@@ -42,7 +45,6 @@ use crate::impls::bootstrap::starknet_chain::{BootstrapStarknetChainArgs, LoadSt
 use crate::impls::bootstrap::subcommand::{BootstrapSubCommand, RunBootstrapSubCommand};
 use crate::impls::error::ProvideCliError;
 use crate::impls::subcommand::{AllSubCommands, RunAllSubCommand};
-use crate::types::config::{StarknetChainConfig, StarknetRelayerConfig};
 
 #[derive(HasField)]
 pub struct StarknetApp {

relayer/crates/starknet-cli/src/lib.rs

@@ -2,4 +2,3 @@ extern crate alloc;
 
 pub mod contexts;
 pub mod impls;
-pub mod types;

relayer/crates/starknet-integration-tests/src/contexts/bootstrap.rs

@@ -22,6 +22,7 @@ use hermes_runtime::types::runtime::HermesRuntime;
 use hermes_runtime_components::traits::runtime::{
     HasRuntime, RuntimeGetterComponent, RuntimeTypeComponent,
 };
+use hermes_starknet_chain_components::types::wallet::StarknetWallet;
 use hermes_starknet_chain_context::contexts::chain::StarknetChain;
 use hermes_starknet_chain_context::impls::error::HandleStarknetChainError;
 use hermes_starknet_test_components::impls::bootstrap::bootstrap_chain::BootstrapStarknetDevnet;
@@ -30,7 +31,6 @@ use hermes_starknet_test_components::impls::types::genesis_config::ProvideStarkn
 use hermes_starknet_test_components::impls::types::node_config::ProvideStarknetNodeConfigType;
 use hermes_starknet_test_components::types::genesis_config::StarknetGenesisConfig;
 use hermes_starknet_test_components::types::node_config::StarknetNodeConfig;
-use hermes_starknet_test_components::types::wallet::StarknetWallet;
 use hermes_test_components::bootstrap::traits::chain::{
     CanBootstrapChain, ChainBootstrapperComponent,
 };

relayer/crates/starknet-integration-tests/src/contexts/chain_driver.rs

@@ -8,11 +8,11 @@ use cgp::prelude::*;
 use hermes_error::impls::ProvideHermesError;
 use hermes_runtime::types::runtime::HermesRuntime;
 use hermes_runtime_components::traits::runtime::{RuntimeGetterComponent, RuntimeTypeComponent};
+use hermes_starknet_chain_components::types::wallet::StarknetWallet;
 use hermes_starknet_chain_context::contexts::chain::StarknetChain;
 use hermes_starknet_chain_context::impls::error::HandleStarknetChainError;
 use hermes_starknet_test_components::types::genesis_config::StarknetGenesisConfig;
 use hermes_starknet_test_components::types::node_config::StarknetNodeConfig;
-use hermes_starknet_test_components::types::wallet::StarknetWallet;
 use hermes_test_components::chain_driver::traits::chain_process::ChainProcessTaker;
 use hermes_test_components::chain_driver::traits::types::chain::{
     ChainGetter, HasChain, ProvideChainType,

relayer/crates/starknet-relayer/Cargo.toml

@@ -20,7 +20,12 @@ hermes-encoding-components       = { workspace = true }
 hermes-logger                    = { workspace = true }
 hermes-relayer-components        = { workspace = true }
 hermes-cosmos-relayer            = { workspace = true }
+hermes-cosmos-chain-components   = { workspace = true }
 hermes-starknet-chain-context    = { workspace = true }
 hermes-starknet-chain-components = { workspace = true }
 
-eyre = { workspace = true }
+starknet = { workspace = true }
+
+eyre  = { workspace = true }
+serde = { workspace = true }
+url   = { workspace = true }

relayer/crates/starknet-relayer/src/contexts/builder.rs

@@ -0,0 +1,153 @@
+use alloc::sync::Arc;
+use core::ops::Deref;
+use std::marker::PhantomData;
+
+use cgp::core::component::UseDelegate;
+use cgp::core::error::{ErrorRaiserComponent, ErrorTypeComponent};
+use cgp::core::field::impls::use_field::WithField;
+use cgp::core::types::impls::WithType;
+use cgp::prelude::*;
+use hermes_cosmos_relayer::contexts::build::CosmosBuilder;
+use hermes_cosmos_relayer::contexts::chain::CosmosChain;
+use hermes_error::impls::ProvideHermesError;
+use hermes_error::types::Error;
+use hermes_error::HermesError;
+use hermes_relayer_components::build::traits::builders::chain_builder::{
+    CanBuildChain, ChainBuilder,
+};
+use hermes_relayer_components::multi::traits::chain_at::ChainTypeAtComponent;
+use hermes_relayer_components::multi::types::index::Index;
+use hermes_runtime::types::runtime::HermesRuntime;
+use hermes_runtime_components::traits::runtime::{RuntimeGetterComponent, RuntimeTypeComponent};
+use hermes_starknet_chain_components::impls::types::config::StarknetChainConfig;
+use hermes_starknet_chain_context::contexts::chain::StarknetChain;
+use hermes_starknet_chain_context::impls::error::HandleStarknetChainError;
+use ibc::core::host::types::identifiers::ChainId;
+use starknet::accounts::{ExecutionEncoding, SingleOwnerAccount};
+use starknet::core::types::Felt;
+use starknet::providers::jsonrpc::HttpTransport;
+use starknet::providers::{JsonRpcClient, Provider};
+use starknet::signers::{LocalWallet, SigningKey};
+use url::Url;
+
+#[derive(Clone)]
+pub struct StarknetBuilder {
+    pub fields: Arc<dyn HasStarknetBuilderFields>,
+}
+
+#[derive(HasField)]
+pub struct StarknetBuilderFields {
+    // Used to build CosmosChain
+    pub cosmos_builder: CosmosBuilder,
+    // Fields for StarknetChain
+    pub runtime: HermesRuntime,
+    pub starknet_chain_config: StarknetChainConfig,
+}
+
+impl Deref for StarknetBuilder {
+    type Target = StarknetBuilderFields;
+
+    fn deref(&self) -> &Self::Target {
+        self.fields.fields()
+    }
+}
+
+pub trait HasStarknetBuilderFields: Send + Sync + 'static {
+    fn fields(&self) -> &StarknetBuilderFields;
+}
+
+impl HasStarknetBuilderFields for StarknetBuilderFields {
+    fn fields(&self) -> &StarknetBuilderFields {
+        self
+    }
+}
+
+pub struct StarknetBuildComponents;
+
+impl HasComponents for StarknetBuilder {
+    type Components = StarknetBuildComponents;
+}
+
+delegate_components! {
+    StarknetBuildComponents {
+        ErrorTypeComponent: ProvideHermesError,
+        ErrorRaiserComponent: UseDelegate<HandleStarknetChainError>,
+        ChainTypeAtComponent<Index<0>>: WithType<StarknetChain>,
+        ChainTypeAtComponent<Index<1>>: WithType<CosmosChain>,
+        RuntimeTypeComponent: WithType<HermesRuntime>,
+        RuntimeGetterComponent: WithField<symbol!("runtime")>,
+    }
+}
+
+impl ChainBuilder<StarknetBuilder, Index<0>> for StarknetBuildComponents {
+    async fn build_chain(
+        build: &StarknetBuilder,
+        _index: PhantomData<Index<0>>,
+        _chain_id: &Felt,
+    ) -> Result<StarknetChain, HermesError> {
+        build.build_chain().await
+    }
+}
+
+impl ChainBuilder<StarknetBuilder, Index<1>> for StarknetBuildComponents {
+    async fn build_chain(
+        build: &StarknetBuilder,
+        _index: PhantomData<Index<1>>,
+        chain_id: &ChainId,
+    ) -> Result<CosmosChain, Error> {
+        build.cosmos_builder.build_chain(chain_id).await
+    }
+}
+
+impl StarknetBuilder {
+    pub fn new(
+        cosmos_builder: CosmosBuilder,
+        runtime: HermesRuntime,
+        starknet_chain_config: StarknetChainConfig,
+    ) -> Self {
+        Self {
+            fields: Arc::new(StarknetBuilderFields {
+                cosmos_builder,
+                runtime,
+                starknet_chain_config,
+            }),
+        }
+    }
+
+    pub async fn build_chain(&self) -> Result<StarknetChain, HermesError> {
+        self.build_chain_with_config().await
+    }
+
+    pub async fn build_chain_with_config(&self) -> Result<StarknetChain, HermesError> {
+        let json_rpc_url = Url::parse(&self.starknet_chain_config.json_rpc_url)?;
+
+        let rpc_client = Arc::new(JsonRpcClient::new(HttpTransport::new(json_rpc_url)));
+
+        let chain_id = rpc_client.chain_id().await?;
+
+        let account = SingleOwnerAccount::new(
+            rpc_client.clone(),
+            LocalWallet::from_signing_key(SigningKey::from_secret_scalar(
+                self.starknet_chain_config.relayer_wallet.signing_key,
+            )),
+            self.starknet_chain_config.relayer_wallet.account_address,
+            chain_id,
+            ExecutionEncoding::New,
+        );
+
+        let context = StarknetChain {
+            runtime: self.runtime.clone(),
+            chain_id,
+            rpc_client,
+            account,
+            ibc_client_contract_address: None,
+            ibc_core_contract_address: None,
+        };
+
+        Ok(context)
+    }
+}
+
+pub trait CanUseStarknetBuilder: CanBuildChain<Index<0>> + CanBuildChain<Index<1>> {}
+
+impl CanUseStarknetBuilder for StarknetBuilder {}

relayer/crates/starknet-relayer/src/contexts/mod.rs

@@ -1,2 +1,3 @@
+pub mod builder;
 pub mod cosmos_to_starknet_relay;
 pub mod starknet_to_cosmos_relay;

relayer/crates/starknet-test-components/src/impls/bootstrap/bootstrap_chain.rs

@@ -12,14 +12,14 @@ use hermes_runtime_components::traits::os::child_process::HasChildProcessType;
 use hermes_runtime_components::traits::os::reserve_port::CanReserveTcpPort;
 use hermes_runtime_components::traits::random::CanGenerateRandom;
 use hermes_runtime_components::traits::runtime::HasRuntime;
+use hermes_starknet_chain_components::types::wallet::StarknetWallet;
 use hermes_test_components::bootstrap::traits::chain::ChainBootstrapper;
 use hermes_test_components::chain::traits::types::wallet::HasWalletType;
 use hermes_test_components::chain_driver::traits::types::chain::HasChainType;
 use starknet::macros::felt;
 
 use crate::types::genesis_config::StarknetGenesisConfig;
 use crate::types::node_config::StarknetNodeConfig;
-use crate::types::wallet::StarknetWallet;
 
 pub struct BootstrapStarknetDevnet;
 

relayer/crates/starknet-test-components/src/impls/types/wallet.rs

@@ -1,9 +1,8 @@
+use hermes_starknet_chain_components::types::wallet::StarknetWallet;
 use hermes_test_components::chain::traits::types::address::HasAddressType;
 use hermes_test_components::chain::traits::types::wallet::ProvideWalletType;
 use starknet::core::types::Felt;
 
-use crate::types::wallet::StarknetWallet;
-
 pub struct ProvideStarknetWalletType;
 
 impl<Bootstrap> ProvideWalletType<Bootstrap> for ProvideStarknetWalletType

relayer/crates/starknet-test-components/src/types/mod.rs

@@ -1,3 +1,2 @@
 pub mod genesis_config;
 pub mod node_config;
-pub mod wallet;