Single node rest settings test (#3962)

* Added first test for setting rest api

* did some cleaning up

* adding test to settings rest api

* adding setter functions for reward_parameters and treasury_parameters

* adding more parameters to test_custom_settings and did some cleanup

* fixing errors after PR

* fixing newline errors after PR

* adding extensions for Block0Configuration and BlockchainConfiguration

* fixing trailing spaces

* fixing clippy errors

Author: kukkok3

jormungandr-lib/src/interfaces/reward_parameters.rs

@@ -3,7 +3,7 @@ use chain_impl_mockchain::{block::Epoch, config::RewardParams as RewardParamsStd
 use serde::{Deserialize, Serialize};
 use std::num::NonZeroU32;
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Copy)]
 #[serde(deny_unknown_fields, rename_all = "snake_case")]
 pub enum RewardParams {
     Linear {

jormungandr-lib/src/interfaces/tax_type.rs

@@ -3,7 +3,7 @@ use chain_impl_mockchain::rewards;
 use serde::{Deserialize, Serialize};
 use std::num::NonZeroU64;
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Copy)]
 #[serde(deny_unknown_fields, rename_all = "snake_case")]
 pub struct TaxType {
     pub fixed: Value,

testing/jormungandr-automation/src/jormungandr/configuration/block0_config_builder.rs

@@ -16,7 +16,7 @@ use rand::SeedableRng;
 use rand_chacha::ChaChaRng;
 use serde_derive::{Deserialize, Serialize};
 
-use std::num::NonZeroU32;
+use std::num::{NonZeroU32, NonZeroU64};
 use std::vec::Vec;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -56,7 +56,7 @@ impl Block0ConfigurationBuilder {
                 treasury_parameters: Some(TaxType {
                     fixed: 10.into(),
                     ratio: Ratio::new_checked(1, 1_000).unwrap(),
-                    max_limit: None,
+                    max_limit: NonZeroU64::new(123),
                 }),
                 total_reward_supply: Some(1_000_000_000.into()),
                 reward_parameters: Some(RewardParams::Linear {
@@ -93,18 +93,22 @@ impl Block0ConfigurationBuilder {
         self.blockchain_configuration.consensus_leader_ids = leaders_ids;
         self
     }
+
     pub fn with_block0_consensus(&mut self, block0_consensus: ConsensusVersion) -> &mut Self {
         self.blockchain_configuration.block0_consensus = block0_consensus;
         self
     }
+
     pub fn with_kes_update_speed(&mut self, kes_update_speed: KesUpdateSpeed) -> &mut Self {
         self.blockchain_configuration.kes_update_speed = kes_update_speed;
         self
     }
+
     pub fn with_slots_per_epoch(&mut self, slots_per_epoch: NumberOfSlotsPerEpoch) -> &mut Self {
         self.blockchain_configuration.slots_per_epoch = slots_per_epoch;
         self
     }
+
     pub fn with_slot_duration(&mut self, slot_duration: SlotDuration) -> &mut Self {
         self.blockchain_configuration.slot_duration = slot_duration;
         self
@@ -122,6 +126,7 @@ impl Block0ConfigurationBuilder {
         self.blockchain_configuration.epoch_stability_depth = epoch_stability_depth;
         self
     }
+
     pub fn with_active_slot_coeff(
         &mut self,
         consensus_genesis_praos_active_slot_coeff: ActiveSlotCoefficient,
@@ -136,6 +141,11 @@ impl Block0ConfigurationBuilder {
         self
     }
 
+    pub fn with_reward_parameters(&mut self, reward_parameters: Option<RewardParams>) -> &mut Self {
+        self.blockchain_configuration.reward_parameters = reward_parameters;
+        self
+    }
+
     pub fn with_total_rewards_supply(&mut self, total_reward_supply: Option<Value>) -> &mut Self {
         self.blockchain_configuration.total_reward_supply = total_reward_supply;
         self
@@ -174,6 +184,11 @@ impl Block0ConfigurationBuilder {
         self
     }
 
+    pub fn with_treasury_parameters(&mut self, treasury_parameters: Option<TaxType>) -> &mut Self {
+        self.blockchain_configuration.treasury_parameters = treasury_parameters;
+        self
+    }
+
     pub fn with_tx_max_expiry_epochs(&mut self, tx_max_expiry_epochs: u8) -> &mut Self {
         self.blockchain_configuration.tx_max_expiry_epochs = Some(tx_max_expiry_epochs);
         self

testing/jormungandr-automation/src/jormungandr/configuration/configuration_builder.rs

@@ -13,6 +13,8 @@ use jormungandr_lib::interfaces::Block0Configuration;
 use jormungandr_lib::interfaces::BlockContentMaxSize;
 use jormungandr_lib::interfaces::InitialToken;
 use jormungandr_lib::interfaces::ProposalExpiration;
+use jormungandr_lib::interfaces::RewardParams;
+use jormungandr_lib::interfaces::TaxType;
 use jormungandr_lib::interfaces::{
     ActiveSlotCoefficient, CommitteeIdDef, ConsensusLeaderId, Cors, EpochStabilityDepth, FeesGoTo,
     Initial, InitialUTxO, KesUpdateSpeed, Log, LogEntry, LogOutput, Mempool, NodeConfig,
@@ -39,7 +41,9 @@ pub struct ConfigurationBuilder {
     secret: Option<NodeSecret>,
     fees_go_to: Option<FeesGoTo>,
     total_reward_supply: Option<Value>,
+    reward_parameters: Option<RewardParams>,
     treasury: Option<Value>,
+    treasury_parameters: Option<TaxType>,
     node_config_builder: NodeConfigBuilder,
     rewards_history: bool,
     configure_default_log: bool,
@@ -82,7 +86,9 @@ impl ConfigurationBuilder {
             proposal_expiry_epochs: Default::default(),
             fees_go_to: None,
             treasury: None,
+            treasury_parameters: None,
             total_reward_supply: None,
+            reward_parameters: None,
             discrimination: Discrimination::Test,
             block_content_max_size: 4092.into(),
             tx_max_expiry_epochs: None,
@@ -294,6 +300,16 @@ impl ConfigurationBuilder {
         self
     }
 
+    pub fn with_treasury_parameters(&mut self, treasury_parameters: TaxType) -> &mut Self {
+        self.treasury_parameters = Some(treasury_parameters);
+        self
+    }
+
+    pub fn with_reward_parameters(&mut self, reward_parameters: RewardParams) -> &mut Self {
+        self.reward_parameters = Some(reward_parameters);
+        self
+    }
+
     pub fn with_total_rewards_supply(&mut self, total_reward_supply: Value) -> &mut Self {
         self.total_reward_supply = Some(total_reward_supply);
         self
@@ -326,6 +342,18 @@ impl ConfigurationBuilder {
                 .to_owned();
         }
 
+        if let Some(treasury_parameters) = self.treasury_parameters {
+            block0_config_builder = block0_config_builder
+                .with_treasury_parameters(Some(treasury_parameters))
+                .to_owned();
+        }
+
+        if let Some(reward_parameters) = self.reward_parameters {
+            block0_config_builder = block0_config_builder
+                .with_reward_parameters(Some(reward_parameters))
+                .to_owned();
+        }
+
         block0_config_builder
             .with_discrimination(self.discrimination)
             .with_initial(initial)

testing/jormungandr-automation/src/testing/block0.rs

@@ -1,13 +1,14 @@
+use super::blockchain_config::BlockchainConfigurationExtension;
 use chain_core::{
     packer::Codec,
     property::{Deserialize, DeserializeFromSlice, ReadError, Serialize, WriteError},
 };
 use chain_impl_mockchain::block::Block;
 use chain_impl_mockchain::certificate::VotePlan;
 use chain_impl_mockchain::ledger::Ledger;
-use jormungandr_lib::interfaces::Block0Configuration;
-use jormungandr_lib::interfaces::Block0ConfigurationError;
 use jormungandr_lib::interfaces::Initial;
+use jormungandr_lib::interfaces::{Block0Configuration, SettingsDto};
+use jormungandr_lib::{interfaces::Block0ConfigurationError, time::SystemTime};
 use std::io::BufReader;
 use std::path::Path;
 use thiserror::Error;
@@ -38,6 +39,7 @@ pub fn get_block<S: Into<String>>(block0: S) -> Result<Block0Configuration, Bloc
 
 pub trait Block0ConfigurationExtension {
     fn vote_plans(&self) -> Vec<VotePlan>;
+    fn settings(&self) -> SettingsDto;
 }
 
 impl Block0ConfigurationExtension for Block0Configuration {
@@ -54,6 +56,25 @@ impl Block0ConfigurationExtension for Block0Configuration {
         }
         vote_plans
     }
+
+    fn settings(&self) -> SettingsDto {
+        let blockchain_configuration = &self.blockchain_configuration;
+        SettingsDto {
+            block0_hash: self.to_block().header().id().to_string(),
+            block0_time: blockchain_configuration.block0_date.into(),
+            curr_slot_start_time: Some(SystemTime::from(blockchain_configuration.block0_date)),
+            consensus_version: blockchain_configuration.block0_consensus.to_string(),
+            fees: blockchain_configuration.linear_fees,
+            block_content_max_size: blockchain_configuration.block_content_max_size.into(),
+            epoch_stability_depth: blockchain_configuration.epoch_stability_depth.into(),
+            slot_duration: u8::from(blockchain_configuration.slot_duration).into(),
+            slots_per_epoch: blockchain_configuration.slots_per_epoch.into(),
+            treasury_tax: blockchain_configuration.treasury_parameters.unwrap().into(),
+            reward_params: blockchain_configuration.reward_parameters().unwrap(),
+            discrimination: blockchain_configuration.discrimination,
+            tx_max_expiry_epochs: blockchain_configuration.tx_max_expiry_epochs.unwrap(),
+        }
+    }
 }
 
 pub fn read_genesis_yaml<P: AsRef<Path>>(genesis: P) -> Result<Block0Configuration, Block0Error> {

testing/jormungandr-automation/src/testing/blockchain_config.rs

@@ -0,0 +1,56 @@
+use chain_impl_mockchain::rewards::{CompoundingType, Limit, Parameters};
+use jormungandr_lib::interfaces::{BlockchainConfiguration, RewardParams};
+
+pub trait BlockchainConfigurationExtension {
+    fn reward_parameters(&self) -> Option<Parameters>;
+}
+
+impl BlockchainConfigurationExtension for BlockchainConfiguration {
+    fn reward_parameters(&self) -> Option<Parameters> {
+        let reward_param = match self.reward_parameters {
+            None => return None,
+            Some(r) => r,
+        };
+
+        let reward_drawing = match self.reward_constraints.reward_drawing_limit_max {
+            None => Limit::None,
+            Some(r) => Limit::ByStakeAbsolute(r.into()),
+        };
+
+        let pool_participation = self
+            .reward_constraints
+            .pool_participation_capping
+            .map(|p| (p.min, p.max));
+
+        match reward_param {
+            RewardParams::Linear {
+                constant,
+                ratio,
+                epoch_start,
+                epoch_rate,
+            } => Some(Parameters {
+                initial_value: constant,
+                compounding_ratio: ratio.into(),
+                compounding_type: CompoundingType::Linear,
+                epoch_rate,
+                epoch_start,
+                reward_drawing_limit_max: reward_drawing,
+                pool_participation_capping: pool_participation,
+            }),
+            RewardParams::Halving {
+                constant,
+                ratio,
+                epoch_start,
+                epoch_rate,
+            } => Some(Parameters {
+                initial_value: constant,
+                compounding_ratio: ratio.into(),
+                compounding_type: CompoundingType::Halvening,
+                epoch_rate,
+                epoch_start,
+                reward_drawing_limit_max: reward_drawing,
+                pool_participation_capping: pool_participation,
+            }),
+        }
+    }
+}

testing/jormungandr-automation/src/testing/mod.rs

@@ -1,6 +1,7 @@
 pub mod asserts;
 pub mod benchmark;
 pub mod block0;
+pub mod blockchain_config;
 pub mod collector;
 pub mod configuration;
 pub mod keys;

testing/jormungandr-integration-tests/src/jormungandr/rest/v1/mod.rs

@@ -1,2 +1,3 @@
 pub mod fragments;
+pub mod utils;
 pub mod votes;

testing/jormungandr-integration-tests/src/jormungandr/rest/v1/utils/mod.rs

@@ -0,0 +1 @@
+pub mod settings;

testing/jormungandr-integration-tests/src/jormungandr/rest/v1/utils/settings.rs

@@ -0,0 +1,67 @@
+use crate::startup;
+use chain_impl_mockchain::fee::{LinearFee, PerCertificateFee, PerVoteCertificateFee};
+use jormungandr_automation::jormungandr::ConfigurationBuilder;
+use jormungandr_automation::testing::block0::Block0ConfigurationExtension;
+use jormungandr_lib::interfaces::RewardParams;
+use jormungandr_lib::interfaces::{Ratio, TaxType};
+use std::num::{NonZeroU32, NonZeroU64};
+
+#[test]
+pub fn test_default_settings() {
+    let alice = thor::Wallet::default();
+    let bob = thor::Wallet::default();
+    let (jormungandr, _stake_pools) =
+        startup::start_stake_pool(&[alice], &[bob], &mut ConfigurationBuilder::new()).unwrap();
+
+    let rest_settings = jormungandr.rest().settings().expect("Rest settings error");
+    let block0_settings = jormungandr.block0_configuration().settings();
+    assert_eq!(rest_settings, block0_settings);
+}
+
+#[test]
+pub fn test_custom_settings() {
+    let alice = thor::Wallet::default();
+
+    let mut linear_fees = LinearFee::new(1, 2, 1);
+    linear_fees.per_certificate_fees(PerCertificateFee::new(
+        NonZeroU64::new(2),
+        NonZeroU64::new(3),
+        NonZeroU64::new(1),
+    ));
+
+    linear_fees.per_vote_certificate_fees(PerVoteCertificateFee::new(
+        NonZeroU64::new(3),
+        NonZeroU64::new(3),
+    ));
+
+    let treasury_parameters = TaxType {
+        fixed: 200.into(),
+        ratio: Ratio::new_checked(10, 500).unwrap(),
+        max_limit: NonZeroU64::new(200),
+    };
+
+    let reward_parameters = RewardParams::Linear {
+        constant: 500_000,
+        ratio: Ratio::new_checked(5, 2_00).unwrap(),
+        epoch_start: 2,
+        epoch_rate: NonZeroU32::new(4).unwrap(),
+    };
+
+    let jormungandr = startup::start_bft(
+        vec![&alice],
+        ConfigurationBuilder::new()
+            .with_linear_fees(linear_fees)
+            .with_block_content_max_size(2000.into())
+            .with_epoch_stability_depth(2000)
+            .with_slot_duration(1)
+            .with_slots_per_epoch(6)
+            .with_treasury_parameters(treasury_parameters)
+            .with_reward_parameters(reward_parameters)
+            .with_tx_max_expiry_epochs(50),
+    )
+    .unwrap();
+
+    let rest_settings = jormungandr.rest().settings().unwrap();
+    let block0_settings = jormungandr.block0_configuration().settings();
+    assert_eq!(rest_settings, block0_settings);
+}