[MEX-592] Distribute only mex in fees collector

.github/workflows/actions.yml

@@ -20,9 +20,9 @@ permissions:
 jobs:
   contracts:
     name: Contracts
-    uses: multiversx/mx-sc-actions/.github/workflows/contracts.yml@v3.3.1
+    uses: multiversx/mx-sc-actions/.github/workflows/contracts.yml@v4.2.2
     with:
-      rust-toolchain: nightly-2024-05-22
+      rust-toolchain: stable
       coverage-args: --ignore-filename-regex='/.cargo/git' --output ./coverage.md
     secrets:
       token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release.yml

@@ -9,7 +9,7 @@ permissions:
 
 jobs:
   build:
-    uses: multiversx/mx-sc-actions/.github/workflows/reproducible-build.yml@v3.3.1
+    uses: multiversx/mx-sc-actions/.github/workflows/reproducible-build.yml@v4.2.2
     with:
-      image_tag: v7.0.0
+      image_tag: v9.0.0
       attach_to_existing_release: true

dex/pair/Cargo.toml

@@ -45,3 +45,6 @@ num-bigint = "0.4.2"
 
 [dev-dependencies.multiversx-sc-scenario]
 version = "=0.53.2"
+
+[dev-dependencies.energy-factory-mock]
+path = "../../energy-integration/energy-factory-mock"

dex/pair/tests/pair_rs_test.rs

@@ -1,9 +1,8 @@
 #![allow(deprecated)]
 
 mod pair_setup;
