chore(kms-connector): remove gw conn from kms-worker

Author: eudelins-zama

kms-connector/config/kms-worker.toml

@@ -15,10 +15,6 @@ chain_id = 54321
 # Ex: KMS_CONNECTOR_KMS_CORE_ENDPOINTS="http://[::1]:50051,http://[::1]:50052"
 kms_core_endpoints = ["http://[::1]:50051"]
 
-# Gateway WebSocket RPC URL endpoint (required)
-# ENV: KMS_CONNECTOR_GATEWAY_URL
-gateway_url = "ws://gateway-node:8546"
-
 # URL of the KMS Connector internal database (required)
 # Format: see https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING-URIS
 # ENV: KMS_CONNECTOR_DATABASE_URL
@@ -37,19 +33,6 @@ address = "0xF0bFB159C7381F7CB332586004d8247252C5b816"
 # ENV: KMS_CONNECTOR_DECRYPTION_DOMAIN_VERSION
 # domain_version = "1"
 
-# Configuration of the GatewayConfig contract (required)
-[gateway_config_contract]
-# Address of the GatewayConfig contract (required)
-# Format: hex string with 0x prefix
-# ENV: KMS_CONNECTOR_GATEWAY_CONFIG_CONTRACT__ADDRESS
-address = "0x5ffdaAB0373E62E2ea2944776209aEf29E631A64"
-# EIP-712 domain name for GatewayConfig contract (optional, defaults to "GatewayConfig")
-# ENV: KMS_CONNECTOR_GATEWAY_CONFIG_CONTRACT__DOMAIN_NAME
-# domain_name = "GatewayConfig"
-# EIP-712 domain version for GatewayConfig contract (optional, defaults to "1")
-# ENV: KMS_CONNECTOR_GATEWAY_CONFIG_CONTRACT__DOMAIN_VERSION
-# domain_version = "1"
-
 # The endpoint used to monitor the connector components (optional, defaults to "0.0.0.0:9100")
 # ENV: KMS_CONNECTOR_MONITORING_ENDPOINT
 # monitoring_endpoint = "0.0.0.0:9100"

kms-connector/crates/kms-worker/src/core/config/parsed.rs

