feat(oracle): WIP add scores account

.vscode/settings.json

@@ -0,0 +1,9 @@
+{
+    "rust-analyzer.check.command": "clippy",
+    "editor.defaultFormatter": "rust-lang.rust-analyzer",
+    "rust-analyzer.rustfmt.overrideCommand": [
+        "rustfmt",
+        "+nightly"
+    ],
+    "editor.formatOnSave": true,
+}

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/Cargo.toml

@@ -13,7 +13,6 @@ solana-program = "=1.13.3"
 bytemuck = "1.11.0"
 thiserror = "1.0"
 num-derive = "0.3"
-num-traits = "0.2"
 byteorder = "1.4.3"
 serde = { version = "1.0", features = ["derive"], optional = true }
 strum = { version = "0.24.1", features = ["derive"], optional = true }
@@ -26,6 +25,7 @@ tokio = "1.14.1"
 hex = "0.3.1"
 quickcheck = "1"
 rand = "0.8.5"
+num-traits = "0.2"
 quickcheck_macros = "1"
 bincode = "1.3.3"
 serde = { version = "1.0", features = ["derive"] }

program/rust/build.rs

@@ -89,10 +89,10 @@ fn do_make_build(targets: Vec<&str>, out_dir: &Path) {
     if !make_output.status.success() {
         panic!(
             "C oracle make build did not exit with 0 (code
-	({:?}).\n\nstdout:\n{}\n\nstderr:\n{}",
+    	({:?}).\n\nstdout:\n{}\n\nstderr:\n{}",
             make_output.status.code(),
-            String::from_utf8(make_output.stdout).unwrap_or("<non-utf8>".to_owned()),
-            String::from_utf8(make_output.stderr).unwrap_or("<non-utf8>".to_owned())
+            String::from_utf8(make_output.stdout).unwrap_or_else(|_| "<non-utf8>".to_owned()),
+            String::from_utf8(make_output.stderr).unwrap_or_else(|_| "<non-utf8>".to_owned())
         );
     }
 }

program/rust/src/accounts.rs

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

program/rust/src/accounts/publisher_caps.rs

