feat(tests): Add comprehensive tests for RLCOFT and related contracts

Author: gfournierPro

Makefile

@@ -73,6 +73,10 @@ verify-oft:
 # Combined verification target
 verify-all: verify-adapter verify-oft
 
+test-rlcoft:
+	@echo "Running RLC OFT tests..."
+	forge test --match-contract RLCOFTTest -vvv
+
 # Test and utility targets
 test:
 	@echo "Running tests..."

test/TokenSpenderMock.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.22;
+
+import "../src/TokenSpender.sol";
+
+contract TokenSpenderMock is TokenSpender {
+    address public lastCaller;
+    uint256 public lastAmount;
+    address public lastToken;
+    bytes public lastData;
+    
+    function receiveApproval(
+        address _sender,
+        uint256 _value,
+        address _token,
+        bytes calldata _extraData
+    ) external override {
+        lastCaller = _sender;
+        lastAmount = _value;
+        lastToken = _token;
+        lastData = _extraData;
+    }
+}

test/mocks/ERC20Mock.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.22;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract ERC20Mock is ERC20 {
+    uint8 private _decimals = 9;
+
+    constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
+    
+    function mint(address to, uint256 amount) external {
+        _mint(to, amount);
+    }
+    
+    function decimals() public view override returns (uint8) {
+        return _decimals;
+    }
+    
+    function setDecimals(uint8 newDecimals) external {
+        _decimals = newDecimals;
+    }
+}

test/mocks/LZEndpointMock.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.22;
+
+import {ILayerZeroEndpoint} from "@layerzerolabs/oft-evm/contracts/interfaces/ILayerZeroEndpoint.sol";
+import {ILayerZeroReceiver} from "@layerzerolabs/oft-evm/contracts/interfaces/ILayerZeroReceiver.sol";
+
+contract LZEndpointMock is ILayerZeroEndpoint {
+    uint16 public chainId;
+    mapping(uint16 => address) public destinations;
+    
+    constructor(uint16 _chainId) {
+        chainId = _chainId;
+    }
+    
+    function setDestLzEndpoint(address destLzEndpoint, uint16 destChainId) external {
+        destinations[destChainId] = destLzEndpoint;
+    }
+    
+    function estimateFees(
+        uint16 _dstChainId,
+        address _userApplication,
+        bytes calldata _payload,
+        bool _payInZRO,
+        bytes calldata _adapterParam
+    ) external view override returns (uint256 nativeFee, uint256 zroFee) {
+        nativeFee = 0.01 ether;
+        zroFee = 0;
+    }
+    
+    function send(
+        uint16 _dstChainId,
+        bytes calldata _destination,
+        bytes calldata _payload,
+        address payable _refundAddress,
+        address _zroPaymentAddress,
+        bytes calldata _adapterParams
+    ) external payable override returns (bytes memory) {
+        address destEndpoint = destinations[_dstChainId];
+        require(destEndpoint != address(0), "Destination not set");
+        
+        address dstAddress;
+        assembly {
+            dstAddress := mload(add(_destination, 20))
+        }
+        
+        LZEndpointMock(destEndpoint).receivePayload(
+            chainId,
+            abi.encodePacked(msg.sender),
+            dstAddress,
+            0, // nonce doesn't matter for testing
+            100000, // gas limit, doesn't matter for testing
+            _payload
+        );
+        
+        return "";
+    }
+    
+    function receivePayload(
+        uint16 _srcChainId,
+        bytes memory _srcAddress,
+        address _dstAddress,
+        uint64 _nonce,
+        uint256 _gasLimit,
+        bytes memory _payload
+    ) external {
+        address srcAddress;
+        assembly {
+            srcAddress := mload(add(_srcAddress, 20))
+        }
+        
+        ILayerZeroReceiver(_dstAddress).lzReceive(
+            _srcChainId,
+            _srcAddress,
+            _nonce,
+            _payload
+        );
+    }
+    
+    // Implement the remaining interfaces with minimal functionality for testing
+    function getChainId() external view override returns (uint16) {
+        return chainId;
+    }
+    
+    function getConfig(
+        uint16, /* _version */
+        uint16, /* _chainId */
+        address, /* _userApplication */
+        uint256 /* _configType */
+    ) external pure override returns (bytes memory) {
+        return "";
+    }
+
+    function getInboundNonce(uint16, bytes calldata) external pure override returns (uint64) {
+        return 0;
+    }
+
+    function getOutboundNonce(uint16, address) external pure override returns (uint64) {
+        return 0;
+    }
+
+    function hasStoredPayload(uint16, bytes calldata) external pure override returns (bool) {
+        return false;
+    }
+
+    function isReceivingPayload() external pure override returns (bool) {
+        return false;
+    }
+
+    function isSendingPayload() external pure override returns (bool) {
+        return false;
+    }
+
+    function receivePayloadAndRetryAffected(
+        uint16, bytes calldata, address, uint64, uint256, bytes calldata, bytes calldata
+    ) external pure override {}
+
+    function retryPayload(
+        uint16, bytes calldata, bytes calldata
+    ) external pure override {}
+
+    function setConfig(
+        uint16, uint16, address, uint256, bytes calldata
+    ) external pure override {}
+
+    function setSendVersion(uint16) external pure override {}
+
+    function setReceiveVersion(uint16) external pure override {}
+}