@@ -27,8 +27,6 @@ pub struct Config {
     pub chain_id: u64,
     /// The `Decryption` contract configuration.
     pub decryption_contract: ContractConfig,
-    /// The `GatewayConfig` contract configuration.
-    pub gateway_config_contract: ContractConfig,
     /// The service name used for tracing.
     pub service_name: String,
 
@@ -84,8 +82,6 @@ impl Config {
             .map_err(|e| Error::InvalidConfig(e.to_string()))?;
         let decryption_contract =
             ContractConfig::parse("Decryption", raw_config.decryption_contract)?;
-        let gateway_config_contract =
-            ContractConfig::parse("GatewayConfig", raw_config.gateway_config_contract)?;
 
         // Validate critical configuration parts
         if raw_config.gateway_url.is_empty() {
@@ -121,7 +117,6 @@ impl Config {
             kms_core_endpoints,
             chain_id: raw_config.chain_id,
             decryption_contract,
-            gateway_config_contract,
             service_name: raw_config.service_name,
             events_batch_size: raw_config.events_batch_size,
             grpc_request_retries: raw_config.grpc_request_retries,
@@ -161,7 +156,6 @@ mod tests {
             env::remove_var("KMS_CONNECTOR_KMS_CORE_ENDPOINTS");
             env::remove_var("KMS_CONNECTOR_CHAIN_ID");
             env::remove_var("KMS_CONNECTOR_DECRYPTION_CONTRACT__ADDRESS");
-            env::remove_var("KMS_CONNECTOR_GATEWAY_CONFIG_CONTRACT__ADDRESS");
             env::remove_var("KMS_CONNECTOR_SERVICE_NAME");
             env::remove_var("KMS_CONNECTOR_S3_CONFIG__REGION");
             env::remove_var("KMS_CONNECTOR_S3_CONFIG__BUCKET");
@@ -193,10 +187,6 @@ mod tests {
             Address::from_str(&raw_config.decryption_contract.address).unwrap(),
             config.decryption_contract.address,
         );
-        assert_eq!(
-            Address::from_str(&raw_config.gateway_config_contract.address).unwrap(),
-            config.gateway_config_contract.address,
-        );
         assert_eq!(raw_config.kms_core_endpoints, config.kms_core_endpoints);
         assert_eq!(raw_config.service_name, config.service_name);
         assert_eq!(
@@ -219,14 +209,6 @@ mod tests {
             raw_config.decryption_contract.domain_version.unwrap(),
             config.decryption_contract.domain_version,
         );
-        assert_eq!(
-            raw_config.gateway_config_contract.domain_name.unwrap(),
-            config.gateway_config_contract.domain_name,
-        );
-        assert_eq!(
-            raw_config.gateway_config_contract.domain_version.unwrap(),
-            config.gateway_config_contract.domain_version,
-        );
         assert_eq!(raw_config.s3_config, config.s3_config);
     }
 
@@ -251,10 +233,7 @@ mod tests {
                 "KMS_CONNECTOR_DECRYPTION_CONTRACT__ADDRESS",
                 "0x5fbdb2315678afecb367f032d93f642f64180aa3",
             );
-            env::set_var(
-                "KMS_CONNECTOR_GATEWAY_CONFIG_CONTRACT__ADDRESS",
-                "0x0000000000000000000000000000000000000001",
-            );
+
             env::set_var("KMS_CONNECTOR_SERVICE_NAME", "kms-connector-test");
             env::set_var("KMS_CONNECTOR_EVENTS_BATCH_SIZE", "15");
             env::set_var("KMS_CONNECTOR_GRPC_REQUEST_RETRIES", "5");
@@ -279,10 +258,6 @@ mod tests {
             config.decryption_contract.address,
             Address::from_str("0x5fbdb2315678afecb367f032d93f642f64180aa3").unwrap()
         );
-        assert_eq!(
-            config.gateway_config_contract.address,
-            Address::from_str("0x0000000000000000000000000000000000000001").unwrap()
-        );
         assert_eq!(config.service_name, "kms-connector-test");
         assert_eq!(config.events_batch_size, 15);
         assert_eq!(config.grpc_request_retries, 5);
@@ -337,10 +312,6 @@ mod tests {
                 address: "0x0000".to_string(),
                 ..Default::default()
             },
-            gateway_config_contract: RawContractConfig {
-                address: "0x000010".to_string(),
-                ..Default::default()
-            },
             ..Default::default()
         };
         assert!(matches!(

kms-connector/crates/kms-worker/src/core/config/raw.rs

@@ -36,7 +36,6 @@ pub struct RawConfig {
     pub kms_core_endpoint: Option<String>,
     pub chain_id: u64,
     pub decryption_contract: RawContractConfig,
-    pub gateway_config_contract: RawContractConfig,
     #[serde(default = "default_service_name")]
     pub service_name: String,
     #[serde(default = "default_events_batch_size")]
@@ -146,11 +145,6 @@ impl Default for RawConfig {
                 domain_name: Some("Decryption".to_string()),
                 domain_version: Some("1".to_string()),
             },
-            gateway_config_contract: RawContractConfig {
-                address: "0x0000000000000000000000000000000000000000".to_string(),
-                domain_name: Some("GatewayConfig".to_string()),
-                domain_version: Some("1".to_string()),
-            },
             service_name: "kms-connector".to_string(),
             events_batch_size: 10,
             grpc_request_retries: 3,

kms-connector/crates/kms-worker/src/core/kms_worker.rs

@@ -10,10 +10,7 @@ use crate::{
     },
     monitoring::health::{KmsHealthClient, State},
 };
-use connector_utils::{
-    conn::{GatewayProvider, connect_to_db, connect_to_gateway},
-    tasks::spawn_with_limit,
-};
+use connector_utils::{conn::connect_to_db, tasks::spawn_with_limit};
 use std::fmt::Display;
 use tokio_util::sync::CancellationToken;
 use tracing::{error, info, warn};
@@ -94,9 +91,8 @@ where
 
 impl KmsWorker<DbEventPicker, DbEventProcessor, DbKmsResponsePublisher> {
     /// Creates a new `KmsWorker` instance from a valid `Config`.
-    pub async fn from_config(config: Config) -> anyhow::Result<(Self, State<GatewayProvider>)> {
+    pub async fn from_config(config: Config) -> anyhow::Result<(Self, State)> {
         let db_pool = connect_to_db(&config.database_url, config.database_pool_size).await?;
-        let provider = connect_to_gateway(&config.gateway_url).await?;
         let kms_client = KmsClient::connect(&config).await?;
         let kms_health_client = KmsHealthClient::connect(&config.kms_core_endpoints).await?;
 
@@ -108,12 +104,7 @@ impl KmsWorker<DbEventPicker, DbEventProcessor, DbKmsResponsePublisher> {
             DbEventProcessor::new(kms_client.clone(), decryption_processor, db_pool.clone());
         let response_publisher = DbKmsResponsePublisher::new(db_pool.clone());
 
-        let state = State::new(
-            db_pool,
-            provider,
-            kms_health_client,
-            config.healthcheck_timeout,
-        );
+        let state = State::new(db_pool, kms_health_client, config.healthcheck_timeout);
         let kms_worker = KmsWorker::new(event_picker, event_processor, response_publisher);
         Ok((kms_worker, state))
     }

kms-connector/crates/kms-worker/src/monitoring/health.rs

@@ -1,6 +1,5 @@
 use actix_web::http::StatusCode;
-use alloy::providers::Provider;
-use connector_utils::monitoring::health::{Healthcheck, database_healthcheck, gateway_healthcheck};
+use connector_utils::monitoring::health::{Healthcheck, database_healthcheck};
 use serde::{Deserialize, Serialize};
 use sqlx::{Pool, Postgres};
 use std::time::Duration;
@@ -13,36 +12,31 @@ use tonic_health::pb::{HealthCheckRequest, HealthCheckResponse, health_client::H
 
 #[derive(Clone)]
 /// The struct used to monitor the state of the `KmsWorker`.
-pub struct State<P> {
+pub struct State {
     db_pool: Pool<Postgres>,
-    provider: P,
     kms_health_client: KmsHealthClient,
     healthcheck_timeout: Duration,
 }
 
-impl<P: Provider> State<P> {
+impl State {
     pub fn new(
         db_pool: Pool<Postgres>,
-        provider: P,
         kms_health_client: KmsHealthClient,
         healthcheck_timeout: Duration,
     ) -> Self {
         Self {
             db_pool,
-            provider,
             kms_health_client,
             healthcheck_timeout,
         }
     }
 }
 
-impl<P: Provider> Healthcheck for State<P> {
+impl Healthcheck for State {
     async fn healthcheck(&self) -> actix_web::HttpResponse {
         let mut errors = vec![];
         let database_connected =
             database_healthcheck(&self.db_pool, self.healthcheck_timeout, &mut errors).await;
-        let gateway_connected =
-            gateway_healthcheck(&self.provider, self.healthcheck_timeout, &mut errors).await;
 
         let mut kms_core_connected = true;
         let kms_healtcheck_results = self.kms_health_client.check(self.healthcheck_timeout).await;
@@ -69,7 +63,6 @@ impl<P: Provider> Healthcheck for State<P> {
         let status = HealthStatus {
             healthy,
             database_connected,
-            gateway_connected,
             kms_core_connected,
             details: errors.join("; "),
         };
@@ -89,8 +82,6 @@ pub struct HealthStatus {
     pub healthy: bool,
     /// Database connection status.
     pub database_connected: bool,
-    /// Gateway provider connection status.
-    pub gateway_connected: bool,
     /// KMS Core connections status.
     pub kms_core_connected: bool,
     /// Details about any issues encountered during healthcheck.

kms-connector/crates/kms-worker/tests/health.rs

@@ -1,7 +1,4 @@
-use alloy::{
-    providers::RootProvider,
-    transports::http::reqwest::{self, StatusCode, Url},
-};
+use alloy::transports::http::reqwest::{self, StatusCode, Url};
 use connector_utils::{
     monitoring::{
         health::{Healthcheck, query_healthcheck_endpoint},
@@ -23,7 +20,6 @@ async fn test_healthcheck_endpoints() -> anyhow::Result<()> {
         KmsHealthClient::connect(&[test_instance.kms_url().to_string()]).await?;
     let state = State::new(
         test_instance.db().clone(),
-        test_instance.provider().clone(),
         kms_health_client,
         Duration::from_secs(5),
     );
@@ -61,7 +57,7 @@ async fn test_healthcheck_endpoints() -> anyhow::Result<()> {
     assert_eq!(
         response.json::<VersionResponse>().await?,
         VersionResponse {
-            name: State::<RootProvider>::service_name().to_string(),
+            name: State::service_name().to_string(),
             version: env!("CARGO_PKG_VERSION").to_string(),
             build: GIT_COMMIT_HASH.to_string(),
         }