Change Oracle to use Key Store keys instead of those defined manually in config

Author: tompntn

Cargo.lock

@@ -35,7 +35,6 @@ config = "0.13.3"
 thiserror = "1.0.32"
 solana-shadow = "0.2.4"
 clap = { version = "4.0.32", features = ["derive"] }
-serde_with = "2.2.0"
 humantime-serde = "1.1.1"
 
 [dev-dependencies]

Cargo.toml

@@ -1,7 +1,4 @@
 [primary_network]
 key_store.root_path = "keystore"
 oracle.poll_interval_duration = "1s"
-oracle.oracle_account_key = "BujGr9ChcuaCJhxeFEvGvaCFTxSV1CUCSVHL1SVFpU4i"
-oracle.mapping_account_key = "BTJKZngp3vzeJiRmmT9PitQH4H29dhQZ1GNhxFfDi4kw"
-oracle.subscriber.account_key = "BujGr9ChcuaCJhxeFEvGvaCFTxSV1CUCSVHL1SVFpU4i"
 exporter.transaction_monitor.poll_interval_duration = "1s"

integration-tests/agent_conf.toml

@@ -50,19 +50,21 @@ pub mod network {
         global_store_update_tx: mpsc::Sender<global::Update>,
         logger: Logger,
     ) -> Result<Vec<JoinHandle<()>>> {
-        // Create the key store
-        let key_store = KeyStore::new(config.key_store.clone())?;
-
         // Spawn the Oracle
         let mut jhs = oracle::spawn_oracle(
             config.oracle.clone(),
+            KeyStore::new(config.key_store.clone())?,
             global_store_update_tx,
             logger.clone(),
         );
 
         // Spawn the Exporter
-        let exporter_jhs =
-            exporter::spawn_exporter(config.exporter, key_store, local_store_tx, logger)?;
+        let exporter_jhs = exporter::spawn_exporter(
+            config.exporter,
+            KeyStore::new(config.key_store.clone())?,
+            local_store_tx,
+            logger,
+        )?;
         jhs.extend(exporter_jhs);
 
         Ok(jhs)

src/agent/solana.rs

@@ -3,6 +3,7 @@
 
 use {
     self::subscriber::Subscriber,
+    super::key_store::KeyStore,
     crate::agent::store::global,
     anyhow::{
         anyhow,
@@ -18,10 +19,6 @@ use {
         Deserialize,
         Serialize,
     },
-    serde_with::{
-        serde_as,
-        DisplayFromStr,
-    },
     slog::Logger,
     solana_client::nonblocking::rpc_client::RpcClient,
     solana_sdk::{
@@ -65,6 +62,9 @@ pub type PriceAccount = pyth_sdk_solana::state::PriceAccount;
 pub struct Oracle {
     config: Config,
 
+    // The Key Store
+    key_store: KeyStore,
+
     // The Solana account data
     data: Data,
 
@@ -85,18 +85,11 @@ pub struct Oracle {
     logger: Logger,
 }
 
-#[serde_as]
 #[derive(Clone, Serialize, Deserialize, Debug)]
 #[serde(default)]
 pub struct Config {
     /// The commitment level to use when reading data from the RPC node.
     pub commitment:               CommitmentLevel,
-    /// Public key of the Oracle program.
-    #[serde_as(as = "DisplayFromStr")]
-    pub oracle_account_key:       Pubkey,
-    /// Public key of the root mapping account.
-    #[serde_as(as = "DisplayFromStr")]
-    pub mapping_account_key:      Pubkey,
     /// RPC endpoint to send requests to.
     pub rpc_url:                  String,
     /// The interval with which to poll account information.
@@ -114,8 +107,6 @@ impl Default for Config {
     fn default() -> Self {
         Self {
             commitment:               CommitmentLevel::Confirmed,
-            oracle_account_key:       Default::default(),
-            mapping_account_key:      Default::default(),
             rpc_url:                  "http://localhost:8899".to_string(),
             poll_interval_duration:   Duration::from_secs(30),
             subscriber_enabled:       true,
@@ -127,6 +118,7 @@ impl Default for Config {
 
 pub fn spawn_oracle(
     config: Config,
+    key_store: KeyStore,
     global_store_update_tx: mpsc::Sender<global::Update>,
     logger: Logger,
 ) -> Vec<JoinHandle<()>> {
@@ -135,12 +127,23 @@ pub fn spawn_oracle(
     // Create and spawn the account subscriber
     let (updates_tx, updates_rx) = mpsc::channel(config.updates_channel_capacity);
     if config.subscriber_enabled {
-        let subscriber = Subscriber::new(config.subscriber.clone(), updates_tx, logger.clone());
+        let subscriber = Subscriber::new(
+            config.subscriber.clone(),
+            key_store.program_key.clone(),
+            updates_tx,
+            logger.clone(),
+        );
         jhs.push(tokio::spawn(async move { subscriber.run().await }));
     }
 
     // Create and spawn the Oracle
-    let mut oracle = Oracle::new(config, updates_rx, global_store_update_tx, logger);
+    let mut oracle = Oracle::new(
+        config,
+        key_store,
+        updates_rx,
+        global_store_update_tx,
+        logger,
+    );
     jhs.push(tokio::spawn(async move { oracle.run().await }));
 
     jhs
@@ -149,6 +152,7 @@ pub fn spawn_oracle(
 impl Oracle {
     pub fn new(
         config: Config,
+        key_store: KeyStore,
         updates_rx: mpsc::Receiver<(Pubkey, solana_sdk::account::Account)>,
         global_store_tx: mpsc::Sender<global::Update>,
         logger: Logger,
@@ -163,6 +167,7 @@ impl Oracle {
 
         Oracle {
             config,
+            key_store,
             data: Default::default(),
             rpc_client,
             poll_interval,
@@ -200,7 +205,7 @@ impl Oracle {
             .cloned()
             .collect::<HashSet<_>>();
         self.data.mapping_accounts = self
-            .fetch_mapping_accounts(self.config.mapping_account_key)
+            .fetch_mapping_accounts(self.key_store.mapping_key)
             .await?;
         info!(self.logger, "fetched mapping accounts"; "new" => format!("{:?}", self
             .data
@@ -449,10 +454,6 @@ mod subscriber {
             Deserialize,
             Serialize,
         },
-        serde_with::{
-            serde_as,
-            DisplayFromStr,
-        },
         slog::Logger,
         solana_sdk::{
             account::Account,
@@ -469,29 +470,23 @@ mod subscriber {
         },
     };
 
-    #[serde_as]
     #[derive(Clone, Serialize, Deserialize, Debug)]
     #[serde(default)]
     pub struct Config {
         /// Commitment level used to read account data
-        pub commitment:  CommitmentLevel,
-        /// Public key of the root account to monitor. Note that all
-        /// accounts owned by this account are also monitored.
-        #[serde_as(as = "DisplayFromStr")]
-        pub account_key: Pubkey,
+        pub commitment: CommitmentLevel,
         /// HTTP RPC endpoint
-        pub rpc_url:     String,
+        pub rpc_url:    String,
         /// WSS RPC endpoint
-        pub wss_url:     String,
+        pub wss_url:    String,
     }
 
     impl Default for Config {
         fn default() -> Self {
             Self {
-                commitment:  CommitmentLevel::Confirmed,
-                account_key: Default::default(),
-                rpc_url:     "http://localhost:8899".to_string(),
-                wss_url:     "ws://localhost:8900".to_string(),
+                commitment: CommitmentLevel::Confirmed,
+                rpc_url:    "http://localhost:8899".to_string(),
+                wss_url:    "ws://localhost:8900".to_string(),
             }
         }
     }
@@ -501,7 +496,11 @@ mod subscriber {
     pub struct Subscriber {
         config: Config,
 
-        // Channel on which updates are sent
+        /// Public key of the root account to monitor. Note that all
+        /// accounts owned by this account are also monitored.
+        account_key: Pubkey,
+
+        /// Channel on which updates are sent
         updates_tx: mpsc::Sender<(Pubkey, solana_sdk::account::Account)>,
 
         logger: Logger,
@@ -510,11 +509,13 @@ mod subscriber {
     impl Subscriber {
         pub fn new(
             config: Config,
+            account_key: Pubkey,
             updates_tx: mpsc::Sender<(Pubkey, solana_sdk::account::Account)>,
             logger: Logger,
         ) -> Self {
             Subscriber {
                 config,
+                account_key,
                 updates_tx,
                 logger,
             }
@@ -549,7 +550,7 @@ mod subscriber {
             &self,
         ) -> Result<broadcast::Receiver<(Pubkey, solana_sdk::account::Account)>> {
             let shadow = BlockchainShadow::new_for_program(
-                &self.config.account_key,
+                &self.account_key,
                 SyncOptions {
                     network: solana_shadow::Network::Custom(
                         self.config.rpc_url.clone(),