feat: add unit tests for internal _credit function

src/mocks/IexecLayerZeroBridgeHarness.sol

@@ -0,0 +1,23 @@
+// SPDX-FileCopyrightText: 2025 IEXEC BLOCKCHAIN TECH <contact@iex.ec>
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.8.22;
+
+import {IexecLayerZeroBridge} from "../bridges/layerZero/IexecLayerZeroBridge.sol";
+
+contract IexecLayerZeroBridgeHarness is IexecLayerZeroBridge {
+    constructor(bool approvalRequired_, address bridgeableToken, address lzEndpoint)
+        IexecLayerZeroBridge(approvalRequired_, bridgeableToken, lzEndpoint)
+    {}
+
+    function exposed_debit(address from, uint256 amountLD, uint256 minAmountLD, uint32 dstEid)
+        external
+        returns (uint256 amountSentLD, uint256 amountReceivedLD)
+    {
+        return _debit(from, amountLD, minAmountLD, dstEid);
+    }
+
+    function exposed_credit(address to, uint256 amountLD, uint32 srcEid) external returns (uint256 amountReceivedLD) {
+        return _credit(to, amountLD, srcEid);
+    }
+}

test/units/RLCLiquidityUnifierUpgrade.t.sol

@@ -22,17 +22,27 @@ contract RLCLiquidityUnifierUpgradeTest is TestHelperOz5 {
     address private upgrader = makeAddr("upgrader");
 
     address public proxyAddress;
-    string private name = "iEx.ec Network Token";
-    string public symbol = "RLC";
     uint256 public constant NEW_STATE_VARIABLE = 2;
 
     function setUp() public virtual override {
         super.setUp();
         setUpEndpoints(2, LibraryType.UltraLightNode);
         mockEndpoint = address(endpoints[1]);
 
-        (,, rlcToken,, rlcLiquidityUnifierV1) =
-            TestUtils.setupDeployment(name, symbol, mockEndpoint, mockEndpoint, admin, upgrader, pauser);
+        TestUtils.DeploymentResult memory deploymentResult = TestUtils.setupDeployment(
+            TestUtils.DeploymentParams({
+                iexecLayerZeroBridgeContractName: "IexecLayerZeroBridge",
+                lzEndpointSource: mockEndpoint,
+                lzEndpointDestination: mockEndpoint,
+                initialAdmin: admin,
+                initialUpgrader: upgrader,
+                initialPauser: pauser
+            })
+        );
+
+        rlcToken = deploymentResult.rlcToken;
+        rlcLiquidityUnifierV1 = deploymentResult.rlcLiquidityUnifier;
+
         proxyAddress = address(rlcLiquidityUnifierV1);
     }
 

test/units/bridges/layerZero/IexecLayerZeroBridge.t.sol

@@ -40,8 +40,6 @@ contract IexecLayerZeroBridgeTest is TestHelperOz5 {
 
     uint256 private constant INITIAL_BALANCE = 100 * 10 ** 9; // 100 RLC tokens with 9 decimals
     uint256 private constant TRANSFER_AMOUNT = 1 * 10 ** 9; // 1 RLC token with 9 decimals
-    string private name = "iEx.ec Network Token";
-    string private symbol = "RLC";
 
     function setUp() public virtual override {
         super.setUp();
@@ -51,8 +49,22 @@ contract IexecLayerZeroBridgeTest is TestHelperOz5 {
         address lzEndpointSource = address(endpoints[SOURCE_EID]); // Source endpoint for Sepolia - Destination endpoint for Arbitrum Sepolia
         address lzEndpointDestination = address(endpoints[DEST_EID]); // Source endpoint for Arbitrum Sepolia - Destination endpoint for Sepolia
 
-        (iexecLayerZeroBridgeEthereum, iexecLayerZeroBridgeChainX, rlcToken, rlcCrosschainToken, rlcLiquidityUnifier) =
-            TestUtils.setupDeployment(name, symbol, lzEndpointSource, lzEndpointDestination, admin, upgrader, pauser);
+        TestUtils.DeploymentResult memory deploymentResult2 = TestUtils.setupDeployment(
+            TestUtils.DeploymentParams({
+                iexecLayerZeroBridgeContractName: "IexecLayerZeroBridge",
+                lzEndpointSource: lzEndpointSource,
+                lzEndpointDestination: lzEndpointDestination,
+                initialAdmin: admin,
+                initialUpgrader: upgrader,
+                initialPauser: pauser
+            })
+        );
+
+        iexecLayerZeroBridgeEthereum = deploymentResult2.iexecLayerZeroBridgeChainA;
+        iexecLayerZeroBridgeChainX = deploymentResult2.iexecLayerZeroBridgeChainB;
+        rlcToken = deploymentResult2.rlcToken;
+        rlcCrosschainToken = deploymentResult2.rlcCrosschainToken;
+        rlcLiquidityUnifier = deploymentResult2.rlcLiquidityUnifier;
 
         address iexecLayerZeroBridgeEthereumAddress = address(iexecLayerZeroBridgeEthereum);
         address iexecLayerZeroBridgeChainXAddress = address(iexecLayerZeroBridgeChainX);

test/units/bridges/layerZero/IexecLayerZeroBridgeUpgrade.t.sol

@@ -22,17 +22,27 @@ contract IexecLayerZeroBridgeUpgradeTest is TestHelperOz5 {
     address public pauser = makeAddr("pauser");
 
     address public proxyAddress;
-    string public name = "iEx.ec Network Token";
-    string public symbol = "RLC";
     uint256 public constant NEW_STATE_VARIABLE = 2;
 
     function setUp() public virtual override {
         super.setUp();
         setUpEndpoints(2, LibraryType.UltraLightNode);
         mockEndpoint = address(endpoints[1]);
 
-        (, iexecLayerZeroBridgeV1,, rlcCrosschainToken,) =
-            TestUtils.setupDeployment(name, symbol, mockEndpoint, mockEndpoint, admin, upgrader, pauser);
+        TestUtils.DeploymentResult memory deploymentResult1 = TestUtils.setupDeployment(
+            TestUtils.DeploymentParams({
+                iexecLayerZeroBridgeContractName: "IexecLayerZeroBridge",
+                lzEndpointSource: mockEndpoint,
+                lzEndpointDestination: mockEndpoint,
+                initialAdmin: admin,
+                initialUpgrader: upgrader,
+                initialPauser: pauser
+            })
+        );
+
+        iexecLayerZeroBridgeV1 = deploymentResult1.iexecLayerZeroBridgeChainA;
+        rlcCrosschainToken = deploymentResult1.rlcCrosschainToken;
+
         proxyAddress = address(iexecLayerZeroBridgeV1);
     }
 

test/units/utils/TestUtils.sol

@@ -16,35 +16,58 @@ import {Deploy as RLCCrosschainTokenDeployScript} from "../../../script/RLCCross
 library TestUtils {
     using OptionsBuilder for bytes;
 
-    // TODO declare name and symbol inside the function.
-    function setupDeployment(
-        string memory name,
-        string memory symbol,
-        address lzEndpointSource,
-        address lzEndpointDestination,
-        address initialAdmin,
-        address initialUpgrader,
-        address initialPauser
-    )
-        internal
-        returns (
-            IexecLayerZeroBridge iexecLayerZeroBridgeChainA,
-            IexecLayerZeroBridge iexecLayerZeroBridgeChainB,
-            RLCMock rlcToken,
-            RLCCrosschainToken rlcCrosschainToken,
-            RLCLiquidityUnifier rlcLiquidityUnifier
-        )
-    {
-        address createXFactory = address(new CreateX());
+    // Struct to hold deployment parameters and reduce stack depth
+    struct DeploymentParams {
+        string iexecLayerZeroBridgeContractName;
+        address lzEndpointSource;
+        address lzEndpointDestination;
+        address initialAdmin;
+        address initialUpgrader;
+        address initialPauser;
+    }
 
-        // Deploy RLC token mock for L1
-        rlcToken = new RLCMock();
+    // Struct to hold deployment results
+    struct DeploymentResult {
+        IexecLayerZeroBridge iexecLayerZeroBridgeChainA;
+        IexecLayerZeroBridge iexecLayerZeroBridgeChainB;
+        RLCMock rlcToken;
+        RLCCrosschainToken rlcCrosschainToken;
+        RLCLiquidityUnifier rlcLiquidityUnifier;
+    }
 
-        // salt for createX
+    function setupDeployment(DeploymentParams memory params) public returns (DeploymentResult memory result) {
+        string memory name = "iEx.ec Network Token";
+        string memory symbol = "RLC";
+        address createXFactory = address(new CreateX());
         bytes32 salt = keccak256("salt");
 
+        // Deploy RLC token mock for L1
+        result.rlcToken = new RLCMock();
+
         // Deploy Liquidity Unifier
-        rlcLiquidityUnifier = RLCLiquidityUnifier(
+        result.rlcLiquidityUnifier =
+            _deployLiquidityUnifier(result.rlcToken, params.initialAdmin, params.initialUpgrader, createXFactory, salt);
+
+        // Deploy IexecLayerZeroBridge for Chain A
+        result.iexecLayerZeroBridgeChainA =
+            _deployBridge(params, true, address(result.rlcLiquidityUnifier), createXFactory, salt);
+
+        // Deploy RLC Crosschain token and Bridge for Chain B
+        result.rlcCrosschainToken =
+            _deployCrosschainToken(name, symbol, params.initialAdmin, params.initialUpgrader, createXFactory, salt);
+
+        result.iexecLayerZeroBridgeChainB =
+            _deployBridge(params, false, address(result.rlcCrosschainToken), createXFactory, salt);
+    }
+
+    function _deployLiquidityUnifier(
+        RLCMock rlcToken,
+        address initialAdmin,
+        address initialUpgrader,
+        address createXFactory,
+        bytes32 salt
+    ) private returns (RLCLiquidityUnifier) {
+        return RLCLiquidityUnifier(
             UUPSProxyDeployer.deployUUPSProxyWithCreateX(
                 "RLCLiquidityUnifier",
                 abi.encode(rlcToken),
@@ -53,39 +76,48 @@ library TestUtils {
                 salt
             )
         );
+    }
 
-        // Deploy IexecLayerZeroBridgeAdapter
-        iexecLayerZeroBridgeChainA = IexecLayerZeroBridge(
+    function _deployBridge(
+        DeploymentParams memory params,
+        bool approvalRequired,
+        address bridgeableToken,
+        address createXFactory,
+        bytes32 salt
+    ) private returns (IexecLayerZeroBridge) {
+        return IexecLayerZeroBridge(
             UUPSProxyDeployer.deployUUPSProxyWithCreateX(
-                "IexecLayerZeroBridge",
-                abi.encode(true, rlcLiquidityUnifier, lzEndpointSource),
+                params.iexecLayerZeroBridgeContractName,
+                abi.encode(
+                    approvalRequired,
+                    bridgeableToken,
+                    approvalRequired ? params.lzEndpointSource : params.lzEndpointDestination
+                ),
                 abi.encodeWithSelector(
-                    IexecLayerZeroBridge.initialize.selector, initialAdmin, initialUpgrader, initialPauser
+                    IexecLayerZeroBridge.initialize.selector,
+                    params.initialAdmin,
+                    params.initialUpgrader,
+                    params.initialPauser
                 ),
                 createXFactory,
                 salt
             )
         );
+    }
 
-        // Deploy RLC Crosschain token (for L2)
-        rlcCrosschainToken = RLCCrosschainToken(
+    function _deployCrosschainToken(
+        string memory name,
+        string memory symbol,
+        address initialAdmin,
+        address initialUpgrader,
+        address createXFactory,
+        bytes32 salt
+    ) private returns (RLCCrosschainToken) {
+        return RLCCrosschainToken(
             new RLCCrosschainTokenDeployScript().deploy(
                 name, symbol, initialAdmin, initialUpgrader, createXFactory, salt
             )
         );
-        // Deploy IexecLayerZeroBridge
-        iexecLayerZeroBridgeChainB = IexecLayerZeroBridge(
-            UUPSProxyDeployer.deployUUPSProxyWithCreateX(
-                "IexecLayerZeroBridge",
-                abi.encode(false, rlcCrosschainToken, lzEndpointDestination),
-                abi.encodeWithSelector(
-                    IexecLayerZeroBridge.initialize.selector, initialAdmin, initialUpgrader, initialPauser
-                ),
-                createXFactory,
-                salt
-            )
-        );
-        // TODO: see if it's possible to authorize the bridge here.
     }
 
     /**