Adapt context to main

Author: maxgttph

Cargo.lock

@@ -7,10 +7,11 @@ members = ["contracts", "contracts/wallet", "server"]
 # client-sdk = { default-features = false, package = "hyle-client-sdk", version = "0.13.0-rc.4" }
 # hyle = { version = "0.13.0-rc.4" }
 
-sdk = { git = "https://github.com/Hyle-org/hyle.git", package = "hyle-contract-sdk", branch = "secp256k1blob" }
-client-sdk = { git = "https://github.com/Hyle-org/hyle.git", default-features = false, package = "hyle-client-sdk", branch = "secp256k1blob" }
-hyle-hyllar = { git = "https://github.com/Hyle-org/hyle", package = "hyle-hyllar", branch = "secp256k1blob" }
-hyle-modules = { git = "https://github.com/Hyle-org/hyle.git", package = "hyle-modules", branch = "secp256k1blob" }
+sdk = { git = "https://github.com/Hyle-org/hyle.git", package = "hyle-contract-sdk", branch = "main" }
+client-sdk = { git = "https://github.com/Hyle-org/hyle.git", default-features = false, package = "hyle-client-sdk", branch = "main" }
+hyle-hyllar = { git = "https://github.com/Hyle-org/hyle", package = "hyle-hyllar", branch = "main" }
+hyle-modules = { git = "https://github.com/Hyle-org/hyle.git", package = "hyle-modules", branch = "main" }
+
 
 contracts = { path = "contracts", default-features = false, package = "contracts" }
 wallet = { path = "contracts/wallet", package = "wallet" }

Cargo.toml

@@ -10,10 +10,11 @@ use axum::{
 };
 use client_sdk::rest_client::NodeApiHttpClient;
 use hyle_modules::{
-    bus::BusClientSender,
+    bus::{BusClientSender, SharedMessageBus},
     module_bus_client, module_handle_messages,
     modules::{
-        contract_state_indexer::CSIBusEvent, websocket::WsTopicMessage, CommonRunContext, Module,
+        contract_state_indexer::CSIBusEvent, websocket::WsTopicMessage, BuildApiContextInner,
+        Module,
     },
 };
 
@@ -29,9 +30,9 @@ pub struct AppModule {
 }
 
 pub struct AppModuleCtx {
-    pub common: Arc<CommonRunContext>,
     pub node_client: Arc<NodeApiHttpClient>,
     pub wallet_cn: ContractName,
+    pub api: Arc<BuildApiContextInner>,
 }
 
 /// Messages received from WebSocket clients that will be processed by the system
