Merge pull request #2115 from multiversx/governance-interactor

Governance interactor

Author: BiancaIalangi

Cargo.lock

@@ -25,6 +25,7 @@ members = [
   # "tools/plotter",
   "tools/interactor-system-func-calls/",
   "tools/interactor-delegation-func-calls/",
+  "tools/interactor-governance-func-calls/",
   "tools/gas-schedule-generator",
 
   "contracts/modules",

Cargo.toml

@@ -16,18 +16,18 @@ pub async fn payable_features_cli() {
 
     let config = Config::load_config();
 
-    let mut basic_interact = PayableInteract::new(config).await;
+    let mut payable_interact = PayableInteract::new(config).await;
 
     let cli = payable_interactor_cli::InteractCli::parse();
     match &cli.command {
         Some(payable_interactor_cli::InteractCliCommand::Deploy) => {
-            basic_interact.deploy().await;
+            payable_interact.deploy().await;
         }
         Some(payable_interactor_cli::InteractCliCommand::AllTransfers) => {
-            basic_interact.check_all_transfers().await;
+            payable_interact.check_all_transfers().await;
         }
         Some(payable_interactor_cli::InteractCliCommand::MultiTransferWithOneEGLD) => {
-            basic_interact
+            payable_interact
                 .check_multi_transfer_only_egld_transfer()
                 .await;
         }
@@ -48,6 +48,9 @@ impl PayableInteract {
             .await
             .use_chain_simulator(config.use_chain_simulator());
 
+        interactor
+            .set_current_dir_from_workspace("contracts/feature-tests/payable-features/interactor");
+
         let sc_owner_address = interactor.register_wallet(test_wallets::heidi()).await;
         let wallet_address = interactor.register_wallet(test_wallets::ivan()).await;
 
@@ -70,6 +73,7 @@ impl PayableInteract {
             .typed(payable_features_proxy::PayableFeaturesProxy)
             .init()
             .code(CODE_PATH)
+            .code_metadata(CodeMetadata::UPGRADEABLE)
             .returns(ReturnsNewBech32Address)
             .run()
             .await;

contracts/feature-tests/payable-features/interactor/src/payable_interactor.rs

@@ -92,6 +92,19 @@ where
     }
 }
 
+impl<Env> AnnotatedValue<Env, BigUint<Env::Api>> for u128
+where
+    Env: TxEnv,
+{
+    fn annotation(&self, _env: &Env) -> ManagedBuffer<Env::Api> {
+        BigUint::from(*self).to_display()
+    }
+
+    fn to_value(&self, _env: &Env) -> BigUint<Env::Api> {
+        BigUint::from(*self)
+    }
+}
+
 impl<Env> AnnotatedValue<Env, BigUint<Env::Api>> for i32
 where
     Env: TxEnv,

framework/base/src/types/interaction/annotated/annotated_impl_big_uint.rs

@@ -5,6 +5,7 @@ mod governance_sc_address;
 mod system_sc_address;
 mod to_caller;
 mod to_self;
+mod validator_sc_address;
 
 pub use delegation_manager_address::DelegationManagerSCAddress;
 pub use esdt_system_sc_address::ESDTSystemSCAddress;
@@ -13,3 +14,4 @@ pub use governance_sc_address::GovernanceSystemSCAddress;
 pub use system_sc_address::SystemSCAddress;
 pub use to_caller::ToCaller;
 pub use to_self::ToSelf;
+pub use validator_sc_address::ValidatorSystemSCAddress;

framework/base/src/types/interaction/markers.rs

@@ -0,0 +1,75 @@
+use hex_literal::hex;
+use multiversx_chain_core::types::Address;
+use multiversx_sc_codec::{EncodeErrorHandler, TopEncode, TopEncodeOutput};
+
+use crate::{
+    abi::TypeAbiFrom,
+    api::ManagedTypeApi,
+    types::{AnnotatedValue, ManagedAddress, ManagedBuffer, TxEnv, TxTo, TxToSpecified},
+};
+
+/// Address of the validator system smart contract.
+const VALIDATOR_SC_ADDRESS_BYTES: [u8; 32] =
+    hex!("000000000000000000010000000000000000000000000000000000000001ffff");
+const VALIDATOR_SC_ADDRESS_BECH32: &str =
+    "erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqplllst77y4l";
+const VALIDATOR_SC_ADDRESS_ANNOTATION: &str =
+    "bech32:erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqplllst77y4l";
+
+/// Indicates the system SC address, which is the same on any MultiversX blockchain.
+pub struct ValidatorSystemSCAddress;
+
+impl ValidatorSystemSCAddress {
+    pub fn to_managed_address<Api>(self) -> ManagedAddress<Api>
+    where
+        Api: ManagedTypeApi,
+    {
+        ManagedAddress::from(VALIDATOR_SC_ADDRESS_BYTES)
+    }
+
+    pub fn to_address(&self) -> Address {
+        VALIDATOR_SC_ADDRESS_BYTES.into()
+    }
+
+    pub fn to_bech32_str(&self) -> &str {
+        VALIDATOR_SC_ADDRESS_BECH32
+    }
+
+    pub fn to_bech32_string(&self) -> alloc::string::String {
+        VALIDATOR_SC_ADDRESS_BECH32.into()
+    }
+}
+
+impl<Env> AnnotatedValue<Env, ManagedAddress<Env::Api>> for ValidatorSystemSCAddress
+where
+    Env: TxEnv,
+{
+    fn annotation(&self, _env: &Env) -> ManagedBuffer<Env::Api> {
+        ManagedBuffer::from(VALIDATOR_SC_ADDRESS_ANNOTATION)
+    }
+
+    fn to_value(&self, _env: &Env) -> ManagedAddress<Env::Api> {
+        ValidatorSystemSCAddress.to_managed_address()
+    }
+}
+
+impl<Env> TxTo<Env> for ValidatorSystemSCAddress where Env: TxEnv {}
+impl<Env> TxToSpecified<Env> for ValidatorSystemSCAddress where Env: TxEnv {}
+
+impl TopEncode for ValidatorSystemSCAddress {
+    fn top_encode_or_handle_err<O, H>(&self, output: O, h: H) -> Result<(), H::HandledErr>
+    where
+        O: TopEncodeOutput,
+        H: EncodeErrorHandler,
+    {
+        VALIDATOR_SC_ADDRESS_BYTES.top_encode_or_handle_err(output, h)
+    }
+}
+
+impl<M> TypeAbiFrom<ValidatorSystemSCAddress> for ManagedAddress<M> where M: ManagedTypeApi {}
+
+impl core::fmt::Display for ValidatorSystemSCAddress {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str(VALIDATOR_SC_ADDRESS_BECH32)
+    }
+}

framework/base/src/types/interaction/markers/validator_sc_address.rs

@@ -6,12 +6,17 @@ mod governance_sc_proxy;
 mod legacy_system_sc_proxy;
 pub(crate) mod token_properties;
 mod token_properties_result;
+mod validator_sc_proxy;
 
 pub use builtin_func_proxy::*;
 pub use delegation_manager_sc_proxy::*;
 pub use delegation_sc_proxy::*;
 pub use esdt_system_sc_proxy::{ESDTSystemSCProxy, ESDTSystemSCProxyMethods, IssueCall};
-pub use governance_sc_proxy::*;
+pub use governance_sc_proxy::{
+    governance_config_result::GovernanceConfigResult, proposal_view_result::ProposalViewResult,
+    GovernanceSCProxy, GovernanceSCProxyMethods,
+};
 pub use legacy_system_sc_proxy::ESDTSystemSmartContractProxy;
 pub use token_properties::*;
 pub use token_properties_result::TokenPropertiesResult;
+pub use validator_sc_proxy::*;

framework/base/src/types/interaction/system_proxy.rs

@@ -1,6 +1,6 @@
 use crate::types::{
-    BigUint, EgldPayment, ManagedAddress, ManagedVec, NotPayable, ProxyArg, Tx, TxEnv, TxFrom,
-    TxGas, TxProxyTrait, TxTo, TxTypedCall,
+    BigUint, Egld, ManagedAddress, ManagedVec, NotPayable, ProxyArg, Tx, TxEgldValue, TxEnv,
+    TxFrom, TxGas, TxProxyTrait, TxTo, TxTypedCall,
 };
 
 /// Proxy for the Delegation Manager smart contract.
@@ -39,17 +39,20 @@ where
     To: TxTo<Env>,
     Gas: TxGas<Env>,
 {
+    /// Field "amount" requires at least 1250 EGLD.
     pub fn create_new_delegation_contract<
         Arg0: ProxyArg<BigUint<Env::Api>>,
         Arg1: ProxyArg<BigUint<Env::Api>>,
+        EgldValue: TxEgldValue<Env>,
     >(
         self,
         total_delegation_cap: Arg0,
         service_fee: Arg1,
-    ) -> TxTypedCall<Env, From, To, EgldPayment<<Env as TxEnv>::Api>, Gas, ()> {
+        amount: EgldValue,
+    ) -> TxTypedCall<Env, From, To, Egld<EgldValue>, Gas, ()> {
         self.wrapped_tx
             .raw_call("createNewDelegationContract")
-            .egld(BigUint::from(1250000000000000000000u128))
+            .egld(amount)
             .argument(&total_delegation_cap)
             .argument(&service_fee)
             .original_result()

framework/base/src/types/interaction/system_proxy/delegation_manager_sc_proxy.rs

@@ -1,7 +1,12 @@
+pub(super) mod governance_config_result;
+pub(super) mod proposal_view_result;
+
 use crate::types::{
-    BigUint, ManagedAddress, ManagedBuffer, MultiValueEncoded, NotPayable, ProxyArg, Tx, TxEnv,
-    TxFrom, TxGas, TxProxyTrait, TxTo, TxTypedCall,
+    BigUint, EgldPayment, ManagedAddress, ManagedBuffer, MultiValueEncoded, NotPayable, ProxyArg,
+    Tx, TxEnv, TxFrom, TxGas, TxProxyTrait, TxTo, TxTypedCall,
 };
+use governance_config_result::GovernanceConfigResult;
+use proposal_view_result::ProposalViewResult;
 
 /// Proxy for the Governance system smart contract.
 pub struct GovernanceSCProxy;
@@ -38,13 +43,6 @@ where
     To: TxTo<Env>,
     Gas: TxGas<Env>,
 {
-    pub fn init_v2(self) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
-        self.wrapped_tx
-            .payment(NotPayable)
-            .raw_call("initV2")
-            .original_result()
-    }
-
     pub fn proposal<
         Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
         Arg1: ProxyArg<BigUint<Env::Api>>,
@@ -54,20 +52,17 @@ where
         commit_hash: Arg0,
         start_vote_epoch: Arg1,
         end_vote_epoch: Arg2,
-    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
+    ) -> TxTypedCall<Env, From, To, EgldPayment<<Env as TxEnv>::Api>, Gas, ()> {
         self.wrapped_tx
-            .payment(NotPayable)
             .raw_call("proposal")
             .argument(&commit_hash)
             .argument(&start_vote_epoch)
             .argument(&end_vote_epoch)
+            .egld(BigUint::from(1_000_000_000_000_000_000_000u128))
             .original_result()
     }
 
-    pub fn vote<
-        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
-        Arg1: ProxyArg<ManagedBuffer<Env::Api>>,
-    >(
+    pub fn vote<Arg0: ProxyArg<BigUint<Env::Api>>, Arg1: ProxyArg<ManagedBuffer<Env::Api>>>(
         self,
         proposal_to_vote: Arg0,
         vote: Arg1,
@@ -81,7 +76,7 @@ where
     }
 
     pub fn delegate_vote<
-        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
+        Arg0: ProxyArg<u64>,
         Arg1: ProxyArg<ManagedBuffer<Env::Api>>,
         Arg2: ProxyArg<ManagedAddress<Env::Api>>,
         Arg3: ProxyArg<BigUint<Env::Api>>,
@@ -162,7 +157,10 @@ where
             .original_result()
     }
 
-    pub fn view_config(self) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
+    /// Note: values are returned as strings (base 10 representation).
+    pub fn view_config(
+        self,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, GovernanceConfigResult> {
         self.wrapped_tx
             .payment(NotPayable)
             .raw_call("viewConfig")
@@ -188,7 +186,7 @@ where
     pub fn view_proposal<Arg0: ProxyArg<BigUint<Env::Api>>>(
         self,
         nonce: Arg0,
-    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ProposalViewResult<Env::Api>> {
         self.wrapped_tx
             .payment(NotPayable)
             .raw_call("viewProposal")

framework/base/src/types/interaction/system_proxy/governance_sc_proxy.rs

@@ -0,0 +1,36 @@
+use alloc::string::String;
+
+use multiversx_sc_codec::{DecodeErrorHandler, TopDecodeMulti, TopDecodeMultiInput};
+
+#[derive(Debug, Clone, Default)]
+pub struct GovernanceConfigResult {
+    pub proposal_fee: String,
+    pub lost_proposal_fee: String,
+    pub min_quorum: String,
+    pub min_veto_threshold: String,
+    pub min_pass_threshold: String,
+    pub last_proposal_nonce: u64,
+}
+
+impl TopDecodeMulti for GovernanceConfigResult {
+    fn multi_decode_or_handle_err<I, H>(input: &mut I, h: H) -> Result<Self, H::HandledErr>
+    where
+        I: TopDecodeMultiInput,
+        H: DecodeErrorHandler,
+    {
+        let proposal_fee = String::multi_decode_or_handle_err(input, h)?;
+        let lost_proposal_fee = String::multi_decode_or_handle_err(input, h)?;
+        let min_quorum = String::multi_decode_or_handle_err(input, h)?;
+        let min_veto_threshold = String::multi_decode_or_handle_err(input, h)?;
+        let min_pass_threshold = String::multi_decode_or_handle_err(input, h)?;
+        let last_proposal_nonce = u64::multi_decode_or_handle_err(input, h)?;
+        Ok(GovernanceConfigResult {
+            proposal_fee,
+            lost_proposal_fee,
+            min_quorum,
+            min_veto_threshold,
+            min_pass_threshold,
+            last_proposal_nonce,
+        })
+    }
+}