set the treasury value and parameters

Author: NicolasDP

jormungandr-lib/src/interfaces/block0_configuration/DOCUMENTED_EXAMPLE.yaml

@@ -82,6 +82,27 @@ blockchain_configuration:
   # default value: {default_kes_update_speed}
   kes_update_speed: {default_kes_update_speed}
 
+  # initial value the treasury will start with, if not set the treasury
+  # starts at 0
+  treasury: 1000000000000
+
+  # set the treasury parameters, this is the tax type, just as in stake pool
+  # registration certificate parameters.
+  #
+  # When distributing the rewards, the treasury will be first serve as per
+  # the incentive specification document
+  #
+  # if not set, the treasury will not grow
+  treasury_parameters:
+    # the fix value the treasury will take from the total reward pot of the epoch
+    fixed: 1000
+    # the extra percentage the the treasury will take from the reward pot of the epoch
+    ratio: "1/10"
+    # It is possible to add a max bound to the total value the treasury takes
+    # at each reward distribution. For example, one could cap the treasury tax
+    # to 10000. Uncomment the following line to apply a max limit:
+    # max_limit: 10000
+
 # Initial state of the ledger. Each item is applied in order of this list
 initial:
   # Initial deposits present in the blockchain

jormungandr-lib/src/interfaces/block0_configuration/initial_config.rs

@@ -1,7 +1,7 @@
 use crate::{
     interfaces::{
         ActiveSlotCoefficient, BFTSlotsRatio, ConsensusLeaderId, KESUpdateSpeed, LinearFeeDef,
-        NumberOfSlotsPerEpoch, SlotDuration, Value,
+        NumberOfSlotsPerEpoch, SlotDuration, TaxType, Value,
     },
     time::SecondsSinceUnixEpoch,
 };
@@ -109,6 +109,11 @@ pub struct BlockchainConfiguration {
     #[serde(default)]
     pub treasury: Option<Value>,
 
+    /// set the treasure parameters, i.e. the first value the treasury will take from the
+    /// rewards pot and fees.
+    #[serde(default)]
+    pub treasury_parameters: Option<TaxType>,
+
     /// Set the value of the reward pot. if omitted then the reward pot is empty
     #[serde(default)]
     pub rewards: Option<Value>,
@@ -160,6 +165,7 @@ impl BlockchainConfiguration {
             max_number_of_transactions_per_block: None,
             epoch_stability_depth: None,
             treasury: None,
+            treasury_parameters: None,
             rewards: None,
         }
     }
@@ -182,6 +188,7 @@ impl BlockchainConfiguration {
         let mut linear_fees = None;
         let mut kes_update_speed = None;
         let mut treasury = None;
+        let mut treasury_parameters = None;
         let mut rewards = None;
         let mut per_certificate_fees = None;
 
@@ -234,7 +241,9 @@ impl BlockchainConfiguration {
                 ConfigParam::TreasuryAdd(param) => {
                     treasury.replace(param.into()).map(|_| "treasury")
                 }
-                ConfigParam::TreasuryParams(_) => unimplemented!(),
+                ConfigParam::TreasuryParams(param) => treasury_parameters
+                    .replace(param.into())
+                    .map(|_| "treasury_parameters"),
                 ConfigParam::RewardPot(param) => {
                     rewards.replace(param.into()).map(|_| "reward-pot")
                 }
@@ -270,6 +279,7 @@ impl BlockchainConfiguration {
             consensus_leader_ids,
             max_number_of_transactions_per_block,
             treasury,
+            treasury_parameters,
             rewards,
         })
     }
@@ -289,6 +299,7 @@ impl BlockchainConfiguration {
             max_number_of_transactions_per_block,
             epoch_stability_depth,
             treasury,
+            treasury_parameters,
             rewards,
         } = self;
 
@@ -320,6 +331,11 @@ impl BlockchainConfiguration {
         if let Some(treasury) = treasury {
             params.push(ConfigParam::TreasuryAdd(treasury.into()));
         }
+
+        if let Some(treasury_parameters) = treasury_parameters {
+            params.push(ConfigParam::TreasuryParams(treasury_parameters.into()));
+        }
+
         if let Some(rewards) = rewards {
             params.push(ConfigParam::RewardPot(rewards.into()));
         }
@@ -387,6 +403,7 @@ mod test {
                 max_number_of_transactions_per_block: Arbitrary::arbitrary(g),
                 epoch_stability_depth: Arbitrary::arbitrary(g),
                 treasury: Arbitrary::arbitrary(g),
+                treasury_parameters: Arbitrary::arbitrary(g),
                 rewards: Arbitrary::arbitrary(g),
             }
         }

