feat(chain-listener): initial refactoring + tests

.github/workflows/e2e.yml

@@ -82,9 +82,10 @@ jobs:
   cli:
     needs:
       - nox-snapshot
-    uses: fluencelabs/cli/.github/workflows/tests.yml@main
+    uses: fluencelabs/cli/.github/workflows/tests.yml@timeout
     with:
       nox-image: "${{ needs.nox-snapshot.outputs.nox-image }}"
+      ref: "timeout"
 
   js-client:
     needs:

Cargo.toml

@@ -174,9 +174,9 @@ enum_dispatch = "0.3.12"
 serde_with = "3.7.0"
 mockito = "1.2.0"
 clarity = "1.3.0"
-cpu-utils = "0.8.0"
-ccp-shared = "0.8.0"
-ccp-rpc-client = "0.8.0"
+cpu-utils = "0.9.0"
+ccp-shared = "0.9.0"
+ccp-rpc-client = "0.9.0"
 alloy-sol-types = "0.6.4"
 alloy-primitives = "0.6.4"
 alloy_serde_macro = "0.1.2"

aquamarine/src/log.rs

@@ -12,7 +12,16 @@ fn truncate(s: &str) -> &str {
 pub fn builtin_log_fn(service: &str, args: &str, elapsed: FormattedDuration, particle_id: String) {
     let args = truncate(args);
     match service {
-        "array" | "cmp" | "debug" | "math" | "op" | "getDataSrv" | "run-console" | "json" => {
+        "run-console" => {
+            tracing::event!(
+                tracing::Level::INFO,
+                "Executed host call {} ({}) [{}]",
+                args,
+                elapsed,
+                particle_id
+            )
+        }
+        "array" | "cmp" | "debug" | "math" | "op" | "getDataSrv" | "json" => {
             tracing::event!(
                 tracing::Level::TRACE,
                 "Executed host call {} ({}) [{}]",

crates/chain-connector/Cargo.toml

@@ -15,7 +15,6 @@ eyre = { workspace = true }
 fluence-libp2p = { workspace = true }
 serde_json = { workspace = true }
 hex = { workspace = true }
-server-config = { workspace = true }
 clarity = { workspace = true }
 tokio = { workspace = true, features = ["rt", "macros"] }
 hex-utils = { workspace = true }

crates/chain-connector/src/connector.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 
 use ccp_shared::proof::CCProof;
 use ccp_shared::types::{Difficulty, GlobalNonce, CUID};
-use clarity::{Transaction, Uint256};
+use clarity::{PrivateKey, Transaction, Uint256};
 use eyre::eyre;
 use futures::FutureExt;
 use jsonrpsee::core::async_trait;
@@ -29,7 +29,6 @@ use hex_utils::decode_hex;
 use particle_args::{Args, JError};
 use particle_builtins::{wrap, CustomService};
 use particle_execution::{ParticleParams, ServiceFunction};
-use server_config::ChainConfig;
 use types::DealId;
 
 use crate::error::{process_response, ConnectorError};
@@ -72,9 +71,47 @@ pub trait ChainConnector: Send + Sync {
     ) -> Result<Vec<Result<Value, ConnectorError>>, ConnectorError>;
 }
 
+#[derive(Clone)]
+pub struct HttpChainConnectorConfig {
+    pub http_endpoint: String,
+    pub core_contract_address: String,
+    pub cc_contract_address: String,
+    pub market_contract_address: String,
+    pub network_id: u64,
+    pub wallet_key: PrivateKey,
+    /// If none, comes from the chain
+    pub default_base_fee: Option<u64>,
+    /// If none, comes from the chain
+    pub default_priority_fee: Option<u64>,
+}
+
+impl HttpChainConnectorConfig {
+    pub fn new(
+        http_endpoint: String,
+        core_contract_address: String,
+        cc_contract_address: String,
+        market_contract_address: String,
+        network_id: u64,
+        wallet_key: PrivateKey,
+        default_base_fee: Option<u64>,
+        default_priority_fee: Option<u64>,
+    ) -> Self {
+        Self {
+            http_endpoint,
+            core_contract_address,
+            cc_contract_address,
+            market_contract_address,
+            network_id,
+            wallet_key,
+            default_base_fee,
+            default_priority_fee,
+        }
+    }
+}
+
 pub struct HttpChainConnector {
     client: Arc<jsonrpsee::http_client::HttpClient>,
-    config: ChainConfig,
+    config: HttpChainConnectorConfig,
     tx_nonce_mutex: Arc<Mutex<()>>,
     host_id: PeerId,
 }
@@ -84,14 +121,14 @@ pub struct CCInitParams {
     pub init_timestamp: U256,
     pub global_nonce: GlobalNonce,
     pub current_epoch: U256,
-    pub epoch_duration: U256,
+    pub epoch_duration_sec: U256,
     pub min_proofs_per_epoch: U256,
     pub max_proofs_per_epoch: U256,
 }
 
 impl HttpChainConnector {
     pub fn new(
-        config: ChainConfig,
+        config: HttpChainConnectorConfig,
         host_id: PeerId,
     ) -> eyre::Result<(Arc<Self>, HashMap<String, CustomService>)> {
         tracing::info!(target: "chain-connector","Connecting to chain via {}", config.http_endpoint);
@@ -400,7 +437,7 @@ impl ChainConnector for HttpChainConnector {
             init_timestamp,
             global_nonce: GlobalNonce::new(global_nonce.0),
             current_epoch,
-            epoch_duration,
+            epoch_duration_sec: epoch_duration,
             min_proofs_per_epoch,
             max_proofs_per_epoch,
         })
@@ -594,12 +631,12 @@ mod tests {
 
     use crate::{
         is_commitment_not_active, CCStatus, ChainConnector, CommitmentId, ConnectorError,
-        HttpChainConnector,
+        HttpChainConnector, HttpChainConnectorConfig,
     };
 
     fn get_connector(url: &str) -> Arc<HttpChainConnector> {
         let (connector, _) = HttpChainConnector::new(
-            server_config::ChainConfig {
+            HttpChainConnectorConfig {
                 http_endpoint: url.to_string(),
                 cc_contract_address: "0x0E62f5cfA5189CA34E79CCB03829C064405790aD".to_string(),
                 core_contract_address: "0x2f5224b7Cb8bd98d9Ef61c247F4741758E8E873d".to_string(),
@@ -805,7 +842,7 @@ mod tests {
             U256::from(0x00000000000000000000000000000000000000000000000000000000000016be)
         );
         assert_eq!(
-            init_params.epoch_duration,
+            init_params.epoch_duration_sec,
             U256::from(0x000000000000000000000000000000000000000000000000000000000000000f)
         );
         assert_eq!(init_params.min_proofs_per_epoch, U256::from(5));

crates/chain-connector/src/lib.rs

@@ -8,5 +8,6 @@ mod function;
 pub use connector::CCInitParams;
 pub use connector::ChainConnector;
 pub use connector::HttpChainConnector;
+pub use connector::HttpChainConnectorConfig;
 pub use error::ConnectorError;
 pub use function::*;

crates/chain-listener/Cargo.toml

@@ -21,7 +21,6 @@ tracing = { workspace = true }
 eyre = { workspace = true }
 serde_json = { workspace = true }
 tokio = { workspace = true, features = ["rt"] }
-server-config = { workspace = true }
 types = { workspace = true }
 libipld = { workspace = true }
 
@@ -43,3 +42,8 @@ peer-metrics = { workspace = true }
 
 [dev-dependencies]
 jsonrpsee = { workspace = true, features = ["server"] }
+tempfile = { workspace = true }
+tokio-stream = { workspace = true }
+log-utils = { workspace = true }
+parking_lot = { workspace = true }
+mockall = "0.12.1"