smom-dbis-138/test/ccip/CCIPFees.t.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import {Test, console} from "forge-std/Test.sol";
import {CCIPSender} from "../../contracts/ccip/CCIPSender.sol";
import {IRouterClient} from "../../contracts/ccip/IRouterClient.sol";

contract CCIPFeesTest is Test {
    CCIPSender public sender;
    address public mockRouter;
    address public linkToken;
    
    uint64 constant TARGET_CHAIN_SELECTOR = 5009297550715157269;
    
    function setUp() public {
        mockRouter = address(new MockRouter());
        linkToken = address(new MockLinkToken());
        
        address oracleAggregator = address(this);
        sender = new CCIPSender(mockRouter, oracleAggregator, linkToken);
        // Mint LINK to sender for fee payment
        MockLinkToken(linkToken).mint(address(sender), 1000e18);
        // Mint LINK to aggregator (test contract) - aggregator pays fees via transferFrom
        MockLinkToken(linkToken).mint(address(this), 1000e18);
    }
    
    function testFeeCalculation() public {
        // Add destination first
        address receiver = address(0x123);
        sender.addDestination(TARGET_CHAIN_SELECTOR, receiver);
        
        bytes memory messageData = abi.encode(uint256(25000000000), uint256(1), uint256(block.timestamp));
        
        uint256 fee = sender.calculateFee(TARGET_CHAIN_SELECTOR, messageData);
        
        assertGt(fee, 0, "Fee should be greater than 0");
    }
    
    function testFeeProportionalToMessageSize() public {
        // Add destination first
        address receiver = address(0x123);
        sender.addDestination(TARGET_CHAIN_SELECTOR, receiver);
        
        bytes memory smallMessage = abi.encode(uint256(25000000000));
        bytes memory largeMessage = abi.encode(uint256(25000000000), uint256(1), uint256(block.timestamp), bytes("additional data"));
        
        uint256 smallFee = sender.calculateFee(TARGET_CHAIN_SELECTOR, smallMessage);
        uint256 largeFee = sender.calculateFee(TARGET_CHAIN_SELECTOR, largeMessage);
        
        assertGe(largeFee, smallFee, "Larger message should cost at least as much");
    }
    
    function testFeePayment() public {
        // Add destination first
        address receiver = address(0x123);
        sender.addDestination(TARGET_CHAIN_SELECTOR, receiver);
        
        // Approve sender to transfer LINK from aggregator (test contract)
        MockLinkToken(linkToken).approve(address(sender), 1000e18);
        
        uint256 balanceBefore = MockLinkToken(linkToken).balanceOf(address(this));
        
        sender.sendOracleUpdate(TARGET_CHAIN_SELECTOR, 25000000000, 1, block.timestamp);
        
        uint256 balanceAfter = MockLinkToken(linkToken).balanceOf(address(this));
        
        // Fee should be deducted from aggregator (approximate check)
        assertLe(balanceAfter, balanceBefore, "Fee should be deducted from balance");
    }
    
    function testInsufficientFee() public {
        // Add destination first
        address receiver = address(0x123);
        sender.addDestination(TARGET_CHAIN_SELECTOR, receiver);
        
        // Drain aggregator's balance to cause insufficient fee
        MockLinkToken(linkToken).transfer(address(0xdead), 1000e18);
        
        vm.expectRevert();
        sender.sendOracleUpdate(TARGET_CHAIN_SELECTOR, 25000000000, 1, block.timestamp);
    }
    
    function testExcessiveFee() public {
        // Add destination first
        address receiver = address(0x123);
        sender.addDestination(TARGET_CHAIN_SELECTOR, receiver);
        
        // Approve sender to transfer LINK from aggregator (test contract)
        MockLinkToken(linkToken).approve(address(sender), 1000e18);
        
        // Should work with sufficient balance
        sender.sendOracleUpdate(TARGET_CHAIN_SELECTOR, 25000000000, 1, block.timestamp);
    }
}

contract MockRouter is IRouterClient {
    function ccipSend(uint64, EVM2AnyMessage memory) external payable returns (bytes32, uint256) {
        return (keccak256("mock"), 0.01e18);
    }
    
    function getFee(uint64, EVM2AnyMessage memory) external pure returns (uint256) {
        // Mock fee calculation: 0.01 LINK base
        return 0.01e18;
    }
    
    function getSupportedTokens(uint64) external pure returns (address[] memory) {
        return new address[](0);
    }
}

contract MockLinkToken {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    
    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }
    
    function transfer(address to, uint256 amount) external returns (bool) {
        require(balanceOf[msg.sender] >= amount, "Insufficient balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }
    
    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(balanceOf[from] >= amount, "Insufficient balance");
        require(allowance[from][msg.sender] >= amount, "Insufficient allowance");
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        allowance[from][msg.sender] -= amount;
        return true;
    }
    
    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }
}