jormungandr-lib/src/interfaces/mod.rs

@@ -12,6 +12,7 @@ mod old_address;
 mod ratio;
 mod settings;
 mod stats;
+mod tax_type;
 mod transaction_input;
 mod transaction_output;
 mod transaction_witness;
@@ -37,6 +38,7 @@ pub use self::old_address::OldAddress;
 pub use self::ratio::{ParseRatioError, Ratio};
 pub use self::settings::*;
 pub use self::stats::{NodeState, Stats};
+pub use self::tax_type::TaxType;
 pub use self::transaction_input::{TransactionInput, TransactionInputType};
 pub use self::transaction_output::TransactionOutput;
 pub use self::transaction_witness::TransactionWitness;

jormungandr-lib/src/interfaces/tax_type.rs

@@ -0,0 +1,107 @@
+use crate::interfaces::{Ratio, Value};
+use chain_impl_mockchain::rewards;
+use serde::{Deserialize, Serialize};
+use std::num::NonZeroU64;
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "snake_case")]
+pub struct TaxType {
+    pub fixed: Value,
+
+    pub ratio: Ratio,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_limit: Option<NonZeroU64>,
+}
+
+/* ************** Conversion *********************************** */
+
+impl From<TaxType> for rewards::TaxType {
+    fn from(tax_type: TaxType) -> Self {
+        rewards::TaxType {
+            fixed: tax_type.fixed.into(),
+            ratio: tax_type.ratio.into(),
+            max_limit: tax_type.max_limit,
+        }
+    }
+}
+
+impl From<rewards::TaxType> for TaxType {
+    fn from(tax_type: rewards::TaxType) -> Self {
+        TaxType {
+            fixed: tax_type.fixed.into(),
+            ratio: tax_type.ratio.into(),
+            max_limit: tax_type.max_limit,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use quickcheck::{Arbitrary, Gen, TestResult};
+    use std::num::NonZeroU64;
+
+    impl Arbitrary for TaxType {
+        fn arbitrary<G>(g: &mut G) -> Self
+        where
+            G: Gen,
+        {
+            TaxType {
+                fixed: Value::arbitrary(g),
+                ratio: Ratio::arbitrary(g),
+                max_limit: NonZeroU64::new(Arbitrary::arbitrary(g)),
+            }
+        }
+    }
+
+    #[test]
+    fn value_serde_yaml() {
+        const FIXED: u64 = 8170;
+        const NUMERATOR: u64 = 192;
+        const DENOMINATOR: NonZeroU64 = unsafe { NonZeroU64::new_unchecked(1291) };
+        let tax_type = TaxType {
+            fixed: FIXED.into(),
+            ratio: Ratio::new(NUMERATOR, DENOMINATOR),
+            max_limit: None,
+        };
+
+        assert_eq!(
+            serde_yaml::to_string(&tax_type).unwrap(),
+            format!(
+                "---\nfixed: {}\nratio: {}/{}",
+                FIXED, NUMERATOR, DENOMINATOR
+            )
+        );
+    }
+
+    #[test]
+    fn value_serde_yaml_with_max_limit() {
+        const FIXED: u64 = 8170;
+        const NUMERATOR: u64 = 192;
+        const DENOMINATOR: NonZeroU64 = unsafe { NonZeroU64::new_unchecked(1291) };
+        const MAX_LIMIT: u64 = 2028;
+        let tax_type = TaxType {
+            fixed: FIXED.into(),
+            ratio: Ratio::new(NUMERATOR, DENOMINATOR),
+            max_limit: NonZeroU64::new(MAX_LIMIT),
+        };
+
+        assert_eq!(
+            serde_yaml::to_string(&tax_type).unwrap(),
+            format!(
+                "---\nfixed: {}\nratio: {}/{}\nmax_limit: {}",
+                FIXED, NUMERATOR, DENOMINATOR, MAX_LIMIT
+            )
+        );
+    }
+
+    quickcheck! {
+        fn value_serde_human_readable_encode_decode(value: TaxType) -> TestResult {
+            let s = serde_yaml::to_string(&value).unwrap();
+            let value_dec: TaxType = serde_yaml::from_str(&s).unwrap();
+
+            TestResult::from_bool(value_dec == value)
+        }
+    }
+}