Initial commit

test/ccip/CCIPIntegration.t.sol

@@ -0,0 +1,142 @@
+// 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 {CCIPReceiver} from "../../contracts/ccip/CCIPReceiver.sol";
+import {IRouterClient} from "../../contracts/ccip/IRouterClient.sol";
+
+contract CCIPIntegrationTest is Test {
+    CCIPSender public sender;
+    CCIPReceiver public receiver;
+    address public mockRouter;
+    address public linkToken;
+    
+    uint64 constant SOURCE_CHAIN_SELECTOR = 138;
+    uint64 constant TARGET_CHAIN_SELECTOR = 5009297550715157269; // Ethereum Mainnet
+    
+    event MessageSent(bytes32 indexed messageId, uint64 indexed destinationChainSelector, address receiver, bytes data);
+    event MessageReceived(bytes32 indexed messageId, uint64 indexed sourceChainSelector, address sender, bytes data);
+    
+    function setUp() public {
+        // Deploy mock router (in real tests, use actual CCIP Router)
+        mockRouter = address(new MockRouter());
+        linkToken = address(new MockLinkToken());
+        
+        // Deploy sender and receiver
+        address oracleAggregator = address(this);
+        sender = new CCIPSender(mockRouter, oracleAggregator, linkToken);
+        receiver = new CCIPReceiver(mockRouter, address(0)); // Oracle aggregator address
+        
+        // Fund sender with LINK
+        MockLinkToken(linkToken).mint(address(sender), 1000e18);
+    }
+    
+    function testSendMessage() public {
+        // Add destination first
+        sender.addDestination(TARGET_CHAIN_SELECTOR, address(receiver));
+        
+        bytes memory messageData = abi.encode(uint256(25000000000), uint256(1), uint256(block.timestamp));
+        
+        // Send oracle update
+        sender.sendOracleUpdate(TARGET_CHAIN_SELECTOR, 25000000000, 1, block.timestamp);
+    }
+    
+    function testReceiveMessage() public {
+        bytes memory messageData = abi.encode(uint256(25000000000), uint256(1), uint256(block.timestamp));
+        
+        IRouterClient.Any2EVMMessage memory message = IRouterClient.Any2EVMMessage({
+            messageId: keccak256("test"),
+            sourceChainSelector: SOURCE_CHAIN_SELECTOR,
+            sender: abi.encode(address(sender)),
+            data: messageData,
+            tokenAmounts: new IRouterClient.TokenAmount[](0)
+        });
+        
+        vm.prank(mockRouter);
+        receiver.ccipReceive(message);
+        
+        assertTrue(receiver.processedMessages(keccak256("test")));
+    }
+    
+    function testReplayProtection() public {
+        bytes memory messageData = abi.encode(uint256(25000000000), uint256(1), uint256(block.timestamp));
+        
+        IRouterClient.Any2EVMMessage memory message = IRouterClient.Any2EVMMessage({
+            messageId: keccak256("test"),
+            sourceChainSelector: SOURCE_CHAIN_SELECTOR,
+            sender: abi.encode(address(sender)),
+            data: messageData,
+            tokenAmounts: new IRouterClient.TokenAmount[](0)
+        });
+        
+        vm.prank(mockRouter);
+        receiver.ccipReceive(message);
+        
+        // Try to process same message again
+        vm.prank(mockRouter);
+        vm.expectRevert("CCIPReceiver: message already processed");
+        receiver.ccipReceive(message);
+    }
+    
+    function testFeeCalculation() public {
+        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 testInsufficientFee() public {
+        // Add destination first
+        sender.addDestination(TARGET_CHAIN_SELECTOR, address(receiver));
+        
+        // Drain balance to cause insufficient fee
+        MockLinkToken(linkToken).transfer(address(0xdead), 1000e18);
+        
+        vm.expectRevert();
+        sender.sendOracleUpdate(TARGET_CHAIN_SELECTOR, 25000000000, 1, block.timestamp);
+    }
+}
+
+// Mock contracts for testing
+contract MockRouter is IRouterClient {
+    function ccipSend(uint64, EVM2AnyMessage memory) external pure returns (bytes32, uint256) {
+        return (keccak256("mock"), 0.01e18);
+    }
+    
+    function getFee(uint64, EVM2AnyMessage memory) external pure returns (uint256) {
+        return 0.01e18;
+    }
+    
+    function getSupportedTokens(uint64) external pure returns (address[] memory) {
+        return new address[](0);
+    }
+}
+
+contract MockLinkToken {
+    mapping(address => uint256) public balanceOf;
+    
+    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");
+        balanceOf[from] -= amount;
+        balanceOf[to] += amount;
+        return true;
+    }
+    
+    function approve(address, uint256) external pure returns (bool) {
+        return true;
+    }
+}
+