score-all command

.gitignore

@@ -3,3 +3,4 @@
 /registry-cli
 /db
 test-ledger/
+.vscode

Dockerfile

@@ -0,0 +1,21 @@
+FROM alpine:3.14
+
+RUN apk update
+RUN apk upgrade
+RUN apk add --no-cache bash sqlite rust cargo openssl-dev eudev-dev linux-headers
+
+WORKDIR /usr/local/
+
+ADD program program/
+ADD cli cli/
+ADD bot bot/
+ADD sql sql/
+ADD Cargo.lock .
+ADD Cargo.toml .
+ADD clean-score-all-mainnet.bash .
+ADD score-all-mainnet.sh .
+ADD import-into-sqlite.sh .
+
+RUN cargo build
+
+CMD ./clean-score-all-mainnet.bash

RELEASE.md

@@ -1,11 +1,14 @@
+# stake-o-matic
 
-The release of the binaries is fully automated. Do not create a Github release
-manually.
+## Build with cargo and run
+```bash
+cargo build
+wget "https://github.com/marinade-finance/staking-status/raw/main/scores.sqlite3" -O "db/score-sqlite3.db"
+./clean-score-all-mainnet.bash
+```
 
-#### Release Process
-1. Create a new tag for the next available release number, see
-   https://github.com/solana-labs/stake-o-matic/tags, and push it to the repo:
-   eg, `git tag v42 && git push origin v42`
-2. The GitHub workflow automatically triggers a new build, creates a release
-   with the name of the tag, and uploads the release artifacts.  You can monitor
-   the release process at https://github.com/solana-labs/stake-o-matic/actions
+## Build with docker and run
+```bash
+./docker-build.bash
+./docker-run.bash
+```

bot/src/data_center_info.rs

@@ -1,5 +1,5 @@
 use {
-    crate::validators_app,
+    crate::{validators_app, ByIdentityInfo},
     log::*,
     serde::{Deserialize, Serialize},
     solana_sdk::pubkey::Pubkey,
@@ -75,7 +75,7 @@ impl std::fmt::Display for DataCenterInfo {
 #[derive(Debug, Default)]
 pub struct DataCenters {
     pub info: Vec<DataCenterInfo>,
-    pub by_identity: HashMap<Pubkey, DataCenterId>,
+    pub by_identity: HashMap<Pubkey, ByIdentityInfo>,
 }
 
 pub fn get(cluster: &str) -> Result<DataCenters, Box<dyn error::Error>> {
@@ -123,7 +123,15 @@ pub fn get(cluster: &str) -> Result<DataCenters, Box<dyn error::Error>> {
             })
             .unwrap_or_default();
 
-        by_identity.insert(identity, data_center_id.clone());
+        by_identity.insert(
+            identity,
+            ByIdentityInfo {
+                data_center_id: data_center_id.clone(),
+                keybase_id: String::from(v.keybase_id.as_deref().unwrap_or("")),
+                name: String::from(v.name.as_deref().unwrap_or("")),
+                www_url: String::from(v.www_url.as_deref().unwrap_or("")),
+            },
+        );
 
         let mut data_center_info = data_center_map
             .entry(data_center_id.clone())

bot/src/db.rs

@@ -2,6 +2,7 @@ use {
     crate::{
         data_center_info::{DataCenterId, DataCenterInfo},
         generic_stake_pool::ValidatorStakeState,
+        Config,
     },
     log::*,
     serde::{Deserialize, Serialize},
@@ -14,6 +15,33 @@ use {
     },
 };
 
+#[derive(Default, Clone, Deserialize, Serialize)]
+pub struct ScoreDiscounts {
+    pub can_halt_the_network_group: bool,
+}
+
+#[derive(Debug, Default, Clone, Deserialize, Serialize)]
+pub struct ByIdentityInfo {
+    pub data_center_id: DataCenterId,
+    pub keybase_id: String,
+    pub name: String,
+    pub www_url: String,
+}
+
+#[derive(Default, Clone, Deserialize, Serialize)]
+/// computed score (more granular than ValidatorStakeState)
+pub struct ScoreData {
+    /// epoch_credits is the base score
+    pub epoch_credits: u64,
+    /// 50 => Average, 0=>worst, 100=twice the average
+    pub average_position: f64,
+    pub score_discounts: ScoreDiscounts,
+    pub commission: u8,
+    pub active_stake: u64,
+    pub data_center_concentration: f64,
+    pub validators_app_info: ByIdentityInfo,
+}
+
 #[derive(Default, Clone, Deserialize, Serialize)]
 pub struct ValidatorClassification {
     pub identity: Pubkey, // Validator identity
@@ -22,6 +50,9 @@ pub struct ValidatorClassification {
     pub stake_state: ValidatorStakeState,
     pub stake_state_reason: String,
 
+    // added optional validator scoring data
+    pub score_data: Option<ScoreData>,
+
     // Summary of the action was taken this epoch to advance the validator's stake
     pub stake_action: Option<String>,
 
@@ -45,6 +76,50 @@ pub struct ValidatorClassification {
     pub prioritize_funding_in_next_epoch: Option<bool>,
 }
 
+impl ScoreData {
+    pub fn score(&self, config: &Config) -> u64 {
+        if self.score_discounts.can_halt_the_network_group
+            || self.active_stake < config.score_min_stake
+            || self.average_position < config.min_avg_position
+            // if config.min_avg_position=100 => everybody passes
+            // if config.min_avg_position=50 => only validators above avg pass
+            || self.commission > config.score_max_commission
+        {
+            0
+        } else {
+            // if data_center_concentration = 25%, lose all score,
+            // data_center_concentration = 10%, lose 40% (rounded)
+            let discount_because_data_center_concentration = (self.data_center_concentration
+                * config.score_concentration_point_discount as f64)
+                as u64;
+
+            // score discounts according to commission
+            // apply commission % as a discount to credits_observed.
+            // The rationale es:
+            // If you're the top performer validator and get 300K credits, but you have 50% commission,
+            // from our user's point of view, it's the same as a 150K credits validator with 0% commission,
+            // both represent the same APY for the user.
+            // So to treat both the same we apply commission to self.epoch_credits
+            let discount_because_commission = self.commission as u64 * self.epoch_credits / 100;
+
+            // give extra score to above average validators in order to increase APY for our users
+            let points_added_above_average: u64 = if self.average_position > 50.0 {
+                let above = self.average_position - 50.0;
+                let multiplier = if above * above > 25.0 { 25.0 } else {above * above};
+                (multiplier * self.epoch_credits as f64) as u64
+            } else {
+                0
+            };
+
+            //result
+            self.epoch_credits
+                .saturating_sub(discount_because_commission)
+                .saturating_sub(discount_because_data_center_concentration)
+                .saturating_add(points_added_above_average)
+        }
+    }
+}
+
 impl ValidatorClassification {
     pub fn stake_state_streak(&self) -> usize {
         let mut streak = 1;