fix: audit fix issues: 1,4,5 and suggestion(2)

Cargo.toml

@@ -11,18 +11,9 @@ path = "src/lib.rs"
 [dependencies.multiversx-sc]
 version = "0.50.3"
 
-[dependencies.multiversx-sc-modules]
-version = "0.50.3"
-
-[dev-dependencies]
-multiversx-wegld-swap-sc = "0.50.3"
-
-
 [dev-dependencies.multiversx-sc-scenario]
 version = "0.50.3"
 
-
-
 [workspace]
 members = [
     ".",

src/admin.rs

@@ -100,7 +100,7 @@ pub trait AdminModule:
     ) {
         only_privileged!(self, ERR_NOT_PRIVILEGED);
         require!(
-            self.tokens_whitelist().contains(&token_identifier),
+            self.token_whitelist().get() == token_identifier,
             ERR_TOKEN_NOT_WHITELISTED
         );
         require!(minimum <= maximum, ERR_WRONG_VALUES);
@@ -119,55 +119,58 @@ pub trait AdminModule:
     #[endpoint(setFeeValue)]
     fn set_fee_value(&self, fee_value: BigUint) {
         only_privileged!(self, ERR_NOT_PRIVILEGED);
+        self.set_fee_value_event(&fee_value);
         self.fee_value().set(fee_value);
     }
 
-    #[endpoint(setWegldContractAddress)]
-    fn set_wegld_contract_address(&self, wegld_contract_address: ManagedAddress) {
+    #[endpoint(setWegldTokenIdentifier)]
+    fn set_wegld_contract_address(&self, wegld_token_identifier: TokenIdentifier) {
         only_privileged!(self, ERR_NOT_PRIVILEGED);
-        self.set_wegld_contract_address_event(&wegld_contract_address);
-        self.wegld_contract_address().set(wegld_contract_address);
+        self.set_wegld_token_identifier(&wegld_token_identifier);
+        self.wegld_token_identifier().set(wegld_token_identifier);
     }
 
-    #[endpoint(addTokensToWhitelist)]
-    fn add_tokens_to_whitelist(
-        &self,
-        tokens: MultiValueEncoded<MultiValue2<TokenIdentifier, u32>>,
-    ) {
+    #[endpoint(addTokenToWhitelist)]
+    fn add_tokens_to_whitelist(&self, token: TokenIdentifier, decimals: u32) {
         only_privileged!(self, ERR_NOT_PRIVILEGED);
 
-        for token in tokens.into_iter() {
-            let (token_identifier, token_decimals) = token.into_tuple();
-            self.token_decimals(&token_identifier).set(token_decimals);
-            require!(
-                self.tokens_whitelist().insert(token_identifier),
-                ERR_TOKEN_ALREADY_IN_WHITELIST
-            );
+        self.add_token_to_whitelist_event(&token, &decimals);
+        if !self.token_whitelist().is_empty() {
+            self.token_decimals(&token).set(decimals);
+            self.token_whitelist().update(|whitelist_token| {
+                require!(*whitelist_token != token, ERR_TOKEN_ALREADY_IN_WHITELIST);
+                *whitelist_token = token
+            });
+        } else {
+            self.token_decimals(&token).set(decimals);
+            self.token_whitelist().set(token);
         }
     }
 
-    #[endpoint(removeTokensFromWhitelist)]
-    fn remove_tokens_from_whitelist(&self, tokens: MultiValueEncoded<TokenIdentifier>) {
+    #[endpoint(removeTokenFromWhitelist)]
+    fn remove_token_from_whitelist(&self, token: TokenIdentifier) {
         only_privileged!(self, ERR_NOT_PRIVILEGED);
-        self.remove_tokens_from_whitelist_event(&tokens.to_vec());
-        for token in tokens.into_iter() {
-            self.token_decimals(&token).clear();
-            require!(
-                self.tokens_whitelist().swap_remove(&token),
-                ERR_TOKEN_NOT_WHITELISTED
-            );
-        }
+
+        self.remove_token_from_whitelist_event(&token);
+        require!(
+            self.token_whitelist().get() == token,
+            ERR_TOKEN_NOT_WHITELISTED
+        );
+
+        self.token_decimals(&token).clear();
+        self.token_whitelist().clear();
     }
 
     #[endpoint(addToWhitelist)]
     fn add_to_whitelist(&self, addresses: MultiValueEncoded<ManagedAddress>) {
         only_privileged!(self, ERR_NOT_PRIVILEGED);
         for address in addresses.into_iter() {
             require!(
-                self.whitelist().contains(&address) == false,
+                !self.whitelist().contains(&address),
                 ERR_ADDRESS_ALREADY_WHITELISTED
             );
             self.whitelist().add(&address);
+            self.add_to_whitelist_event(&address);
         }
     }
 
@@ -180,6 +183,7 @@ pub trait AdminModule:
                 ERR_ADDRESS_NOT_WHITELISTED
             );
             self.whitelist().remove(&address);
+            self.remove_from_whitelist_event(&address);
         }
     }
 
@@ -198,7 +202,7 @@ pub trait AdminModule:
         let payment = self.call_value().single_esdt();
 
         require!(
-            self.tokens_whitelist().contains(&payment.token_identifier),
+            self.token_whitelist().get() == payment.token_identifier,
             ERR_TOKEN_NOT_WHITELISTED
         );
 

src/config.rs

@@ -84,15 +84,15 @@ pub trait ConfigModule: storage::StorageModule + events::EventsModule {
                 is_ready = false;
             }
 
-            if self.wegld_contract_address().is_empty() {
+            if self.wegld_token_identifier().is_empty() {
                 is_ready = false;
             }
         }
 
         if self.relayer().is_empty() {
             is_ready = false;
         }
-        if self.tokens_whitelist().is_empty() {
+        if self.token_whitelist().is_empty() {
             is_ready = false;
         }
         is_ready
@@ -103,8 +103,8 @@ pub trait ConfigModule: storage::StorageModule + events::EventsModule {
     fn administrator(&self) -> SingleValueMapper<ManagedAddress>;
 
     #[view(getTokensWhitelist)]
-    #[storage_mapper("tokens_whitelist")]
-    fn tokens_whitelist(&self) -> UnorderedSetMapper<TokenIdentifier>;
+    #[storage_mapper("token_whitelist")]
+    fn token_whitelist(&self) -> SingleValueMapper<TokenIdentifier>;
 
     #[storage_mapper("whitelist")]
     fn whitelist(&self) -> WhitelistMapper<ManagedAddress>;

src/events.rs

@@ -1,5 +1,3 @@
-use multiversx_sc::types::ManagedVec;
-
 use crate::config::State;
 
 #[multiversx_sc::module]
@@ -14,6 +12,12 @@ pub trait EventsModule {
         #[indexed] destination_signature: &ManagedBuffer,
     );
 
+    #[event("addToWhitelist")]
+    fn add_to_whitelist_event(&self, #[indexed] address: &ManagedAddress);
+
+    #[event("removeFromWhitelist")]
+    fn remove_from_whitelist_event(&self, #[indexed] address: &ManagedAddress);
+
     #[event("sendFromLiquidityEvent")]
     fn send_from_liquidity_event(
         &self,
@@ -29,12 +33,6 @@ pub trait EventsModule {
     #[event("setAdministratorEvent")]
     fn set_administrator_event(&self, #[indexed] administrator: &ManagedAddress);
 
-    #[event("addTokensToWhitelistEvent")]
-    fn add_tokens_to_whitelist_event(&self, #[indexed] tokens: &ManagedVec<TokenIdentifier>);
-
-    #[event("removeTokensFromWhitelistEvent")]
-    fn remove_tokens_from_whitelist_event(&self, #[indexed] tokens: &ManagedVec<TokenIdentifier>);
-
     #[event("setRelayerEvent")]
     fn set_relayer_event(&self, #[indexed] relayer: &ManagedAddress);
 
@@ -65,14 +63,20 @@ pub trait EventsModule {
         #[indexed] maximum: &BigUint,
     );
 
+    #[event("addTokenToWhitelistEvent")]
+    fn add_token_to_whitelist_event(&self, #[indexed] token: &TokenIdentifier, decimals: &u32);
+
+    #[event("removeTokenFromWhitelistEvent")]
+    fn remove_token_from_whitelist_event(&self, #[indexed] token: &TokenIdentifier);
+
     #[event("setFeeCollectorEvent")]
     fn set_fee_collector_event(&self, #[indexed] fee_collector: &ManagedAddress);
 
     #[event("setFeeValueEvent")]
     fn set_fee_value_event(&self, #[indexed] fee_value: &BigUint);
 
-    #[event("setWegldContractAddressEvent")]
-    fn set_wegld_contract_address_event(&self, #[indexed] wegld_contract_address: &ManagedAddress);
+    #[event("setWegldTokenIdentifier")]
+    fn set_wegld_token_identifier(&self, #[indexed] wegld_token_identifier: &TokenIdentifier);
 
     #[event("setRelayerStateEvent")]
     fn set_relayer_state_event(&self, #[indexed] state: &State);

src/lib.rs

@@ -6,16 +6,13 @@ use crate::errors::{
     ERR_TOKEN_NOT_WHITELISTED, ERR_WRONG_FEE_TOKEN_IDENTIFIER, ERR_WRONG_VALUES,
 };
 
-use crate::proxies::wegld_proxy;
-
 multiversx_sc::imports!();
 
 pub mod admin;
 pub mod config;
 pub mod errors;
 pub mod events;
 pub mod macros;
-pub mod proxies;
 pub mod storage;
 pub mod utils;
 #[multiversx_sc::contract]
@@ -56,7 +53,7 @@ pub trait CoreMxBridgeSc:
             let deposit = self.call_value().single_esdt();
 
             require!(
-                self.tokens_whitelist().contains(&deposit.token_identifier),
+                self.token_whitelist().get() == deposit.token_identifier,
                 ERR_TOKEN_NOT_WHITELISTED
             );
 
@@ -89,21 +86,13 @@ pub trait CoreMxBridgeSc:
 
             require!(fee_value == fee.amount, ERR_WRONG_VALUES);
 
-            let wegld_token_identifier = self
-                .tx()
-                .to(&self.wegld_contract_address().get())
-                .typed(wegld_proxy::EgldEsdtSwapProxy)
-                .wrapped_egld_token_id()
-                .returns(ReturnsResult)
-                .sync_call();
-
             require!(
-                fee.token_identifier == wegld_token_identifier,
+                fee.token_identifier == self.wegld_token_identifier().get(),
                 ERR_WRONG_FEE_TOKEN_IDENTIFIER
             );
 
             require!(
-                self.tokens_whitelist().contains(&deposit.token_identifier),
+                self.token_whitelist().get() == deposit.token_identifier,
                 ERR_TOKEN_NOT_WHITELISTED
             );
 
@@ -121,18 +110,11 @@ pub trait CoreMxBridgeSc:
                 ERR_PAYMENT_AMOUNT_NOT_IN_ACCEPTED_RANGE
             );
 
-            let back_transfers = self
-                .tx()
-                .to(&self.wegld_contract_address().get())
-                .typed(wegld_proxy::EgldEsdtSwapProxy)
-                .unwrap_egld()
-                .with_esdt_transfer(fee)
-                .returns(ReturnsBackTransfers)
-                .sync_call();
-
-            self.send().direct_egld(
+            self.send().direct_esdt(
                 &self.fee_collector().get(),
-                &back_transfers.total_egld_amount,
+                &fee.token_identifier,
+                0u64,
+                &fee.amount,
             );
 
             self.send_to_liquidity_event(