Move rpc_url and wss_url into network-level configuration

Author: tompntn

src/agent/solana.rs

@@ -34,8 +34,13 @@ pub mod network {
     };
 
     /// Configuration for a network
-    #[derive(Clone, Serialize, Deserialize, Debug, Default)]
+    #[derive(Clone, Serialize, Deserialize, Debug)]
+    #[serde(default)]
     pub struct Config {
+        /// HTTP RPC endpoint
+        pub rpc_url:   String,
+        /// WSS RPC endpoint
+        pub wss_url:   String,
         /// Keystore
         pub key_store: key_store::Config,
         /// Configuration for the Oracle reading data from this network
@@ -44,6 +49,18 @@ pub mod network {
         pub exporter:  exporter::Config,
     }
 
+    impl Default for Config {
+        fn default() -> Self {
+            Self {
+                rpc_url:   "http://localhost:8899".to_string(),
+                wss_url:   "ws://localhost:8900".to_string(),
+                key_store: Default::default(),
+                oracle:    Default::default(),
+                exporter:  Default::default(),
+            }
+        }
+    }
+
     pub fn spawn_network(
         config: Config,
         local_store_tx: Sender<store::local::Message>,
@@ -53,6 +70,8 @@ pub mod network {
         // Spawn the Oracle
         let mut jhs = oracle::spawn_oracle(
             config.oracle.clone(),
+            &config.rpc_url,
+            &config.wss_url,
             KeyStore::new(config.key_store.clone())?,
             global_store_update_tx,
             logger.clone(),
@@ -61,6 +80,7 @@ pub mod network {
         // Spawn the Exporter
         let exporter_jhs = exporter::spawn_exporter(
             config.exporter,
+            &config.rpc_url,
             KeyStore::new(config.key_store.clone())?,
             local_store_tx,
             logger,

src/agent/solana/exporter.rs

@@ -86,8 +86,6 @@ struct UpdPriceCmd {
 #[derive(Clone, Serialize, Deserialize, Debug)]
 #[serde(default)]
 pub struct Config {
-    /// HTTP endpoint of the Solana RPC node
-    pub rpc_endpoint:                            String,
     /// Duration of the interval at which to refresh the cached network state (current slot and blockhash).
     /// It is recommended to set this to slightly less than the network's block time,
     /// as the slot fetched will be used as the time of the price update.
@@ -114,7 +112,6 @@ pub struct Config {
 impl Default for Config {
     fn default() -> Self {
         Self {
-            rpc_endpoint:                            "http://localhost:8899".to_string(),
             refresh_network_state_interval_duration: Duration::from_millis(200),
             publish_interval_duration:               Duration::from_secs(1),
             staleness_threshold:                     Duration::from_secs(5),
@@ -130,14 +127,15 @@ impl Default for Config {
 
 pub fn spawn_exporter(
     config: Config,
+    rpc_url: &str,
     key_store: KeyStore,
     local_store_tx: Sender<store::local::Message>,
     logger: Logger,
 ) -> Result<Vec<JoinHandle<()>>> {
     // Create and spawn the network state querier
     let (network_state_tx, network_state_rx) = watch::channel(Default::default());
     let mut network_state_querier = NetworkStateQuerier::new(
-        &config.rpc_endpoint,
+        &rpc_url,
         time::interval(config.refresh_network_state_interval_duration),
         network_state_tx,
         logger.clone(),
@@ -149,6 +147,7 @@ pub fn spawn_exporter(
         mpsc::channel(config.inflight_transactions_channel_capacity);
     let mut transaction_monitor = TransactionMonitor::new(
         config.transaction_monitor.clone(),
+        rpc_url,
         transactions_rx,
         logger.clone(),
     );
@@ -157,6 +156,7 @@ pub fn spawn_exporter(
     // Create and spawn the exporter
     let mut exporter = Exporter::new(
         config,
+        rpc_url,
         key_store,
         local_store_tx,
         network_state_rx,
@@ -203,6 +203,7 @@ pub struct Exporter {
 impl Exporter {
     pub fn new(
         config: Config,
+        rpc_url: &str,
         key_store: KeyStore,
         local_store_tx: Sender<store::local::Message>,
         network_state_rx: watch::Receiver<NetworkState>,
@@ -211,7 +212,7 @@ impl Exporter {
     ) -> Self {
         let publish_interval = time::interval(config.publish_interval_duration);
         Exporter {
-            rpc_client: RpcClient::new(config.rpc_endpoint.to_string()),
+            rpc_client: RpcClient::new(rpc_url.to_string()),
             config,
             publish_interval,
             key_store,
@@ -512,8 +513,6 @@ mod transaction_monitor {
     #[derive(Clone, Serialize, Deserialize, Debug)]
     #[serde(default)]
     pub struct Config {
-        /// HTTP endpoint of the Solana RPC node
-        pub rpc_endpoint:           String,
         /// Duration of the interval with which to poll the status of transactions.
         /// It is recommended to set this to a value close to the Exporter's publish_interval.
         #[serde(with = "humantime_serde")]
@@ -527,7 +526,6 @@ mod transaction_monitor {
     impl Default for Config {
         fn default() -> Self {
             Self {
-                rpc_endpoint:           "http://localhost:8899".to_string(),
                 poll_interval_duration: Duration::from_secs(4),
                 max_transactions:       100,
             }
@@ -557,11 +555,12 @@ mod transaction_monitor {
     impl TransactionMonitor {
         pub fn new(
             config: Config,
+            rpc_url: &str,
             transactions_rx: mpsc::Receiver<Signature>,
             logger: Logger,
         ) -> Self {
             let poll_interval = time::interval(config.poll_interval_duration);
-            let rpc_client = RpcClient::new(config.rpc_endpoint.to_string());
+            let rpc_client = RpcClient::new(rpc_url.to_string());
             TransactionMonitor {
                 config,
                 rpc_client,

src/agent/solana/oracle.rs

@@ -88,8 +88,6 @@ pub struct Oracle {
 pub struct Config {
     /// The commitment level to use when reading data from the RPC node.
     pub commitment:               CommitmentLevel,
-    /// RPC endpoint to send requests to.
-    pub rpc_url:                  String,
     /// The interval with which to poll account information.
     #[serde(with = "humantime_serde")]
     pub poll_interval_duration:   Duration,
@@ -105,7 +103,6 @@ impl Default for Config {
     fn default() -> Self {
         Self {
             commitment:               CommitmentLevel::Confirmed,
-            rpc_url:                  "http://localhost:8899".to_string(),
             poll_interval_duration:   Duration::from_secs(30),
             subscriber_enabled:       true,
             subscriber:               Default::default(),
@@ -116,6 +113,8 @@ impl Default for Config {
 
 pub fn spawn_oracle(
     config: Config,
+    rpc_url: &str,
+    wss_url: &str,
     key_store: KeyStore,
     global_store_update_tx: mpsc::Sender<global::Update>,
     logger: Logger,
@@ -127,6 +126,8 @@ pub fn spawn_oracle(
     if config.subscriber_enabled {
         let subscriber = Subscriber::new(
             config.subscriber.clone(),
+            rpc_url.to_string(),
+            wss_url.to_string(),
             key_store.program_key.clone(),
             updates_tx,
             logger.clone(),
@@ -137,6 +138,7 @@ pub fn spawn_oracle(
     // Create and spawn the Oracle
     let mut oracle = Oracle::new(
         config,
+        rpc_url,
         key_store,
         updates_rx,
         global_store_update_tx,
@@ -150,21 +152,21 @@ pub fn spawn_oracle(
 impl Oracle {
     pub fn new(
         config: Config,
+        rpc_url: &str,
         key_store: KeyStore,
         updates_rx: mpsc::Receiver<(Pubkey, solana_sdk::account::Account)>,
         global_store_tx: mpsc::Sender<global::Update>,
         logger: Logger,
     ) -> Self {
         let rpc_client = RpcClient::new_with_commitment(
-            config.rpc_url.clone(),
+            rpc_url.to_string(),
             CommitmentConfig {
                 commitment: config.commitment,
             },
         );
         let poll_interval = tokio::time::interval(config.poll_interval_duration);
 
         Oracle {
-            config,
             key_store,
             data: Default::default(),
             rpc_client,
@@ -473,18 +475,12 @@ mod subscriber {
     pub struct Config {
         /// Commitment level used to read account data
         pub commitment: CommitmentLevel,
-        /// HTTP RPC endpoint
-        pub rpc_url:    String,
-        /// WSS RPC endpoint
-        pub wss_url:    String,
     }
 
     impl Default for Config {
         fn default() -> Self {
             Self {
                 commitment: CommitmentLevel::Confirmed,
-                rpc_url:    "http://localhost:8899".to_string(),
-                wss_url:    "ws://localhost:8900".to_string(),
             }
         }
     }
@@ -494,6 +490,11 @@ mod subscriber {
     pub struct Subscriber {
         config: Config,
 
+        /// HTTP RPC endpoint
+        pub rpc_url: String,
+        /// WSS RPC endpoint
+        pub wss_url: String,
+
         /// Public key of the root account to monitor. Note that all
         /// accounts owned by this account are also monitored.
         account_key: Pubkey,
@@ -507,12 +508,16 @@ mod subscriber {
     impl Subscriber {
         pub fn new(
             config: Config,
+            rpc_url: String,
+            wss_url: String,
             account_key: Pubkey,
             updates_tx: mpsc::Sender<(Pubkey, solana_sdk::account::Account)>,
             logger: Logger,
         ) -> Self {
             Subscriber {
                 config,
+                rpc_url,
+                wss_url,
                 account_key,
                 updates_tx,
                 logger,
@@ -551,8 +556,8 @@ mod subscriber {
                 &self.account_key,
                 SyncOptions {
                     network: solana_shadow::Network::Custom(
-                        self.config.rpc_url.clone(),
-                        self.config.wss_url.clone(),
+                        self.rpc_url.clone(),
+                        self.wss_url.clone(),
                     ),
                     commitment: self.config.commitment,
                     ..SyncOptions::default()