@@ -0,0 +1,307 @@
+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, Pod, Zeroable)]
+
+/// This account is part of Community Integrity Pool (CIP) project.
+/// It is used to store the caps of the publishers which will be sent
+/// to the `integrity_pool` program on mainnet to calculate the rewards.
+pub struct PublisherCapsAccount {
+    pub header:         AccountHeader,
+    pub num_publishers: usize,
+    pub num_symbols:    usize,
+    // Z is a constant used to normalize the caps
+    pub z:              u64,
+    // M is a constant showing the target stake per symbol
+    pub m:              u64,
+
+    // 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 caps:                  [u64; PC_MAX_PUBLISHERS as usize],
+    pub publishers:            [Pubkey; PC_MAX_PUBLISHERS as usize],
+    pub prices:                [Pubkey; PC_MAX_SYMBOLS as usize],
+}
+
+impl PublisherCapsAccount {
+    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
+            .prices
+            .iter()
+            .position(|&x| x == price_account)
+            .ok_or(ProgramError::InvalidArgument)?;
+
+        self.set_publisher_permission(publisher_index, symbol_index, true);
+
+        self.calculate_caps()
+    }
+
+    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 price_index = self
+            .prices
+            .iter()
+            .position(|&x| x == price_account)
+            .ok_or(ProgramError::InvalidArgument)?;
+
+        self.set_publisher_permission(publisher_index, price_index, false);
+        self.calculate_caps()
+    }
+
+    pub fn add_price(&mut self, symbol: Pubkey) -> Result<(), ProgramError> {
+        let price_index = self
+            .prices
+            .iter()
+            .position(|&x| x == symbol)
+            .unwrap_or(self.num_symbols);
+
+        if price_index == self.num_symbols {
+            if self.num_symbols == PC_MAX_SYMBOLS as usize {
+                return Err(ProgramError::AccountDataTooSmall);
+            }
+
+            self.prices[self.num_symbols] = symbol;
+            self.num_symbols += 1;
+        }
+
+        Ok(())
+    }
+
+    pub fn del_price(&mut self, symbol: Pubkey) -> Result<(), ProgramError> {
+        let price_index = self
+            .prices
+            .iter()
+            .position(|&x| x == symbol)
+            .ok_or(ProgramError::InvalidArgument)?;
+
+        // update symbol list
+        self.prices[price_index] = self.prices[self.num_symbols - 1];
+        self.prices[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, price_index, value)
+        }
+
+        self.num_symbols -= 1;
+        self.calculate_caps()
+    }
+
+
+    pub fn calculate_caps(&mut self) -> Result<(), ProgramError> {
+        let price_weights: Vec<u64> = self
+            .prices
+            .iter()
+            .enumerate()
+            .map(|(j, _)| {
+                let weight = self
+                    .publisher_permissions
+                    .iter()
+                    .enumerate()
+                    .filter(|(i, _)| self.get_publisher_permission(*i, j))
+                    .count() as u64;
+                max(weight, self.z)
+            })
+            .collect();
+
+        for i in 0..self.num_publishers {
+            self.caps[i] = self
+                .prices
+                .iter()
+                .enumerate()
+                .filter(|(j, _)| self.get_publisher_permission(i, *j))
+                .map(|(j, _)| self.m * 1_000_000_000_u64 / price_weights[j])
+                .sum();
+        }
+        Ok(())
+    }
+}
+
+impl PythAccount for PublisherCapsAccount {
+    const ACCOUNT_TYPE: u32 = PC_ACCTYPE_SCORE;
+    // Calculate the initial size of the account
+    const INITIAL_SIZE: u32 = 75824;
+}
+
+
+#[cfg(test)]
+mod tests {
+    use {
+        super::*,
+        crate::c_oracle_header::{
+            PC_ACCTYPE_SCORE,
+            PC_VERSION,
+        },
+        solana_program::pubkey::Pubkey,
+        std::mem::size_of,
+    };
+
+    fn get_empty_account() -> PublisherCapsAccount {
+        PublisherCapsAccount {
+            header:                AccountHeader {
+                magic_number: PC_ACCTYPE_SCORE,
+                account_type: PC_ACCTYPE_SCORE,
+                version:      PC_VERSION,
+                size:         size_of::<PublisherCapsAccount>() as u32,
+            },
+            num_publishers:        0,
+            num_symbols:           0,
+            z:                     2,
+            m:                     1000,
+            publisher_permissions: [[0; PC_MAX_SYMBOLS_64 as usize]; PC_MAX_PUBLISHERS as usize],
+            caps:                  [0; PC_MAX_PUBLISHERS as usize],
+            publishers:            [Pubkey::default(); PC_MAX_PUBLISHERS as usize],
+            prices:                [Pubkey::default(); PC_MAX_SYMBOLS as usize],
+        }
+    }
+
+    #[test]
+    fn test_size_of_publisher_caps_account() {
+        let account = get_empty_account();
+        assert_eq!(
+            PublisherCapsAccount::INITIAL_SIZE as usize,
+            size_of::<PublisherCapsAccount>()
+        );
+        assert_eq!(
+            account.header.size as usize,
+            size_of::<PublisherCapsAccount>()
+        );
+    }
+
+    #[test]
+    fn test_publisher_caps_account() {
+        let mut account = get_empty_account();
+
+        let publisher1 = Pubkey::new_unique();
+        let publisher2 = Pubkey::new_unique();
+        let publisher3 = Pubkey::new_unique();
+        let symbol1 = Pubkey::new_unique();
+        let symbol2 = Pubkey::new_unique();
+
+        account.add_price(symbol1).unwrap();
+        account.add_price(symbol2).unwrap();
+
+        account.add_publisher(publisher1, symbol1).unwrap();
+        assert_eq!(account.caps[..2], [account.m * 500_000_000, 0]);
+
+        account.add_publisher(publisher1, symbol2).unwrap();
+        assert!(account.get_publisher_permission(0, 0));
+        assert!(account.get_publisher_permission(0, 1));
+        assert_eq!(account.caps[..2], [account.m * 1_000_000_000, 0]);
+
+
+        account.add_publisher(publisher2, symbol1).unwrap();
+        assert_eq!(
+            account.caps[..2],
+            [account.m * 1_000_000_000, account.m * 500_000_000]
+        );
+
+        account.add_publisher(publisher2, symbol2).unwrap();
+        assert!(account.get_publisher_permission(1, 0));
+        assert!(account.get_publisher_permission(1, 1));
+        assert_eq!(
+            account.caps[..2],
+            [account.m * 1_000_000_000, account.m * 1_000_000_000]
+        );
+
+        account.add_publisher(publisher3, symbol1).unwrap();
+        assert_eq!(
+            account.caps[..3],
+            [833_333_333_333, 833_333_333_333, 333333333333]
+        );
+
+        account.del_publisher(publisher1, symbol1).unwrap();
+        assert_eq!(account.num_publishers, 3);
+        assert_eq!(account.num_symbols, 2);
+        assert!(!account.get_publisher_permission(0, 0));
+        assert!(account.get_publisher_permission(0, 1));
+        assert!(account.get_publisher_permission(1, 0));
+        assert!(account.get_publisher_permission(1, 1));
+
+        account.del_publisher(publisher1, symbol2).unwrap();
+        assert_eq!(account.num_publishers, 3);
+        assert_eq!(account.num_symbols, 2);
+        assert!(!account.get_publisher_permission(0, 0));
+        assert!(!account.get_publisher_permission(0, 1));
+        assert!(account.get_publisher_permission(1, 0));
+        assert!(account.get_publisher_permission(1, 1));
+
+        account.del_publisher(publisher2, symbol1).unwrap();
+        assert_eq!(account.num_publishers, 3);
+        assert_eq!(account.num_symbols, 2);
+        assert!(!account.get_publisher_permission(0, 0));
+        assert!(!account.get_publisher_permission(0, 1));
+        assert!(!account.get_publisher_permission(1, 0));
+        assert!(account.get_publisher_permission(1, 1));
+
+        account.del_publisher(publisher2, symbol2).unwrap();
+        assert_eq!(account.num_publishers, 3);
+        assert_eq!(account.num_symbols, 2);
+        assert!(!account.get_publisher_permission(0, 0));
+        assert!(!account.get_publisher_permission(0, 1));
+        assert!(!account.get_publisher_permission(1, 0));
+        assert!(!account.get_publisher_permission(1, 1));
+
+        assert_eq!(account.caps[..3], [0, 0, 500000000000]);
+    }
+}