Chain-Config update logic

chain-config/src/lib.rs

@@ -1,8 +1,7 @@
 #![no_std]
 
 use multiversx_sc_modules::only_admin;
-use transaction::StakeMultiArg;
-use validator_rules::TokenIdAmountPair;
+use transaction::{SovereignConfig, StakeArgs};
 
 multiversx_sc::imports!();
 
@@ -19,54 +18,35 @@ pub trait ChainConfigContract:
         max_validators: u64,
         min_stake: BigUint,
         admin: ManagedAddress,
-        additional_stake_required: MultiValueEncoded<StakeMultiArg<Self::Api>>,
+        additional_stake_required: MultiValueEncoded<StakeArgs<Self::Api>>,
     ) {
         require!(
             min_validators <= max_validators,
             "Invalid min/max validator numbers"
         );
 
-        let mut additional_stake_vec = ManagedVec::new();
-        for multi_value in additional_stake_required {
-            let (token_id, amount) = multi_value.into_tuple();
-            let value = TokenIdAmountPair { token_id, amount };
-
-            additional_stake_vec.push(value);
-        }
-
         self.min_validators().set(min_validators);
         self.max_validators().set(max_validators);
         self.min_stake().set(min_stake);
         self.add_admin(admin);
-        self.additional_stake_required().set(additional_stake_vec);
+        self.additional_stake_required()
+            .extend(additional_stake_required);
     }
 
     #[only_admin]
