add proposer rewards and python stuff

Author: cameron1024

asyncio

@@ -0,0 +1,54 @@
+use std::path::PathBuf;
+
+use rust_decimal::Decimal;
+use serde::Deserialize;
+
+use crate::cli::rewards::community_advisors::{FundSettingOpt, ProposalRewardsSlotsOpt};
+
+#[derive(Debug, Deserialize)]
+pub(super) struct Config {
+    pub(super) inputs: Inputs,
+    pub(super) outputs: Outputs,
+    pub(super) params: Params,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct Inputs {
+    pub(super) block_file: PathBuf,
+    pub(super) snapshot_path: PathBuf,
+    pub(super) vote_count_path: PathBuf,
+    pub(super) reviews_csv: PathBuf,
+    pub(super) assessments_path: PathBuf, // is assessments the same as reviews?
+    pub(super) proposal_bonus_output: Option<PathBuf>,
+    pub(super) approved_proposals_path: PathBuf,
+    pub(super) proposer_script_path: PathBuf,
+    pub(super) active_voteplans: PathBuf,
+    pub(super) challenges: PathBuf,
+    pub(super) proposals_path: PathBuf,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct Outputs {
+    pub(super) veterans_rewards_output: PathBuf,
+    pub(super) ca_rewards_output: PathBuf,
+    pub(super) proposer_rewards_output: PathBuf,
+}
+
+#[derive(Debug, Deserialize)]
+pub(super) struct Params {
+    pub(super) registration_threshold: u64,
+    pub(super) vote_threshold: u64,
+    pub(super) total_rewards: u64,
+    pub(super) rewards_agreement_rate_cutoffs: Vec<Decimal>,
+    pub(super) rewards_agreement_rate_modifiers: Vec<Decimal>,
+    pub(super) reputation_agreement_rate_cutoffs: Vec<Decimal>,
+    pub(super) reputation_agreement_rate_modifiers: Vec<Decimal>,
+    pub(super) min_rankings: usize,
+    pub(super) max_rankings_reputation: usize,
+    pub(super) max_rankings_rewards: usize,
+    pub(super) rewards_slots: ProposalRewardsSlotsOpt,
+    pub(super) fund_settings: FundSettingOpt,
+    pub(super) ca_seed: String,
+    pub(super) proposer_stake_threshold: f64,
+    pub(super) proposer_approval_threshold: f64,
+}

catalyst-toolbox/scripts/python/proposers_rewards.py

@@ -1,15 +1,13 @@
-use std::{
-    fs::File,
-    path::{Path, PathBuf},
-};
+use std::{fs::File, path::Path};
 
 use color_eyre::Result;
+use config::*;
 use log::info;
-use rust_decimal::Decimal;
-use serde::Deserialize;
 use serde_json::from_reader;
 
-use super::community_advisors::{FundSettingOpt, ProposalRewardsSlotsOpt};
+mod config;
+mod proposers;
+mod python;
 
 pub(super) fn full_rewards(path: &Path) -> Result<()> {
     let config = from_reader(File::open(path)?)?;
@@ -23,11 +21,16 @@ pub(super) fn full_rewards(path: &Path) -> Result<()> {
                 assessments_path,
                 proposal_bonus_output,
                 approved_proposals_path,
+                proposer_script_path,
+                active_voteplans,
+                challenges,
+                proposals_path,
             },
         outputs:
             Outputs {
                 veterans_rewards_output,
                 ca_rewards_output,
+                proposer_rewards_output,
             },
         params:
             Params {
@@ -44,12 +47,14 @@ pub(super) fn full_rewards(path: &Path) -> Result<()> {
                 rewards_slots,
                 fund_settings,
                 ca_seed,
+                proposer_stake_threshold,
+                proposer_approval_threshold,
             },
     } = config;
 
     info!("calculating voter rewards");
     super::voters::voter_rewards(
-        Some(block_file),
+        &block_file,
         vote_count_path,
         snapshot_path,
         registration_threshold,
@@ -82,46 +87,17 @@ pub(super) fn full_rewards(path: &Path) -> Result<()> {
         proposal_bonus_output,
     )?;
 
-    Ok(())
-}
-
-#[derive(Debug, Deserialize)]
-struct Config {
-    inputs: Inputs,
-    outputs: Outputs,
-    params: Params,
-}
-
-#[derive(Debug, Deserialize)]
-struct Inputs {
-    block_file: PathBuf,
-    snapshot_path: PathBuf,
-    vote_count_path: PathBuf,
-    reviews_csv: PathBuf,
-    assessments_path: PathBuf, // is assessments the same as reviews?
-    proposal_bonus_output: Option<PathBuf>,
-    approved_proposals_path: PathBuf,
-}
-
-#[derive(Debug, Deserialize)]
-struct Outputs {
-    veterans_rewards_output: PathBuf,
-    ca_rewards_output: PathBuf,
-}
+    info!("calculating proposer rewards");
+    proposers::proposers_rewards(
+        &proposer_script_path,
+        &block_file,
+        &proposer_rewards_output,
+        proposer_stake_threshold,
+        proposer_approval_threshold,
+        &proposals_path,
+        &active_voteplans,
+        &challenges,
+    )?;
 
-#[derive(Debug, Deserialize)]
-struct Params {
-    registration_threshold: u64,
-    vote_threshold: u64,
-    total_rewards: u64,
-    rewards_agreement_rate_cutoffs: Vec<Decimal>,
-    rewards_agreement_rate_modifiers: Vec<Decimal>,
-    reputation_agreement_rate_cutoffs: Vec<Decimal>,
-    reputation_agreement_rate_modifiers: Vec<Decimal>,
-    min_rankings: usize,
-    max_rankings_reputation: usize,
-    max_rankings_rewards: usize,
-    rewards_slots: ProposalRewardsSlotsOpt,
-    fund_settings: FundSettingOpt,
-    ca_seed: String,
+    Ok(())
 }

catalyst-toolbox/src/bin/cli/rewards/full/config.rs

@@ -0,0 +1,36 @@
+use std::{ffi::OsStr, path::Path};
+
+use color_eyre::Result;
+
+use super::python::exec_python_script;
+
+pub(super) fn proposers_rewards(
+    proposer_reward_script: &Path,
+    block0: &Path,
+    output: &Path,
+    stake_threshold: f64,
+    approval_threshold: f64,
+    proposals: &Path,
+    active_voteplans: &Path,
+    challenges: &Path,
+) -> Result<()> {
+    exec_python_script(
+        proposer_reward_script,
+        [
+            OsStr::new("--block0-path"),
+            block0.as_ref(),
+            OsStr::new("--output-file"),
+            output.as_ref(),
+            OsStr::new("--total-stake-threshold"),
+            OsStr::new(&format!("{stake_threshold}")),
+            OsStr::new("--approval-threshold"),
+            OsStr::new(&format!("{approval_threshold}")),
+            OsStr::new("--proposals-path"),
+            proposals.as_ref(),
+            OsStr::new("--active-voteplans-path"),
+            active_voteplans.as_ref(),
+            OsStr::new("--challenges-path"),
+            challenges.as_ref(),
+        ],
+    )
+}

catalyst-toolbox/src/bin/cli/rewards/full/mod.rs

@@ -0,0 +1,11 @@
+use std::{ffi::OsStr, process::Command};
+
+use color_eyre::eyre::Result;
+
+pub(crate) fn exec_python_script(
+    path: impl AsRef<OsStr>,
+    args: impl IntoIterator<Item = impl AsRef<OsStr>>,
+) -> Result<()> {
+    Command::new("python").arg(path).args(args).output()?;
+    Ok(())
+}

catalyst-toolbox/src/bin/cli/rewards/full/proposers.rs

@@ -2,6 +2,7 @@ use catalyst_toolbox::rewards::voters::{calc_voter_rewards, Rewards, VoteCount};
 use catalyst_toolbox::snapshot::{registration::MainnetRewardAddress, Snapshot};
 use catalyst_toolbox::utils::assert_are_close;
 
+use color_eyre::eyre::eyre;
 use color_eyre::{Report, Result};
 use jcli_lib::block::{load_block, open_block_file};
 use jcli_lib::jcli_lib::block::{open_output, Common};
@@ -11,7 +12,7 @@ use jormungandr_lib::interfaces::Block0Configuration;
 use structopt::StructOpt;
 
 use std::collections::BTreeMap;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 #[derive(StructOpt)]
 #[structopt(rename_all = "kebab-case")]
@@ -69,7 +70,10 @@ impl VotersRewards {
         } = self;
 
         voter_rewards(
-            common.output_file,
+            common
+                .output_file
+                .as_deref()
+                .ok_or(eyre!("missing block file"))?,
             votes_count_path,
             snapshot_path,
             registration_threshold,
@@ -80,14 +84,14 @@ impl VotersRewards {
 }
 
 pub fn voter_rewards(
-    block_file: Option<PathBuf>,
+    block_file: &Path,
     votes_count_path: PathBuf,
     snapshot_path: PathBuf,
     registration_threshold: u64,
     vote_threshold: u64,
     total_rewards: u64,
 ) -> Result<()> {
-    let block = open_block_file(&block_file)?;
+    let block = open_block_file(&Some(block_file.to_path_buf()))?;
     let block = load_block(block)?;
 
     let block0 = Block0Configuration::from_block(&block)?;
@@ -109,6 +113,6 @@ pub fn voter_rewards(
     let actual_rewards = results.values().sum::<Rewards>();
     assert_are_close(actual_rewards, Rewards::from(total_rewards));
 
-    write_rewards_results(&block_file, &results)?;
+    write_rewards_results(&Some(block_file.to_path_buf()), &results)?;
     Ok(())
 }