Initial commit

This commit is contained in:
defiQUG
2025-12-12 14:56:07 -08:00
commit a1466e4005
15 changed files with 2523 additions and 0 deletions

View File

@@ -0,0 +1,115 @@
// 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 CCIPErrorHandlingTest is Test {
CCIPSender public sender;
CCIPReceiver public receiver;
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); // Use test contract as aggregator
sender = new CCIPSender(mockRouter, oracleAggregator, linkToken);
receiver = new CCIPReceiver(mockRouter, address(0));
MockLinkToken(linkToken).mint(address(sender), 1000e18);
}
function testInvalidMessageFormat() public {
bytes memory invalidData = "invalid";
IRouterClient.Any2EVMMessage memory message = IRouterClient.Any2EVMMessage({
messageId: keccak256("test"),
sourceChainSelector: 138,
sender: abi.encode(address(sender)),
data: invalidData,
tokenAmounts: new IRouterClient.TokenAmount[](0)
});
vm.prank(mockRouter);
// Should handle invalid format gracefully
try receiver.ccipReceive(message) {
// If it doesn't revert, that's also acceptable if error handling is implemented
} catch {
// Expected to revert on invalid format
}
}
function testUnauthorizedSender() public {
bytes memory messageData = abi.encode(uint256(25000000000), uint256(1), uint256(block.timestamp));
IRouterClient.Any2EVMMessage memory message = IRouterClient.Any2EVMMessage({
messageId: keccak256("test"),
sourceChainSelector: 138,
sender: abi.encode(address(0x123)), // Unauthorized sender
data: messageData,
tokenAmounts: new IRouterClient.TokenAmount[](0)
});
vm.prank(mockRouter);
// Should reject unauthorized sender
receiver.ccipReceive(message);
}
function testRouterOnlyAccess() public {
bytes memory messageData = abi.encode(uint256(25000000000), uint256(1), uint256(block.timestamp));
IRouterClient.Any2EVMMessage memory message = IRouterClient.Any2EVMMessage({
messageId: keccak256("test"),
sourceChainSelector: 138,
sender: abi.encode(address(sender)),
data: messageData,
tokenAmounts: new IRouterClient.TokenAmount[](0)
});
// Try to call from non-router address
vm.expectRevert("CCIPReceiver: only router");
receiver.ccipReceive(message);
}
function testInsufficientLinkBalance() public {
// Add destination first
sender.addDestination(TARGET_CHAIN_SELECTOR, address(receiver));
// Drain LINK balance
MockLinkToken(linkToken).transfer(address(0xdead), 1000e18);
bytes memory messageData = abi.encode(uint256(25000000000), uint256(1), uint256(block.timestamp));
// Should revert due to insufficient balance
vm.expectRevert();
sender.sendOracleUpdate(TARGET_CHAIN_SELECTOR, 25000000000, 1, block.timestamp);
}
}
contract MockRouter {
function send(uint64, bytes memory) external pure returns (bytes32) {
return bytes32(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;
}
}

View File

@@ -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;
}
}