-    fn update_config(
-        &self,
-        opt_min_validators: Option<u64>,
-        opt_max_validators: Option<u64>,
-        opt_min_stake: Option<BigUint>,
-        opt_additional_stake_required: Option<MultiValueEncoded<StakeMultiArg<Self::Api>>>,
-    ) {
-        if let Some(min_validators) = opt_min_validators {
+    fn update_config(&self, new_config: SovereignConfig<Self::Api>) {
+        if let Some(min_validators) = new_config.opt_min_validators {
             self.min_validators().set(min_validators);
         }
-        if let Some(max_validators) = opt_max_validators {
+        if let Some(max_validators) = new_config.opt_max_validators {
             self.max_validators().set(max_validators);
         }
-        if let Some(min_stake) = opt_min_stake {
+        if let Some(min_stake) = new_config.opt_min_stake {
             self.min_stake().set(min_stake);
         }
-        if let Some(additional_stake_required) = opt_additional_stake_required {
-            let mut additional_stake_vec = ManagedVec::new();
-            for multi_value in additional_stake_required {
-                let (token_id, amount) = multi_value.into_tuple();
-                let value = TokenIdAmountPair { token_id, amount };
-
-                additional_stake_vec.push(value);
-            }
-            self.additional_stake_required().set(additional_stake_vec);
+        if let Some(additional_stake_required) = new_config.opt_additional_stake_required {
+            self.additional_stake_required()
+                .extend(&additional_stake_required);
         }
     }
 

chain-config/src/validator_rules.rs

@@ -1,3 +1,5 @@
+use transaction::StakeArgs;
+
 multiversx_sc::imports!();
 multiversx_sc::derive_imports!();
 
@@ -49,9 +51,7 @@ pub trait ValidatorRulesModule {
     // TODO: Read user stake and verify
     #[view(getAdditionalStakeRequired)]
     #[storage_mapper("additionalStakeRequired")]
-    fn additional_stake_required(
-        &self,
-    ) -> SingleValueMapper<ManagedVec<TokenIdAmountPair<Self::Api>>>;
+    fn additional_stake_required(&self) -> UnorderedSetMapper<StakeArgs<Self::Api>>;
 
     #[view(wasPreviouslySlashed)]
     #[storage_mapper("wasPreviouslySlashed")]

chain-factory/src/factory.rs

@@ -7,7 +7,7 @@ use proxies::{
     fee_market_proxy::{FeeMarketProxy, FeeStruct},
     header_verifier_proxy::HeaderverifierProxy,
 };
-use transaction::StakeMultiArg;
+use transaction::StakeArgs;
 multiversx_sc::derive_imports!();
 
 #[multiversx_sc::module]
@@ -19,7 +19,7 @@ pub trait FactoryModule: only_admin::OnlyAdminModule {
         min_validators: u64,
         max_validators: u64,
         min_stake: BigUint,
-        additional_stake_required: MultiValueEncoded<StakeMultiArg<Self::Api>>,
+        additional_stake_required: MultiValueEncoded<StakeArgs<Self::Api>>,
     ) -> ManagedAddress {
         let caller = self.blockchain().get_caller();
         let source_address = self.chain_config_template().get();

chain-factory/tests/chain_factory_tests.rs

@@ -9,7 +9,7 @@ use multiversx_sc_scenario::{
 use proxies::{
     chain_config_proxy::ChainConfigContractProxy, chain_factory_proxy::ChainFactoryContractProxy,
 };
-use transaction::StakeMultiArg;
+use transaction::StakeArgs;
 
 const FACTORY_ADDRESS: TestSCAddress = TestSCAddress::new("chain-factory");
 const CODE_PATH: MxscPath = MxscPath::new("output/chain-factory.mxsc.json");
@@ -38,9 +38,7 @@ struct ChainFactoryTestState {
 }
 
 impl ChainFactoryTestState {
-    fn new(
-        additional_stake_required: &MultiValueEncoded<StaticApi, StakeMultiArg<StaticApi>>,
-    ) -> Self {
+    fn new(additional_stake_required: &MultiValueEncoded<StaticApi, StakeArgs<StaticApi>>) -> Self {
         let mut world = world();
 
         world.account(OWNER).balance(OWNER_BALANCE).nonce(1);
@@ -87,7 +85,7 @@ impl ChainFactoryTestState {
         min_validators: usize,
         max_validators: usize,
         min_stake: BigUint<StaticApi>,
-        additional_stake_required: MultiValueEncoded<StaticApi, StakeMultiArg<StaticApi>>,
+        additional_stake_required: MultiValueEncoded<StaticApi, StakeArgs<StaticApi>>,
         expected_result: Option<ExpectError<'_>>,
     ) {
         let transaction = self
@@ -114,8 +112,8 @@ impl ChainFactoryTestState {
 
 #[test]
 fn deploy() {
-    let additional_stake: StakeMultiArg<StaticApi> =
-        (TokenIdentifier::from("TEST-TOKEN"), BigUint::from(100u64)).into();
+    let additional_stake =
+        StakeArgs::new(TokenIdentifier::from("TEST-TOKEN"), BigUint::from(100u64));
     let mut additional_stake_required = MultiValueEncoded::new();
     additional_stake_required.push(additional_stake);
 
@@ -125,8 +123,8 @@ fn deploy() {
 
 #[test]
 fn deploy_chain_config_from_factory() {
-    let additional_stake: StakeMultiArg<StaticApi> =
-        (TokenIdentifier::from("TEST-TOKEN"), BigUint::from(100u64)).into();
+    let additional_stake =
+        StakeArgs::new(TokenIdentifier::from("TEST-TOKEN"), BigUint::from(100u64));
     let mut additional_stake_required = MultiValueEncoded::new();
     additional_stake_required.push(additional_stake);
 

common/proxies/src/chain_config_proxy.rs

@@ -48,7 +48,7 @@ where
         Arg1: ProxyArg<u64>,
         Arg2: ProxyArg<BigUint<Env::Api>>,
         Arg3: ProxyArg<ManagedAddress<Env::Api>>,
-        Arg4: ProxyArg<MultiValueEncoded<Env::Api, MultiValue2<TokenIdentifier<Env::Api>, BigUint<Env::Api>>>>,
+        Arg4: ProxyArg<MultiValueEncoded<Env::Api, transaction::StakeArgs<Env::Api>>>,
     >(
         self,
         min_validators: Arg0,
@@ -126,7 +126,7 @@ where
 
     pub fn additional_stake_required(
         self,
-    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ManagedVec<Env::Api, TokenIdAmountPair<Env::Api>>> {
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValueEncoded<Env::Api, transaction::StakeArgs<Env::Api>>> {
         self.wrapped_tx
             .payment(NotPayable)
             .raw_call("getAdditionalStakeRequired")
@@ -194,13 +194,3 @@ where
             .original_result()
     }
 }
-
-#[type_abi]
-#[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, ManagedVecItem)]
-pub struct TokenIdAmountPair<Api>
-where
-    Api: ManagedTypeApi,
-{
-    pub token_id: TokenIdentifier<Api>,
-    pub amount: BigUint<Api>,
-}

common/proxies/src/chain_factory_proxy.rs

@@ -101,7 +101,7 @@ where
         Arg0: ProxyArg<u64>,
         Arg1: ProxyArg<u64>,
         Arg2: ProxyArg<BigUint<Env::Api>>,
-        Arg3: ProxyArg<MultiValueEncoded<Env::Api, MultiValue2<TokenIdentifier<Env::Api>, BigUint<Env::Api>>>>,
+        Arg3: ProxyArg<MultiValueEncoded<Env::Api, transaction::StakeArgs<Env::Api>>>,
     >(
         self,
         min_validators: Arg0,

common/proxies/src/sovereign_forge_proxy.rs

@@ -130,7 +130,7 @@ where
         Arg0: ProxyArg<u64>,
         Arg1: ProxyArg<u64>,
         Arg2: ProxyArg<BigUint<Env::Api>>,
-        Arg3: ProxyArg<MultiValueEncoded<Env::Api, MultiValue2<TokenIdentifier<Env::Api>, BigUint<Env::Api>>>>,
+        Arg3: ProxyArg<MultiValueEncoded<Env::Api, transaction::StakeArgs<Env::Api>>>,
     >(
         self,
         min_validators: Arg0,

common/transaction/src/lib.rs

@@ -32,7 +32,35 @@ pub type ExtractedFeeResult<M> =
     MultiValue2<OptionalValue<EsdtTokenPayment<M>>, ManagedVec<M, EsdtTokenPayment<M>>>;
 pub type OptionalValueTransferDataTuple<M> =
     OptionalValue<MultiValue3<GasLimit, ManagedBuffer<M>, ManagedVec<M, ManagedBuffer<M>>>>;
-pub type StakeMultiArg<M> = MultiValue2<TokenIdentifier<M>, BigUint<M>>;
+
+#[type_abi]
+#[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, ManagedVecItem, Clone)]
+pub struct StakeArgs<M: ManagedTypeApi> {
+    pub token_id: TokenIdentifier<M>,
+    pub amount: BigUint<M>,
+}
+
+impl<M: ManagedTypeApi> StakeArgs<M> {
+    pub fn new(token_id: TokenIdentifier<M>, amount: BigUint<M>) -> Self {
+        StakeArgs { token_id, amount }
+    }
+
+    pub fn get_default() -> Self {
+        StakeArgs {
+            token_id: TokenIdentifier::from(""),
+            amount: BigUint::default(),
+        }
+    }
+}
+
+#[type_abi]
+#[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, ManagedVecItem, Clone)]
+pub struct SovereignConfig<M: ManagedTypeApi> {
+    pub opt_min_validators: Option<u64>,
+    pub opt_max_validators: Option<u64>,
+    pub opt_min_stake: Option<BigUint<M>>,
+    pub opt_additional_stake_required: Option<ManagedVec<M, StakeArgs<M>>>,
+}
 
 #[type_abi]
 #[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, ManagedVecItem, Clone)]

sovereign-forge/interactor/Cargo.toml

@@ -21,6 +21,9 @@ version = "0.54.5"
 [dependencies.multiversx-sc]
 version = "0.54.5"
 
+[dependencies.transaction]
+path = "../../common/transaction"
+
 [dependencies.proxies]
 path = "../../common/proxies"
 

sovereign-forge/interactor/src/interact.rs

@@ -17,6 +17,7 @@ use std::{
     io::{Read, Write},
     path::Path,
 };
+use transaction::StakeArgs;
 
 const STATE_FILE: &str = "state.toml";
 const CHAIN_CONFIG_CODE_PATH: &str = "../../chain-config/output/chain-config.mxsc.json";
@@ -400,13 +401,7 @@ impl ContractInteract {
         let min_validators = 1u64;
         let max_validators = 3u64;
         let min_stake = BigUint::<StaticApi>::from(0u128);
-        let additional_stake_required = MultiValueVec::from(vec![MultiValue2::<
-            TokenIdentifier<StaticApi>,
-            BigUint<StaticApi>,
-        >::from((
-            TokenIdentifier::from_esdt_bytes(&b""[..]),
-            BigUint::<StaticApi>::from(0u128),
-        ))]);
+        let additional_stake_required = MultiValueVec::from(vec![StakeArgs::get_default()]);
 
         let response = self
             .interactor

sovereign-forge/src/common/sc_deploy.rs

@@ -1,7 +1,7 @@
 use crate::err_msg;
 use multiversx_sc::types::{MultiValueEncoded, ReturnsResult};
 use proxies::{chain_factory_proxy::ChainFactoryContractProxy, fee_market_proxy::FeeStruct};
-use transaction::StakeMultiArg;
+use transaction::StakeArgs;
 
 #[multiversx_sc::module]
 pub trait ScDeployModule: super::utils::UtilsModule + super::storage::StorageModule {
@@ -11,7 +11,7 @@ pub trait ScDeployModule: super::utils::UtilsModule + super::storage::StorageMod
         min_validators: u64,
         max_validators: u64,
         min_stake: BigUint,
-        additional_stake_required: MultiValueEncoded<StakeMultiArg<Self::Api>>,
+        additional_stake_required: MultiValueEncoded<StakeArgs<Self::Api>>,
     ) -> ManagedAddress {
         self.tx()
             .to(self.get_chain_factory_address())

sovereign-forge/src/phases.rs

@@ -1,9 +1,9 @@
 use crate::err_msg;
 use core::ops::Deref;
 use proxies::fee_market_proxy::FeeStruct;
-use transaction::StakeMultiArg;
 
 use multiversx_sc::{require, types::MultiValueEncoded};
+use transaction::StakeArgs;
 
 use crate::common::{
     self,
@@ -49,7 +49,7 @@ pub trait PhasesModule:
         min_validators: u64,
         max_validators: u64,
         min_stake: BigUint,
-        additional_stake_required: MultiValueEncoded<StakeMultiArg<Self::Api>>,
+        additional_stake_required: MultiValueEncoded<StakeArgs<Self::Api>>,
     ) {
         self.require_setup_complete();
 

sovereign-forge/tests/sovereign_forge_unit_tests.rs

@@ -16,7 +16,7 @@ use sovereign_forge::common::{
     storage::StorageModule,
     utils::{ScArray, UtilsModule},
 };
-use transaction::StakeMultiArg;
+use transaction::StakeArgs;
 
 const FORGE_ADDRESS: TestSCAddress = TestSCAddress::new("sovereign-forge");
 const FORGE_CODE_PATH: MxscPath = MxscPath::new("output/sovereign-forge.mxsc.json");
@@ -244,7 +244,7 @@ impl SovereignForgeTestState {
         min_validators: u64,
         max_validators: u64,
         min_stake: BigUint<StaticApi>,
-        additional_stake_required: MultiValueEncoded<StaticApi, StakeMultiArg<StaticApi>>,
+        additional_stake_required: MultiValueEncoded<StaticApi, StakeArgs<StaticApi>>,
         expected_result: Option<ExpectError>,
     ) {
         let transaction = self