@@ -57,7 +58,7 @@ pub struct AppModuleBusClient {
 impl Module for AppModule {
     type Context = Arc<AppModuleCtx>;
 
-    async fn build(ctx: Self::Context) -> Result<Self> {
+    async fn build(bus: SharedMessageBus, ctx: Self::Context) -> Result<Self> {
         let state = RouterCtx {
             wallet_cn: ctx.wallet_cn.clone(),
         };
@@ -74,12 +75,12 @@ impl Module for AppModule {
             .with_state(state)
             .layer(cors); // Apply the CORS middleware
 
-        if let Ok(mut guard) = ctx.common.router.lock() {
+        if let Ok(mut guard) = ctx.api.router.lock() {
             if let Some(router) = guard.take() {
                 guard.replace(router.merge(api));
             }
         }
-        let bus = AppModuleBusClient::new_from_bus(ctx.common.bus.new_handle()).await;
+        let bus = AppModuleBusClient::new_from_bus(bus.new_handle()).await;
 
         Ok(AppModule { bus })
     }

server/src/app.rs

@@ -11,21 +11,18 @@ use hyle_modules::{
     bus::{metrics::BusMetrics, SharedMessageBus},
     modules::{
         contract_state_indexer::{ContractStateIndexer, ContractStateIndexerCtx},
-        da_listener::{DAListener, DAListenerCtx},
+        da_listener::{DAListener, DAListenerConf},
         prover::{AutoProver, AutoProverCtx},
         rest::{RestApi, RestApiRunContext},
-        websocket::{WebSocketModule, WebSocketModuleCtx},
-        CommonRunContext, ModulesHandler,
+        websocket::WebSocketModule,
+        BuildApiContextInner, ModulesHandler,
     },
     utils::{conf, logger::setup_tracing},
 };
 
 use prometheus::Registry;
 use sdk::{api::NodeInfo, info, ContractName, ZkContract};
-use std::{
-    env,
-    sync::{Arc, Mutex},
-};
+use std::{env, sync::Arc};
 use tracing::error;
 use wallet::{client::indexer::WalletEvent, Wallet};
 
@@ -92,17 +89,15 @@ async fn main() -> Result<()> {
 
     let mut handler = ModulesHandler::new(&bus).await;
 
-    let ctx = Arc::new(CommonRunContext {
-        bus: bus.new_handle(),
-        config: config.clone(),
-        router: Mutex::new(Some(Router::new())),
-        openapi: Default::default(),
+    let build_api_ctx = Arc::new(BuildApiContextInner {
+        router: std::sync::Mutex::new(Some(Router::new())),
+        openapi: std::sync::Mutex::new(Default::default()),
     });
 
     let app_ctx = Arc::new(AppModuleCtx {
-        common: ctx.clone(),
         node_client,
         wallet_cn: contract_name.clone(),
+        api: build_api_ctx.clone(),
     });
     let start_height = app_ctx.node_client.get_block_height().await?;
 
@@ -111,22 +106,23 @@ async fn main() -> Result<()> {
     handler
         .build_module::<ContractStateIndexer<Wallet, WalletEvent>>(ContractStateIndexerCtx {
             contract_name: contract_name.clone(),
-            common: ctx.clone(),
+            data_directory: config.data_directory.clone(),
+            api: build_api_ctx.clone(),
         })
         .await?;
     handler
         .build_module::<ContractStateIndexer<HyllarHistory, Vec<HistoryEvent>>>(
             ContractStateIndexerCtx {
                 contract_name: "hyllar".into(),
-                common: ctx.clone(),
+                data_directory: config.data_directory.clone(),
+                api: build_api_ctx.clone(),
             },
         )
         .await?;
 
     handler
         .build_module::<AutoProver<Wallet>>(Arc::new(AutoProverCtx {
             start_height,
-            bus: ctx.bus.new_handle(),
             data_directory: config.data_directory.clone(),
             prover: Arc::new(Risc0Prover::new(contracts::WALLET_ELF)),
             contract_name: contract_name.clone(),
@@ -136,7 +132,6 @@ async fn main() -> Result<()> {
     handler
         .build_module::<AutoProver<hyle_hyllar::Hyllar>>(Arc::new(AutoProverCtx {
             start_height,
-            bus: ctx.bus.new_handle(),
             data_directory: config.data_directory.clone(),
             prover: Arc::new(Risc0Prover::new(
                 hyle_hyllar::client::tx_executor_handler::metadata::HYLLAR_ELF,
@@ -147,40 +142,45 @@ async fn main() -> Result<()> {
         .await?;
 
     handler
-        .build_module::<WebSocketModule<AppWsInMessage, AppOutWsEvent>>(WebSocketModuleCtx {
-            bus: ctx.bus.new_handle(),
-            config: config.websocket.clone().into(),
-        })
+        .build_module::<WebSocketModule<AppWsInMessage, AppOutWsEvent>>(
+            config.websocket.clone().into(),
+        )
         .await?;
 
     // This module connects to the da_address and receives all the blocks²
     handler
-        .build_module::<DAListener>(DAListenerCtx {
-            common: ctx.clone(),
+        .build_module::<DAListener>(DAListenerConf {
+            data_directory: config.data_directory.clone(),
+            da_read_from: config.da_read_from.clone(),
             start_block: None,
         })
         .await?;
 
     // Should come last so the other modules have nested their own routes.
     #[allow(clippy::expect_used, reason = "Fail on misconfiguration")]
-    let router = ctx
+    let router = build_api_ctx
         .router
         .lock()
-        .expect("Context router should be available")
+        .expect("Context router should be available.")
         .take()
-        .expect("Context router should be available");
+        .expect("Context router should be available.");
+    #[allow(clippy::expect_used, reason = "Fail on misconfiguration")]
+    let openapi = build_api_ctx
+        .openapi
+        .lock()
+        .expect("OpenAPI should be available")
+        .clone();
 
     handler
         .build_module::<RestApi>(RestApiRunContext {
-            port: ctx.config.rest_server_port,
-            max_body_size: ctx.config.rest_server_max_body_size,
-            bus: ctx.bus.new_handle(),
+            port: config.rest_server_port,
+            max_body_size: config.rest_server_max_body_size,
             registry: Registry::new(),
-            router: router.clone(),
-            openapi: Default::default(),
+            router,
+            openapi,
             info: NodeInfo {
-                id: ctx.config.id.clone(),
-                da_address: ctx.config.da_read_from.clone(),
+                id: config.id.clone(),
+                da_address: config.da_read_from.clone(),
                 pubkey: None,
             },
         })