feat: relayer and public separate states

interaction/devnet.snippets.sh

@@ -121,23 +121,45 @@ setWegldContractAddress(){
 
 
 
-setContractStateActive(){
+setPublicStateActive(){
     mxpy --verbose contract call ${ADDRESS} \
     --recall-nonce \
     --pem=${WALLET} \
     --gas-limit=6000000 \
-    --function "setContractStateActive" \
+    --function "setPublicStateActive" \
     --proxy ${PROXY} \
     --chain ${CHAIN_ID} \
     --send || return
 }
 
-setContractStateInactive(){
+setPublicStateInactive(){
     mxpy --verbose contract call ${ADDRESS} \
     --recall-nonce \
     --pem=${WALLET} \
     --gas-limit=6000000 \
-    --function "setContractStateInactive" \
+    --function "setPublicStateInactive" \
+    --proxy ${PROXY} \
+    --chain ${CHAIN_ID} \
+    --send || return
+}
+
+setRelayerStateActive(){
+    mxpy --verbose contract call ${ADDRESS} \
+    --recall-nonce \
+    --pem=${WALLET} \
+    --gas-limit=6000000 \
+    --function "setRelayerStateActive" \
+    --proxy ${PROXY} \
+    --chain ${CHAIN_ID} \
+    --send || return
+}
+
+setRelayerStateInactive(){
+    mxpy --verbose contract call ${ADDRESS} \
+    --recall-nonce \
+    --pem=${WALLET} \
+    --gas-limit=6000000 \
+    --function "setRelayerStateInactive" \
     --proxy ${PROXY} \
     --chain ${CHAIN_ID} \
     --send || return

src/admin.rs

@@ -15,38 +15,60 @@ multiversx_sc::derive_imports!();
 pub trait AdminModule:
     crate::config::ConfigModule + storage::StorageModule + events::EventsModule
 {
-    #[endpoint(setContractStateActive)]
-    fn set_contract_state_active(&self) {
+    #[endpoint(setPublicStateActive)]
+    fn set_public_state_active(&self) {
         let caller = self.blockchain().get_caller();
 
         require!(
             self.is_privileged(&caller) || self.is_relayer(&caller),
             ERR_NOT_PRIVILEGED
         );
         require!(
-            self.contract_state().get() == State::Inactive,
+            self.public_state().get() == State::Inactive,
             ERR_ALREADY_ACTIVE
         );
-        self.contract_state().set(State::Active);
+        self.public_state().set(State::Active);
         self.set_contract_state_event(&State::Active);
     }
 
-    #[endpoint(setContractStateInactive)]
-    fn set_contract_state_inactive(&self) {
+    #[endpoint(setPublicStateInactive)]
+    fn set_public_state_inactive(&self) {
         let caller = self.blockchain().get_caller();
 
         require!(
             self.is_privileged(&caller) || self.is_relayer(&caller),
             ERR_NOT_PRIVILEGED
         );
         require!(
-            self.contract_state().get() == State::Active,
+            self.public_state().get() == State::Active,
             ERR_ALREADY_INACTIVE
         );
-        self.contract_state().set(State::Inactive);
+        self.public_state().set(State::Inactive);
         self.set_contract_state_event(&State::Inactive);
     }
 
+    #[endpoint(setRelayerStateActive)]
+    fn set_relayer_state_active(&self) {
+        only_privileged!(self, ERR_NOT_PRIVILEGED);
+        require!(
+            self.relayer_state().get() == State::Inactive,
+            ERR_ALREADY_ACTIVE
+        );
+        self.relayer_state().set(State::Active);
+        self.set_relayer_state_event(&State::Active);
+    }
+
+    #[endpoint(setRelayerStateInactive)]
+    fn set_relayer_state_inactive(&self) {
+        only_privileged!(self, ERR_NOT_PRIVILEGED);
+        require!(
+            self.relayer_state().get() == State::Active,
+            ERR_ALREADY_INACTIVE
+        );
+        self.relayer_state().set(State::Inactive);
+        self.set_relayer_state_event(&State::Inactive);
+    }
+
     #[endpoint(setWhitelistStateActive)]
     fn set_whitelist_state_active(&self) {
         only_privileged!(self, ERR_NOT_PRIVILEGED);

src/config.rs

@@ -75,10 +75,6 @@ pub trait ConfigModule: storage::StorageModule + events::EventsModule {
     fn contract_is_ready(&self) -> bool {
         let mut is_ready = true;
 
-        if !self.is_state_active(self.contract_state().get()) {
-            is_ready = false;
-        }
-
         if self.administrator().is_empty() {
             is_ready = false;
         }
@@ -117,9 +113,13 @@ pub trait ConfigModule: storage::StorageModule + events::EventsModule {
     #[storage_mapper("whitelist_state")]
     fn whitelist_state(&self) -> SingleValueMapper<State>;
 
-    #[view(getContractState)]
-    #[storage_mapper("contract_state")]
-    fn contract_state(&self) -> SingleValueMapper<State>;
+    #[view(getPublicState)]
+    #[storage_mapper("public_state")]
+    fn public_state(&self) -> SingleValueMapper<State>;
+
+    #[view(getRelayerState)]
+    #[storage_mapper("relayer_state")]
+    fn relayer_state(&self) -> SingleValueMapper<State>;
 
     #[view(getRelayer)]
     #[storage_mapper("relayer")]

src/events.rs

@@ -73,4 +73,7 @@ pub trait EventsModule {
 
     #[event("setWegldContractAddressEvent")]
     fn set_wegld_contract_address_event(&self, #[indexed] wegld_contract_address: &ManagedAddress);
+
+    #[event("setRelayerStateEvent")]
+    fn set_relayer_state_event(&self, #[indexed] state: &State);
 }

src/lib.rs

@@ -31,7 +31,8 @@ pub trait CoreMxBridgeSc:
 
     #[upgrade]
     fn upgrade(&self) {
-        self.set_contract_state_inactive();
+        self.set_public_state_inactive();
+        self.set_relayer_state_inactive();
     }
 
     #[payable("*")]
@@ -43,6 +44,10 @@ pub trait CoreMxBridgeSc:
     ) {
         let caller = self.blockchain().get_caller();
         require_contract_ready!(self, ERR_CONTRACT_NOT_READY);
+        require!(
+            self.is_state_active(self.public_state().get()),
+            ERR_CONTRACT_NOT_READY
+        );
         check_whitelist!(self, &caller, ERR_ADDRESS_NOT_WHITELISTED);
 
         let fee_value = self.fee_value().get();
@@ -151,6 +156,10 @@ pub trait CoreMxBridgeSc:
         receiver: ManagedAddress,
     ) {
         require_contract_ready!(self, ERR_CONTRACT_NOT_READY);
+        require!(
+            self.is_state_active(self.relayer_state().get()),
+            ERR_CONTRACT_NOT_READY
+        );
         let caller = self.blockchain().get_caller();
         require!(self.relayer().get() == caller, ERR_NOT_PRIVILEGED);
 

tests/bridge_sc/bridge_sc.rs

@@ -228,7 +228,7 @@ impl ContractState {
     pub fn check_contract_state(&mut self, contract_state: State) -> &mut Self {
         self.world.sc_query(
             ScQueryStep::new()
-                .call(self.contract.contract_state())
+                .call(self.contract.public_state())
                 .expect_value(SingleValue::from(contract_state)),
         );
         self
@@ -291,7 +291,37 @@ impl ContractState {
         self.world.sc_call(
             ScCallStep::new()
                 .from(caller)
-                .call(self.contract.set_contract_state_active())
+                .call(self.contract.set_public_state_active())
+                .expect(tx_expect),
+        );
+        self
+    }
+
+    pub fn set_relayer_state_active(
+        &mut self,
+        caller: &str,
+        expect: Option<TxExpect>,
+    ) -> &mut Self {
+        let tx_expect = expect.unwrap_or(TxExpect::ok());
+        self.world.sc_call(
+            ScCallStep::new()
+                .from(caller)
+                .call(self.contract.set_relayer_state_active())
+                .expect(tx_expect),
+        );
+        self
+    }
+
+    pub fn set_relayer_state_inactive(
+        &mut self,
+        caller: &str,
+        expect: Option<TxExpect>,
+    ) -> &mut Self {
+        let tx_expect = expect.unwrap_or(TxExpect::ok());
+        self.world.sc_call(
+            ScCallStep::new()
+                .from(caller)
+                .call(self.contract.set_relayer_state_inactive())
                 .expect(tx_expect),
         );
         self
@@ -306,7 +336,7 @@ impl ContractState {
         self.world.sc_call(
             ScCallStep::new()
                 .from(caller)
-                .call(self.contract.set_contract_state_inactive())
+                .call(self.contract.set_public_state_inactive())
                 .expect(tx_expect),
         );
         self

tests/endpoints/relayer.rs

@@ -22,7 +22,7 @@ fn relayer_test() {
 
     state
         .default_deploy_and_set()
-        .set_contract_state_active(OWNER_BRIDGE_CONTRACT_ADDRESS_EXPR, None);
+        .set_relayer_state_active(OWNER_BRIDGE_CONTRACT_ADDRESS_EXPR, None);
 
     state.send_from_liquidity(
         FIRST_USER_ADDRESS_EXPR,

tests/unit_tests.rs

@@ -53,7 +53,7 @@ fn contract_is_ready_test() {
 
     assert_eq!(check, false);
 
-    bridge_sc.contract_state().set(State::Active);
+    bridge_sc.public_state().set(State::Active);
 
     check = bridge_sc.contract_is_ready();
 

wasm/src/lib.rs

@@ -6,9 +6,9 @@
 
 // Init:                                 1
 // Upgrade:                              1
-// Endpoints:                           30
+// Endpoints:                           33
 // Async Callback (empty):               1
-// Total number of exported functions:  33
+// Total number of exported functions:  36
 
 #![no_std]
 
@@ -33,10 +33,13 @@ multiversx_sc_wasm_adapter::endpoints! {
         getAdministrator => administrator
         getTokensWhitelist => tokens_whitelist
         getWhitelistState => whitelist_state
-        getContractState => contract_state
+        getPublicState => public_state
+        getRelayerState => relayer_state
         getRelayer => relayer
-        setContractStateActive => set_contract_state_active
-        setContractStateInactive => set_contract_state_inactive
+        setPublicStateActive => set_public_state_active
+        setPublicStateInactive => set_public_state_inactive
+        setRelayerStateActive => set_relayer_state_active
+        setRelayerStateInactive => set_relayer_state_inactive
         setWhitelistStateActive => set_whitelist_state_active
         setWhitelistStateInactive => set_whitelist_state_inactive
         setDepositLimits => set_deposit_limits