Liquid Staking calls

chain-config/Cargo.toml

@@ -19,3 +19,6 @@ version = "=0.53.2"
 
 [dependencies.multiversx-sc-modules]
 version = "=0.53.2"
+#
+# [dependencies.liquid-staking]
+# path = "../liquid-staking"

chain-config/src/bls_keys.rs

@@ -1,9 +1,9 @@
-use crate::{validator_rules, StakeMultiArg};
+use crate::{events, validator_rules, StakeMultiArg};
 
 multiversx_sc::imports!();
 
 #[multiversx_sc::module]
-pub trait BlsKeysModule: validator_rules::ValidatorRulesModule {
+pub trait BlsKeysModule: validator_rules::ValidatorRulesModule + events::EventsModule {
     #[payable("*")]
     #[endpoint(register)]
     fn register(
@@ -16,11 +16,18 @@ pub trait BlsKeysModule: validator_rules::ValidatorRulesModule {
         let (_, stake_amount) = egld_stake_value.into_tuple();
         self.require_min_stake(stake_amount);
 
-        // TODO: query Validator SC about the validator
-        for bls_key in pub_bls_keys {
+        for bls_key in pub_bls_keys.clone() {
+            let has_stake = self.has_stake_in_validator_sc(&bls_key);
+            require!(has_stake, "The validator with the {} BLS key does not have any stake in the SovereignValidatorSC", bls_key);
+
+            // let delegated_value = self.get_delegated_value(validator_id)
+
             self.require_bls_key_whitelist(&bls_key);
 
             self.bls_keys().insert(bls_key);
         }
+
+        let current_sc_address = self.blockchain().get_sc_address();
+        self.register_event(&current_sc_address, &pub_bls_keys);
     }
 }

chain-config/src/chain_config_proxy.rs

@@ -255,6 +255,15 @@ where
             .original_result()
     }
 
+    pub fn liquid_staking_address(
+        self,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ManagedAddress<Env::Api>> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("getLiquidStakingAddress")
+            .original_result()
+    }
+
     pub fn is_admin<
         Arg0: ProxyArg<ManagedAddress<Env::Api>>,
     >(

chain-config/src/events.rs

@@ -0,0 +1,11 @@
+multiversx_sc::imports!();
+
+#[multiversx_sc::module]
+pub trait EventsModule {
+    #[event("registerEvent")]
+    fn register_event(
+        &self,
+        #[indexed] address: &ManagedAddress,
+        #[indexed] bls_keys: &MultiValueEncoded<ManagedBuffer>,
+    );
+}

chain-config/src/lib.rs

@@ -6,6 +6,8 @@ multiversx_sc::imports!();
 
 pub mod bls_keys;
 pub mod bridge;
+pub mod events;
+pub mod liquid_staking_proxy;
 pub mod validator_rules;
 
 pub type StakeMultiArg<M> = MultiValue2<TokenIdentifier<M>, BigUint<M>>;

chain-config/src/liquid_staking_proxy.rs

@@ -0,0 +1,311 @@
+// Code generated by the multiversx-sc proxy generator. DO NOT EDIT.
+
+////////////////////////////////////////////////////
+////////////////// AUTO-GENERATED //////////////////
+////////////////////////////////////////////////////
+
+#![allow(dead_code)]
+#![allow(clippy::all)]
+
+use multiversx_sc::proxy_imports::*;
+
+pub struct LiquidStakingProxy;
+
+impl<Env, From, To, Gas> TxProxyTrait<Env, From, To, Gas> for LiquidStakingProxy
+where
+    Env: TxEnv,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    type TxProxyMethods = LiquidStakingProxyMethods<Env, From, To, Gas>;
+
+    fn proxy_methods(self, tx: Tx<Env, From, To, (), Gas, (), ()>) -> Self::TxProxyMethods {
+        LiquidStakingProxyMethods { wrapped_tx: tx }
+    }
+}
+
+pub struct LiquidStakingProxyMethods<Env, From, To, Gas>
+where
+    Env: TxEnv,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    wrapped_tx: Tx<Env, From, To, (), Gas, (), ()>,
+}
+
+#[rustfmt::skip]
+impl<Env, From, Gas> LiquidStakingProxyMethods<Env, From, (), Gas>
+where
+    Env: TxEnv,
+    Env::Api: VMApi,
+    From: TxFrom<Env>,
+    Gas: TxGas<Env>,
+{
+    pub fn init(
+        self,
+    ) -> TxTypedDeploy<Env, From, NotPayable, Gas, ()> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_deploy()
+            .original_result()
+    }
+}
+
+#[rustfmt::skip]
+impl<Env, From, To, Gas> LiquidStakingProxyMethods<Env, From, To, Gas>
+where
+    Env: TxEnv,
+    Env::Api: VMApi,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    pub fn upgrade(
+        self,
+    ) -> TxTypedUpgrade<Env, From, To, NotPayable, Gas, ()> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_upgrade()
+            .original_result()
+    }
+}
+
+#[rustfmt::skip]
+impl<Env, From, To, Gas> LiquidStakingProxyMethods<Env, From, To, Gas>
+where
+    Env: TxEnv,
+    Env::Api: VMApi,
+    From: TxFrom<Env>,
+    To: TxTo<Env>,
+    Gas: TxGas<Env>,
+{
+    pub fn register_delegation_address<
+        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
+        Arg1: ProxyArg<ManagedAddress<Env::Api>>,
+    >(
+        self,
+        contract_name: Arg0,
+        delegation_address: Arg1,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("registerDelegationContractAddress")
+            .argument(&contract_name)
+            .argument(&delegation_address)
+            .original_result()
+    }
+
+    pub fn register_header_verifier_address<
+        Arg0: ProxyArg<ManagedAddress<Env::Api>>,
+    >(
+        self,
+        header_verifier_address: Arg0,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("registerHeaderVerifierAddress")
+            .argument(&header_verifier_address)
+            .original_result()
+    }
+
+    pub fn register_bls_keys<
+        Arg0: ProxyArg<MultiValueEncoded<Env::Api, ManagedBuffer<Env::Api>>>,
+    >(
+        self,
+        bls_keys: Arg0,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("registerBlsKeys")
+            .argument(&bls_keys)
+            .original_result()
+    }
+
+    pub fn stake<
+        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
+    >(
+        self,
+        contract_name: Arg0,
+    ) -> TxTypedCall<Env, From, To, (), Gas, ()> {
+        self.wrapped_tx
+            .raw_call("stake")
+            .argument(&contract_name)
+            .original_result()
+    }
+
+    pub fn unstake<
+        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
+        Arg1: ProxyArg<BigUint<Env::Api>>,
+    >(
+        self,
+        contract_name: Arg0,
+        egld_amount_to_unstake: Arg1,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("unStake")
+            .argument(&contract_name)
+            .argument(&egld_amount_to_unstake)
+            .original_result()
+    }
+
+    pub fn claim_rewards_from_delegation<
+        Arg0: ProxyArg<MultiValueEncoded<Env::Api, ManagedBuffer<Env::Api>>>,
+    >(
+        self,
+        contracts: Arg0,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("claimRewardsFromDelegation")
+            .argument(&contracts)
+            .original_result()
+    }
+
+    pub fn slash_validator<
+        Arg0: ProxyArg<ManagedAddress<Env::Api>>,
+        Arg1: ProxyArg<ManagedBuffer<Env::Api>>,
+        Arg2: ProxyArg<BigUint<Env::Api>>,
+    >(
+        self,
+        validator_address: Arg0,
+        bls_key: Arg1,
+        value_to_slash: Arg2,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("slashValidator")
+            .argument(&validator_address)
+            .argument(&bls_key)
+            .argument(&value_to_slash)
+            .original_result()
+    }
+
+    pub fn lock_for_sovereign_chain<
+        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
+    >(
+        self,
+        chain_id: Arg0,
+    ) -> TxTypedCall<Env, From, To, (), Gas, ()> {
+        self.wrapped_tx
+            .raw_call("lockForSovereignChain")
+            .argument(&chain_id)
+            .original_result()
+    }
+
+    pub fn claim_rewards(
+        self,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("claim_rewards")
+            .original_result()
+    }
+
+    pub fn delegation_addresses<
+        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
+    >(
+        self,
+        contract_name: Arg0,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ManagedAddress<Env::Api>> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("getDelegationAddress")
+            .argument(&contract_name)
+            .original_result()
+    }
+
+    pub fn delegated_value<
+        Arg0: ProxyArg<u64>,
+    >(
+        self,
+        validator: Arg0,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, BigUint<Env::Api>> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("getDelegatedValue")
+            .argument(&validator)
+            .original_result()
+    }
+
+    pub fn undelegate_epoch<
+        Arg0: ProxyArg<ManagedAddress<Env::Api>>,
+    >(
+        self,
+        address: Arg0,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, u64> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("unDelegateEpoch")
+            .argument(&address)
+            .original_result()
+    }
+
+    pub fn egld_token_supply(
+        self,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, BigUint<Env::Api>> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("getTotalEgldSupply")
+            .original_result()
+    }
+
+    pub fn header_verifier_address(
+        self,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ManagedAddress<Env::Api>> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("getHeaderVerifierAddress")
+            .original_result()
+    }
+
+    pub fn registered_bls_keys(
+        self,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, MultiValueEncoded<Env::Api, ManagedBuffer<Env::Api>>> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("getRegisteredBlsKeys")
+            .original_result()
+    }
+
+    pub fn validator_bls_key_address_map<
+        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
+    >(
+        self,
+        bls_key: Arg0,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ManagedAddress<Env::Api>> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("validatorBlsKeyMap")
+            .argument(&bls_key)
+            .original_result()
+    }
+
+    pub fn get_validator_id<
+        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
+    >(
+        self,
+        bls_key: Arg0,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, u64> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("getValidatorId")
+            .argument(&bls_key)
+            .original_result()
+    }
+
+    pub fn locked_supply<
+        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
+    >(
+        self,
+        chain_id: Arg0,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, BigUint<Env::Api>> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("lockedSupply")
+            .argument(&chain_id)
+            .original_result()
+    }
+}