feat(oracle): WIP add scores account

program/c/src/oracle/oracle.h

@@ -21,8 +21,12 @@ extern "C" {
 #define PC_PUBKEY_SIZE       32
 #define PC_PUBKEY_SIZE_64   (PC_PUBKEY_SIZE/sizeof(uint64_t))
 #define PC_MAP_TABLE_SIZE   640
+#define PC_MAX_PUBLISHERS    256
+#define PC_MAX_SYMBOLS       1024
+// This is the number of 64-bit words needed to store the bitset of symbols
+#define PC_MAX_SYMBOLS_64    (PC_MAX_SYMBOLS/64)
 
-  // Total price component slots available
+// Total price component slots available
 #define PC_NUM_COMP_PYTHNET     128
 
 // PC_NUM_COMP - number of price components in use
@@ -49,11 +53,12 @@ extern "C" {
 #define PC_STATUS_IGNORED     4
 
 // account types
-#define PC_ACCTYPE_MAPPING    1
-#define PC_ACCTYPE_PRODUCT    2
-#define PC_ACCTYPE_PRICE      3
-#define PC_ACCTYPE_TEST       4
-#define PC_ACCTYPE_PERMISSIONS       5
+#define PC_ACCTYPE_MAPPING      1
+#define PC_ACCTYPE_PRODUCT      2
+#define PC_ACCTYPE_PRICE        3
+#define PC_ACCTYPE_TEST         4
+#define PC_ACCTYPE_PERMISSIONS  5
+#define PC_ACCTYPE_SCORE        6
 
 
 // Compute budget requested per price update instruction

program/rust/src/accounts.rs

@@ -39,6 +39,7 @@ mod mapping;
 mod permission;
 mod price;
 mod product;
+mod score;
 
 // Some types only exist during use as a library.
 #[cfg(feature = "strum")]
@@ -64,6 +65,7 @@ pub use {
         update_product_metadata,
         ProductAccount,
     },
+    score::PublisherScoresAccount,
 };
 
 // PDA seeds for accounts.

program/rust/src/accounts/score.rs

@@ -0,0 +1,181 @@
+use {
+    super::{
+        AccountHeader,
+        PythAccount,
+    },
+    crate::c_oracle_header::{
+        PC_ACCTYPE_SCORE,
+        PC_MAX_PUBLISHERS,
+        PC_MAX_SYMBOLS,
+        PC_MAX_SYMBOLS_64,
+    },
+    bytemuck::{
+        Pod,
+        Zeroable,
+    },
+    solana_program::{
+        program_error::ProgramError,
+        pubkey::Pubkey,
+    },
+    std::cmp::max,
+};
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct PublisherScoresAccount {
+    pub header:         AccountHeader,
+    pub num_publishers: usize,
+    pub num_symbols:    usize,
+    // a constant used to normalize the scores
+    pub z:              u32,
+
+    // array[x][y] is a u64 whose bits represent if publisher x publishes symbols 64*y to 64*(y+1) - 1
+    pub publisher_permissions: [[u64; PC_MAX_SYMBOLS_64 as usize]; PC_MAX_PUBLISHERS as usize],
+    pub scores:                [f64; PC_MAX_PUBLISHERS as usize],
+    pub publishers:            [Pubkey; PC_MAX_PUBLISHERS as usize],
+    pub symbols:               [Pubkey; PC_MAX_SYMBOLS as usize],
+}
+
+impl PublisherScoresAccount {
+    fn get_publisher_permission(&self, x: usize, y: usize) -> bool {
+        (self.publisher_permissions[x][y / 64] >> (y % 64)) & 1 == 1
+    }
+
+    fn set_publisher_permission(&mut self, x: usize, y: usize, value: bool) {
+        if value {
+            self.publisher_permissions[x][y / 64] |= 1 << (y % 64);
+        } else {
+            self.publisher_permissions[x][y / 64] &= !(1 << (y % 64));
+        }
+    }
+
+    pub fn add_publisher(
+        &mut self,
+        publisher: Pubkey,
+        price_account: Pubkey,
+    ) -> Result<(), ProgramError> {
+        let publisher_index = self
+            .publishers
+            .iter()
+            .position(|&x| x == publisher)
+            .unwrap_or(self.num_publishers);
+
+        if publisher_index == self.num_publishers {
+            if self.num_publishers == PC_MAX_PUBLISHERS as usize {
+                return Err(ProgramError::AccountDataTooSmall);
+            }
+
+            self.publishers[self.num_publishers] = publisher;
+            self.num_publishers += 1;
+        }
+
+        let symbol_index = self
+            .symbols
+            .iter()
+            .position(|&x| x == price_account)
+            .ok_or(ProgramError::InvalidArgument)?;
+
+        self.set_publisher_permission(publisher_index, symbol_index, true);
+        self.calculate_scores()
+    }
+
+    pub fn del_publisher(
+        &mut self,
+        publisher: Pubkey,
+        price_account: Pubkey,
+    ) -> Result<(), ProgramError> {
+        let publisher_index = self
+            .publishers
+            .iter()
+            .position(|&x| x == publisher)
+            .ok_or(ProgramError::InvalidArgument)?;
+
+        let symbol_index = self
+            .symbols
+            .iter()
+            .position(|&x| x == price_account)
+            .ok_or(ProgramError::InvalidArgument)?;
+
+        self.set_publisher_permission(publisher_index, symbol_index, false);
+        self.calculate_scores()
+    }
+
+    pub fn add_price(&mut self, symbol: Pubkey) -> Result<(), ProgramError> {
+        let symbol_index = self
+            .symbols
+            .iter()
+            .position(|&x| x == symbol)
+            .unwrap_or(self.num_symbols);
+
+        if symbol_index == self.num_symbols {
+            if self.num_symbols == PC_MAX_SYMBOLS as usize {
+                return Err(ProgramError::AccountDataTooSmall);
+            }
+
+            self.symbols[self.num_symbols] = symbol;
+            self.num_symbols += 1;
+        }
+
+        Ok(())
+    }
+
+    pub fn del_price(&mut self, symbol: Pubkey) -> Result<(), ProgramError> {
+        let symbol_index = self
+            .symbols
+            .iter()
+            .position(|&x| x == symbol)
+            .ok_or(ProgramError::InvalidArgument)?;
+
+        // update symbol list
+        self.symbols[symbol_index] = self.symbols[self.num_symbols - 1];
+        self.symbols[self.num_symbols - 1] = Pubkey::default();
+
+        // update publisher permissions
+        for i in 0..self.num_publishers {
+            let value = self.get_publisher_permission(i, self.num_symbols - 1);
+            self.set_publisher_permission(i, symbol_index, value)
+        }
+
+        self.num_symbols -= 1;
+        self.calculate_scores()
+    }
+
+    pub fn calculate_scores(&mut self) -> Result<(), ProgramError> {
+        let symbol_scores: Vec<u32> = self
+            .symbols
+            .iter()
+            .enumerate()
+            .map(|(j, _)| {
+                let score = self
+                    .publisher_permissions
+                    .iter()
+                    .fold(0, |score, permissions| score + permissions[j] as u32);
+                max(score, self.z)
+            })
+            .collect();
+
+        for i in 0..self.num_publishers {
+            self.scores[i] = self
+                .symbols
+                .iter()
+                .enumerate()
+                .filter(|(j, _)| self.get_publisher_permission(i, *j))
+                .map(|(j, _)| 1f64 / symbol_scores[j] as f64)
+                .sum();
+        }
+        Ok(())
+    }
+}
+
+impl PythAccount for PublisherScoresAccount {
+    const ACCOUNT_TYPE: u32 = PC_ACCTYPE_SCORE;
+    // Calculate the initial size of the account
+    const INITIAL_SIZE: u32 = 1000;
+}
+
+// Unsafe impl because product_list is of size 640 and there's no derived trait for this size
+unsafe impl Pod for PublisherScoresAccount {
+}
+
+unsafe impl Zeroable for PublisherScoresAccount {
+}

program/rust/src/processor/add_price.rs

@@ -3,6 +3,7 @@ use {
         accounts::{
             PriceAccount,
             ProductAccount,
+            PublisherScoresAccount,
             PythAccount,
         },
         c_oracle_header::{
@@ -34,6 +35,7 @@ use {
 // account[0] funding account       [signer writable]
 // account[1] product account       [signer writable]
 // account[2] new price account     [signer writable]
+// account[3] scores account        [signer writable]
 pub fn add_price(
     program_id: &Pubkey,
     accounts: &[AccountInfo],
@@ -48,10 +50,12 @@ pub fn add_price(
     )?;
 
 
-    let (funding_account, product_account, price_account, permissions_account) = match accounts {
-        [x, y, z, p] => Ok((x, y, z, p)),
-        _ => Err(OracleError::InvalidNumberOfAccounts),
-    }?;
+    let (funding_account, product_account, price_account, permissions_account, scores_account) =
+        match accounts {
+            [x, y, z, p] => Ok((x, y, z, p, None)),
+            [x, y, z, p, s] => Ok((x, y, z, p, Some(s))),
+            _ => Err(OracleError::InvalidNumberOfAccounts),
+        }?;
 
     check_valid_funding_account(funding_account)?;
     check_permissioned_funding_account(
@@ -80,5 +84,11 @@ pub fn add_price(
     price_data.min_pub_ = PRICE_ACCOUNT_DEFAULT_MIN_PUB;
     product_data.first_price_account = *price_account.key;
 
+    if let Some(scores_account) = scores_account {
+        let mut scores_account =
+            load_checked::<PublisherScoresAccount>(scores_account, cmd_args.header.version)?;
+        scores_account.add_price(*price_account.key)?;
+    }
+
     Ok(())
 }

program/rust/src/processor/add_publisher.rs

@@ -3,6 +3,7 @@ use {
         accounts::{
             PriceAccount,
             PriceComponent,
+            PublisherScoresAccount,
             PythAccount,
         },
         c_oracle_header::PC_NUM_COMP,
@@ -36,6 +37,7 @@ use {
 /// Add publisher to symbol account
 // account[0] funding account       [signer writable]
 // account[1] price account         [signer writable]
+// account[2] scores account        [signer writable]
 pub fn add_publisher(
     program_id: &Pubkey,
     accounts: &[AccountInfo],
@@ -48,8 +50,9 @@ pub fn add_publisher(
         ProgramError::InvalidArgument,
     )?;
 
-    let (funding_account, price_account, permissions_account) = match accounts {
-        [x, y, p] => Ok((x, y, p)),
+    let (funding_account, price_account, permissions_account, scores_account) = match accounts {
+        [x, y, p] => Ok((x, y, p, None)),
+        [x, y, p, s] => Ok((x, y, p, Some(s))),
         _ => Err(OracleError::InvalidNumberOfAccounts),
     }?;
 
@@ -99,6 +102,13 @@ pub fn add_publisher(
     }
 
     price_data.header.size = try_convert::<_, u32>(PriceAccount::INITIAL_SIZE)?;
+
+    if let Some(scores_account) = scores_account {
+        let mut scores_account =
+            load_checked::<PublisherScoresAccount>(scores_account, cmd_args.header.version)?;
+        scores_account.add_publisher(cmd_args.publisher, *price_account.key)?;
+    }
+
     Ok(())
 }
 

program/rust/src/processor/del_price.rs

@@ -3,6 +3,7 @@ use {
         accounts::{
             PriceAccount,
             ProductAccount,
+            PublisherScoresAccount,
         },
         deserialize::{
             load,
@@ -30,17 +31,20 @@ use {
 // account[0] funding account       [signer writable]
 // account[1] product account       [signer writable]
 // account[2] price account         [signer writable]
+// account[3] scores account        [signer writable]
 /// Warning: This function is dangerous and will break any programs that depend on the deleted
 /// price account!
 pub fn del_price(
     program_id: &Pubkey,
     accounts: &[AccountInfo],
     instruction_data: &[u8],
 ) -> ProgramResult {
-    let (funding_account, product_account, price_account, permissions_account) = match accounts {
-        [w, x, y, p] => Ok((w, x, y, p)),
-        _ => Err(OracleError::InvalidNumberOfAccounts),
-    }?;
+    let (funding_account, product_account, price_account, permissions_account, scores_account) =
+        match accounts {
+            [x, y, z, p] => Ok((x, y, z, p, None)),
+            [x, y, z, p, s] => Ok((x, y, z, p, Some(s))),
+            _ => Err(OracleError::InvalidNumberOfAccounts),
+        }?;
 
     let cmd_args = load::<CommandHeader>(instruction_data)?;
 
@@ -83,5 +87,11 @@ pub fn del_price(
     **price_account.lamports.borrow_mut() = 0;
     **funding_account.lamports.borrow_mut() += lamports;
 
+    if let Some(scores_account) = scores_account {
+        let mut scores_account =
+            load_checked::<PublisherScoresAccount>(scores_account, cmd_args.version)?;
+        scores_account.del_price(*price_account.key)?;
+    }
+
     Ok(())
 }