refactor: remove usage of static config references

Signed-off-by: Gustavo Inacio <[email protected]>

Author: gusinacio

crates/config/src/config.rs

@@ -30,7 +30,7 @@ use crate::NonZeroGRT;
 
 const SHARED_PREFIX: &str = "INDEXER_";
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct Config {
     pub indexer: IndexerConfig,
@@ -229,14 +229,14 @@ impl Config {
     }
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct IndexerConfig {
     pub indexer_address: Address,
     pub operator_mnemonic: Mnemonic,
 }
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Debug, Deserialize, Clone)]
 #[cfg_attr(test, derive(PartialEq))]
 #[serde(untagged)]
 #[serde(deny_unknown_fields)]
@@ -278,14 +278,14 @@ impl DatabaseConfig {
     }
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct GraphNodeConfig {
     pub query_url: Url,
     pub status_url: Url,
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct MetricsConfig {
     pub port: u16,
@@ -297,15 +297,15 @@ impl MetricsConfig {
     }
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct SubgraphsConfig {
     pub network: NetworkSubgraphConfig,
     pub escrow: EscrowSubgraphConfig,
 }
 
 #[serde_as]
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct NetworkSubgraphConfig {
     #[serde(flatten)]
@@ -315,15 +315,15 @@ pub struct NetworkSubgraphConfig {
     pub recently_closed_allocation_buffer_secs: Duration,
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct EscrowSubgraphConfig {
     #[serde(flatten)]
     pub config: SubgraphConfig,
 }
 
 #[serde_as]
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct SubgraphConfig {
     pub query_url: Url,
@@ -346,14 +346,14 @@ pub enum TheGraphChainId {
     Test = 1337,
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct BlockchainConfig {
     pub chain_id: TheGraphChainId,
     pub receipts_verifier_address: Address,
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct ServiceConfig {
     pub serve_network_subgraph: bool,
@@ -366,14 +366,14 @@ pub struct ServiceConfig {
 }
 
 #[serde_as]
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct ServiceTapConfig {
     /// what's the maximum value we accept in a receipt
     pub max_receipt_value_grt: NonZeroGRT,
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct TapConfig {
     /// what is the maximum amount the indexer is willing to lose in grt
@@ -383,7 +383,7 @@ pub struct TapConfig {
     pub sender_aggregator_endpoints: HashMap<Address, Url>,
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct DipsConfig {
     pub allowed_payers: Vec<Address>,
@@ -402,7 +402,7 @@ impl TapConfig {
 }
 
 #[serde_as]
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 #[cfg_attr(test, derive(PartialEq))]
 pub struct RavRequestConfig {
     /// what divisor of the amount willing to lose to trigger the rav request

crates/service/src/service.rs

@@ -27,8 +27,8 @@ pub use tap_receipt_header::TapReceipt;
 #[derive(Clone)]
 pub struct GraphNodeState {
     pub graph_node_client: reqwest::Client,
-    pub graph_node_status_url: &'static Url,
-    pub graph_node_query_base_url: &'static Url,
+    pub graph_node_status_url: Url,
+    pub graph_node_query_base_url: Url,
 }
 
 const HTTP_CLIENT_TIMEOUT: Duration = Duration::from_secs(30);
@@ -39,17 +39,16 @@ pub async fn run() -> anyhow::Result<()> {
     let cli = Cli::parse();
 
     // Load the service configuration
-    let config = Box::leak(Box::new(
-        Config::parse(indexer_config::ConfigPrefix::Service, cli.config.as_ref()).map_err(|e| {
+    let config = Config::parse(indexer_config::ConfigPrefix::Service, cli.config.as_ref())
+        .map_err(|e| {
             error!(
                 "Invalid configuration file `{}`: {}, if a value is missing you can also use \
                 --config to fill the rest of the values",
                 cli.config.unwrap_or_default().display(),
                 e
             );
             anyhow!(e)
-        })?,
-    ));
+        })?;
 
     // Parse basic configurations
     build_info::build_info!(fn build_info);
@@ -90,28 +89,30 @@ pub async fn run() -> anyhow::Result<()> {
         config.blockchain.receipts_verifier_address,
     );
 
+    let host_and_port = config.service.host_and_port;
+
     let router = ServiceRouter::builder()
         .database(database)
         .domain_separator(domain_separator)
-        .graph_node(&config.graph_node)
+        .graph_node(config.graph_node)
         .http_client(http_client)
         .release(release)
-        .indexer(&config.indexer)
-        .service(&config.service)
-        .dips(config.dips.as_ref())
-        .blockchain(&config.blockchain)
+        .indexer(config.indexer)
+        .service(config.service)
+        .dips(config.dips)
+        .blockchain(config.blockchain)
         .timestamp_buffer_secs(config.tap.rav_request.timestamp_buffer_secs)
-        .network_subgraph(network_subgraph, &config.subgraphs.network)
-        .escrow_subgraph(escrow_subgraph, &config.subgraphs.escrow)
+        .network_subgraph(network_subgraph, config.subgraphs.network)
+        .escrow_subgraph(escrow_subgraph, config.subgraphs.escrow)
         .build();
 
     serve_metrics(config.metrics.get_socket_addr());
 
     info!(
-        address = %config.service.host_and_port,
+        address = %host_and_port,
         "Serving requests",
     );
-    let listener = TcpListener::bind(&config.service.host_and_port)
+    let listener = TcpListener::bind(&host_and_port)
         .await
         .expect("Failed to bind to indexer-service port");
 

crates/service/src/service/router.rs

@@ -71,29 +71,29 @@ pub struct ServiceRouter {
     release: Option<IndexerServiceRelease>,
 
     // configuration
-    graph_node: &'static GraphNodeConfig,
-    indexer: &'static IndexerConfig,
-    service: &'static ServiceConfig,
-    blockchain: &'static BlockchainConfig,
+    graph_node: GraphNodeConfig,
+    indexer: IndexerConfig,
+    service: ServiceConfig,
+    blockchain: BlockchainConfig,
     timestamp_buffer_secs: Duration,
     #[builder(default)]
-    dips: Option<&'static DipsConfig>,
+    dips: Option<DipsConfig>,
 
     // either provide subgraph or watcher
     #[builder(default, setter(transform =
         |subgraph: &'static SubgraphClient,
-            config: &'static EscrowSubgraphConfig|
+            config: EscrowSubgraphConfig|
         Some((subgraph, config))))]
-    escrow_subgraph: Option<(&'static SubgraphClient, &'static EscrowSubgraphConfig)>,
+    escrow_subgraph: Option<(&'static SubgraphClient, EscrowSubgraphConfig)>,
     #[builder(default, setter(strip_option))]
     escrow_accounts: Option<EscrowAccountsWatcher>,
 
     // provide network subgraph or allocations + dispute manager
     #[builder(default, setter(transform =
         |subgraph: &'static SubgraphClient,
-            config: &'static NetworkSubgraphConfig|
+            config: NetworkSubgraphConfig|
         Some((subgraph, config))))]
-    network_subgraph: Option<(&'static SubgraphClient, &'static NetworkSubgraphConfig)>,
+    network_subgraph: Option<(&'static SubgraphClient, NetworkSubgraphConfig)>,
     #[builder(default, setter(strip_option))]
     allocations: Option<AllocationWatcher>,
     #[builder(default, setter(strip_option))]
@@ -142,9 +142,9 @@ impl ServiceRouter {
         let dips = match self.dips.as_ref() {
             Some(dips_config) => {
                 let schema = dips::build_schema(
-                    *indexer_address,
+                    indexer_address,
                     dips_config,
-                    self.blockchain,
+                    &self.blockchain,
                     agreement_store,
                     prices,
                 );
@@ -159,7 +159,7 @@ impl ServiceRouter {
             (Some(allocations), _) => allocations,
             (_, Some((network_subgraph, network))) => indexer_allocations(
                 network_subgraph,
-                *indexer_address,
+                indexer_address,
                 network.config.syncing_interval_secs,
                 network.recently_closed_allocation_buffer_secs,
             )
@@ -174,7 +174,7 @@ impl ServiceRouter {
             (Some(escrow_account), _) => escrow_account,
             (_, Some((escrow_subgraph, escrow))) => escrow_accounts(
                 escrow_subgraph,
-                *indexer_address,
+                indexer_address,
                 escrow.config.syncing_interval_secs,
                 true, // Reject thawing signers eagerly
             )
@@ -385,21 +385,21 @@ impl ServiceRouter {
         };
 
         let operator_address =
-            Json(serde_json::json!({ "publicKey": public_key(operator_mnemonic)?}));
+            Json(serde_json::json!({ "publicKey": public_key(&operator_mnemonic)?}));
 
         // Graphnode state
         let graphnode_state = GraphNodeState {
             graph_node_client: self.http_client,
-            graph_node_status_url: &self.graph_node.status_url,
-            graph_node_query_base_url: &self.graph_node.query_url,
+            graph_node_status_url: self.graph_node.status_url,
+            graph_node_query_base_url: self.graph_node.query_url,
         };
 
         // data layer
         let data_routes = Router::new()
             .route("/subgraphs/id/:id", post_request_handler)
             .with_state(graphnode_state.clone());
 
-        let subgraphs_route = Router::new().nest(url_prefix, data_routes);
+        let subgraphs_route = Router::new().nest(&url_prefix, data_routes);
 
         let misc_routes = Router::new()
             .route("/", get("Service is up and running"))

crates/service/tests/router_test.rs

@@ -66,15 +66,15 @@ async fn full_integration_test(database: PgPool) {
         .database(database)
         .domain_separator(TAP_EIP712_DOMAIN.clone())
         .http_client(http_client)
-        .graph_node(leak(GraphNodeConfig {
+        .graph_node(GraphNodeConfig {
             query_url: graph_node_url.clone(),
             status_url: graph_node_url.clone(),
-        }))
-        .indexer(leak(IndexerConfig {
+        })
+        .indexer(IndexerConfig {
             indexer_address: *test_assets::INDEXER_ADDRESS,
             operator_mnemonic: test_assets::INDEXER_MNEMONIC.clone(),
-        }))
-        .service(leak(indexer_config::ServiceConfig {
+        })
+        .service(indexer_config::ServiceConfig {
             serve_network_subgraph: false,
             serve_escrow_subgraph: false,
             serve_auth_token: None,
@@ -84,11 +84,11 @@ async fn full_integration_test(database: PgPool) {
                 max_receipt_value_grt: NonZeroGRT::new(1000000000000).unwrap(),
             },
             free_query_auth_token: None,
-        }))
-        .blockchain(leak(BlockchainConfig {
+        })
+        .blockchain(BlockchainConfig {
             chain_id: indexer_config::TheGraphChainId::Test,
             receipts_verifier_address: *test_assets::VERIFIER_ADDRESS,
-        }))
+        })
         .timestamp_buffer_secs(Duration::from_secs(10))
         .escrow_accounts(escrow_accounts)
         .dispute_manager(dispute_manager)
@@ -127,7 +127,3 @@ async fn full_integration_test(database: PgPool) {
 
     insta::assert_snapshot!(res);
 }
-
-fn leak<T>(thing: T) -> &'static T {
-    Box::leak(Box::new(thing))
-}