-use fees_collector::{
-    config::ConfigModule, fees_accumulation::FeesAccumulationModule, FeesCollector,
-};
+use energy_factory_mock::EnergyFactoryMock;
+use fees_collector::{config::ConfigModule, FeesCollector};
 use multiversx_sc::codec::{self, TopDecode};
 use multiversx_sc::{
     api::ManagedTypeApi,
@@ -1583,13 +1582,34 @@ fn fees_collector_pair_test() {
     let mut pair_setup = PairSetup::new(pair::contract_obj);
     let fees_collector_wrapper = pair_setup.b_mock.create_sc_account(
         &rust_biguint!(0),
-        None,
+        Some(&pair_setup.owner_address),
         fees_collector::contract_obj,
         "fees collector path",
     );
 
-    let pair_addr = pair_setup.pair_wrapper.address_ref().clone();
-    let energy_factory_mock_addr = pair_setup.pair_wrapper.address_ref().clone();
+    let energy_factory_mock_wrapper = pair_setup.b_mock.create_sc_account(
+        &rust_biguint!(0),
+        Some(&pair_setup.owner_address),
+        energy_factory_mock::contract_obj,
+        "energy factory mock",
+    );
+    pair_setup
+        .b_mock
+        .execute_tx(
+            &pair_setup.owner_address,
+            &energy_factory_mock_wrapper,
+            &rust_biguint!(0),
+            |sc| {
+                sc.init();
+                sc.base_asset_token_id()
+                    .set(managed_token_id!(MEX_TOKEN_ID));
+                sc.locked_token()
+                    .set_token_id(managed_token_id!(LOCKED_TOKEN_ID));
+            },
+        )
+        .assert_ok();
+
+    let energy_factory_mock_addr = energy_factory_mock_wrapper.address_ref().clone();
     pair_setup
         .b_mock
         .execute_tx(
@@ -1598,17 +1618,11 @@ fn fees_collector_pair_test() {
             &rust_biguint!(0),
             |sc| {
                 sc.init(
-                    managed_token_id!(LOCKED_TOKEN_ID),
                     managed_address!(&energy_factory_mock_addr),
+                    managed_address!(&energy_factory_mock_addr), // unused
+                    0,
                     MultiValueEncoded::new(),
                 );
-                let _ = sc.known_contracts().insert(managed_address!(&pair_addr));
-
-                let mut tokens = MultiValueEncoded::new();
-                tokens.push(managed_token_id!(WEGLD_TOKEN_ID));
-                tokens.push(managed_token_id!(MEX_TOKEN_ID));
-
-                sc.add_known_tokens(tokens);
             },
         )
         .assert_ok();
@@ -1644,7 +1658,7 @@ fn fees_collector_pair_test() {
         .b_mock
         .execute_query(&fees_collector_wrapper, |sc| {
             assert_eq!(
-                sc.accumulated_fees(1, &managed_token_id!(WEGLD_TOKEN_ID))
+                sc.all_accumulated_tokens(&managed_token_id!(WEGLD_TOKEN_ID))
                     .get(),
                 managed_biguint!(25)
             );

dex/router/src/factory.rs

@@ -132,24 +132,20 @@ pub trait FactoryModule: config::ConfigModule + read_pair_storage::ReadPairStora
         first_token_id: TokenIdentifier,
         second_token_id: TokenIdentifier,
     ) -> ManagedAddress {
-        let mut address = self
-            .pair_map()
-            .get(&PairTokens {
-                first_token_id: first_token_id.clone(),
-                second_token_id: second_token_id.clone(),
-            })
-            .unwrap_or_else(ManagedAddress::zero);
-
-        if address.is_zero() {
-            address = self
-                .pair_map()
-                .get(&PairTokens {
-                    first_token_id: second_token_id,
-                    second_token_id: first_token_id,
-                })
-                .unwrap_or_else(ManagedAddress::zero);
+        let mut opt_address = self.pair_map().get(&PairTokens {
+            first_token_id: first_token_id.clone(),
+            second_token_id: second_token_id.clone(),
+        });
+        if opt_address.is_some() {
+            return unsafe { opt_address.unwrap_unchecked() };
         }
-        address
+
+        opt_address = self.pair_map().get(&PairTokens {
+            first_token_id: second_token_id,
+            second_token_id: first_token_id,
+        });
+
+        opt_address.unwrap_or_else(ManagedAddress::zero)
     }
 
     fn get_pair_temporary_owner(&self, pair_address: &ManagedAddress) -> Option<ManagedAddress> {

dex/router/tests/router_setup/mod.rs

@@ -42,7 +42,7 @@ where
     RouterObjBuilder: 'static + Copy + Fn() -> router::ContractObj<DebugApi>,
     PairObjBuilder: 'static + Copy + Fn() -> pair::ContractObj<DebugApi>,
 {
-    pub blockchain_wrapper: BlockchainStateWrapper,
+    pub b_mock: BlockchainStateWrapper,
     pub owner_address: Address,
     pub user_address: Address,
     pub router_wrapper: ContractObjWrapper<router::ContractObj<DebugApi>, RouterObjBuilder>,
@@ -57,31 +57,23 @@ where
 {
     pub fn new(router_builder: RouterObjBuilder, pair_builder: PairObjBuilder) -> Self {
         let rust_zero = rust_biguint!(0u64);
-        let mut blockchain_wrapper = BlockchainStateWrapper::new();
-        let owner_addr = blockchain_wrapper.create_user_account(&rust_zero);
+        let mut b_mock = BlockchainStateWrapper::new();
+        let owner_addr = b_mock.create_user_account(&rust_zero);
 
-        let router_wrapper = blockchain_wrapper.create_sc_account(
+        let router_wrapper = b_mock.create_sc_account(
             &rust_zero,
             Some(&owner_addr),
             router_builder,
             ROUTER_WASM_PATH,
         );
 
-        let mex_pair_wrapper = blockchain_wrapper.create_sc_account(
-            &rust_zero,
-            Some(&owner_addr),
-            pair_builder,
-            PAIR_WASM_PATH,
-        );
+        let mex_pair_wrapper =
+            b_mock.create_sc_account(&rust_zero, Some(&owner_addr), pair_builder, PAIR_WASM_PATH);
 
-        let usdc_pair_wrapper = blockchain_wrapper.create_sc_account(
-            &rust_zero,
-            Some(&owner_addr),
-            pair_builder,
-            PAIR_WASM_PATH,
-        );
+        let usdc_pair_wrapper =
+            b_mock.create_sc_account(&rust_zero, Some(&owner_addr), pair_builder, PAIR_WASM_PATH);
 
-        blockchain_wrapper
+        b_mock
             .execute_tx(&owner_addr, &mex_pair_wrapper, &rust_zero, |sc| {
                 let first_token_id = managed_token_id!(WEGLD_TOKEN_ID);
                 let second_token_id = managed_token_id!(MEX_TOKEN_ID);
@@ -108,7 +100,7 @@ where
             })
             .assert_ok();
 
-        blockchain_wrapper
+        b_mock
             .execute_tx(&owner_addr, &usdc_pair_wrapper, &rust_zero, |sc| {
                 let first_token_id = managed_token_id!(WEGLD_TOKEN_ID);
                 let second_token_id = managed_token_id!(USDC_TOKEN_ID);
@@ -135,7 +127,7 @@ where
             })
             .assert_ok();
 
-        blockchain_wrapper
+        b_mock
             .execute_tx(&owner_addr, &router_wrapper, &rust_zero, |sc| {
                 sc.init(OptionalValue::None);
 
@@ -157,38 +149,38 @@ where
             .assert_ok();
 
         let lp_token_roles = [EsdtLocalRole::Mint, EsdtLocalRole::Burn];
-        blockchain_wrapper.set_esdt_local_roles(
+        b_mock.set_esdt_local_roles(
             mex_pair_wrapper.address_ref(),
             LPMEX_TOKEN_ID,
             &lp_token_roles[..],
         );
 
         let lp_token_roles = [EsdtLocalRole::Mint, EsdtLocalRole::Burn];
-        blockchain_wrapper.set_esdt_local_roles(
+        b_mock.set_esdt_local_roles(
             usdc_pair_wrapper.address_ref(),
             LPUSDC_TOKEN_ID,
             &lp_token_roles[..],
         );
 
-        let user_addr = blockchain_wrapper.create_user_account(&rust_biguint!(100_000_000));
-        blockchain_wrapper.set_esdt_balance(
+        let user_addr = b_mock.create_user_account(&rust_biguint!(100_000_000));
+        b_mock.set_esdt_balance(
             &user_addr,
             WEGLD_TOKEN_ID,
             &rust_biguint!(USER_TOTAL_WEGLD_TOKENS),
         );
-        blockchain_wrapper.set_esdt_balance(
+        b_mock.set_esdt_balance(
             &user_addr,
             MEX_TOKEN_ID,
             &rust_biguint!(USER_TOTAL_MEX_TOKENS),
         );
-        blockchain_wrapper.set_esdt_balance(
+        b_mock.set_esdt_balance(
             &user_addr,
             USDC_TOKEN_ID,
             &rust_biguint!(USER_TOTAL_USDC_TOKENS),
         );
 
         RouterSetup {
-            blockchain_wrapper,
+            b_mock,
             owner_address: owner_addr,
             user_address: user_addr,
             router_wrapper,
@@ -211,7 +203,7 @@ where
             },
         ];
 
-        self.blockchain_wrapper
+        self.b_mock
             .execute_esdt_multi_transfer(
                 &self.user_address,
                 &self.mex_pair_wrapper,
@@ -238,7 +230,7 @@ where
             },
         ];
 
-        self.blockchain_wrapper
+        self.b_mock
             .execute_esdt_multi_transfer(
                 &self.user_address,
                 &self.usdc_pair_wrapper,
@@ -261,7 +253,7 @@ where
     ) {
         let payment_amount_big = rust_biguint!(payment_amount);
 
-        self.blockchain_wrapper
+        self.b_mock
             .execute_esdt_transfer(
                 &self.user_address,
                 &self.router_wrapper,

dex/router/tests/router_test.rs

@@ -1,6 +1,7 @@
 #![allow(deprecated)]
 
 mod router_setup;
+
 use multiversx_sc::{
     codec::multi_types::OptionalValue,
     storage::mappers::StorageTokenWrapper,
@@ -131,17 +132,17 @@ fn test_multi_pair_swap() {
 
     router_setup.add_liquidity();
 
-    router_setup.blockchain_wrapper.check_esdt_balance(
+    router_setup.b_mock.check_esdt_balance(
         &router_setup.user_address,
         WEGLD_TOKEN_ID,
         &rust_biguint!(5_000_000_000),
     );
-    router_setup.blockchain_wrapper.check_esdt_balance(
+    router_setup.b_mock.check_esdt_balance(
         &router_setup.user_address,
         MEX_TOKEN_ID,
         &rust_biguint!(5_000_000_000),
     );
-    router_setup.blockchain_wrapper.check_esdt_balance(
+    router_setup.b_mock.check_esdt_balance(
         &router_setup.user_address,
         USDC_TOKEN_ID,
         &rust_biguint!(5_000_000_000),
@@ -164,17 +165,17 @@ fn test_multi_pair_swap() {
 
     router_setup.multi_pair_swap(MEX_TOKEN_ID, 100_000, &ops);
 
-    router_setup.blockchain_wrapper.check_esdt_balance(
+    router_setup.b_mock.check_esdt_balance(
         &router_setup.user_address,
         WEGLD_TOKEN_ID,
         &rust_biguint!(5_000_000_000), //unchanged
     );
-    router_setup.blockchain_wrapper.check_esdt_balance(
+    router_setup.b_mock.check_esdt_balance(
         &router_setup.user_address,
         MEX_TOKEN_ID,
         &rust_biguint!(4_999_900_000), //spent 100_000
     );
-    router_setup.blockchain_wrapper.check_esdt_balance(
+    router_setup.b_mock.check_esdt_balance(
         &router_setup.user_address,
         USDC_TOKEN_ID,
         &rust_biguint!(5_000_082_909), //gained 82_909

energy-integration/energy-factory-mock/src/lib.rs

@@ -55,6 +55,9 @@ pub trait EnergyFactoryMock {
     #[storage_mapper("userEnergy")]
     fn user_energy(&self, user: &ManagedAddress) -> SingleValueMapper<Energy<Self::Api>>;
 
+    #[storage_mapper("baseAssetTokenId")]
+    fn base_asset_token_id(&self) -> SingleValueMapper<TokenIdentifier>;
+
     #[storage_mapper("lockedTokenId")]
     fn locked_token(&self) -> NonFungibleTokenMapper;
 }