Add Oracle Aggregator and CCIP Integration

- Introduced Aggregator.sol for Chainlink-compatible oracle functionality, including round-based updates and access control.
- Added OracleWithCCIP.sol to extend Aggregator with CCIP cross-chain messaging capabilities.
- Created .gitmodules to include OpenZeppelin contracts as a submodule.
- Developed a comprehensive deployment guide in NEXT_STEPS_COMPLETE_GUIDE.md for Phase 2 and smart contract deployment.
- Implemented Vite configuration for the orchestration portal, supporting both Vue and React frameworks.
- Added server-side logic for the Multi-Cloud Orchestration Portal, including API endpoints for environment management and monitoring.
- Created scripts for resource import and usage validation across non-US regions.
- Added tests for CCIP error handling and integration to ensure robust functionality.
- Included various new files and directories for the orchestration portal and deployment scripts.
This commit is contained in:
defiQUG
2025-12-12 14:57:48 -08:00
parent a1466e4005
commit 1fb7266469
1720 changed files with 241279 additions and 16 deletions

108
test/ccip/CCIPFees.t.sol Normal file
View File

@@ -0,0 +1,108 @@
// 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);
MockLinkToken(linkToken).mint(address(sender), 1000e18);
}
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 testFeeProportionalToMessageSize() public {
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);
uint256 balanceBefore = MockLinkToken(linkToken).balanceOf(address(sender));
sender.sendOracleUpdate(TARGET_CHAIN_SELECTOR, 25000000000, 1, block.timestamp);
uint256 balanceAfter = MockLinkToken(linkToken).balanceOf(address(sender));
// Fee should be deducted (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 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);
// 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;
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

@@ -38,7 +38,7 @@ contract CCIPIntegrationTest is Test {
bytes memory messageData = abi.encode(uint256(25000000000), uint256(1), uint256(block.timestamp));
// Send oracle update
// Send oracle update (must be called by aggregator, which is address(this) in setUp)
sender.sendOracleUpdate(TARGET_CHAIN_SELECTOR, 25000000000, 1, block.timestamp);
}
@@ -94,6 +94,7 @@ contract CCIPIntegrationTest is Test {
// Drain balance to cause insufficient fee
MockLinkToken(linkToken).transfer(address(0xdead), 1000e18);
// Must be called by aggregator (address(this) in setUp)
vm.expectRevert();
sender.sendOracleUpdate(TARGET_CHAIN_SELECTOR, 25000000000, 1, block.timestamp);
}
@@ -101,7 +102,7 @@ contract CCIPIntegrationTest is Test {
// Mock contracts for testing
contract MockRouter is IRouterClient {
function ccipSend(uint64, EVM2AnyMessage memory) external pure returns (bytes32, uint256) {
function ccipSend(uint64, EVM2AnyMessage memory) external payable returns (bytes32, uint256) {
return (keccak256("mock"), 0.01e18);
}

161
test/ccip/OracleCCIP.t.sol Normal file
View File

@@ -0,0 +1,161 @@
// 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 {Aggregator} from "../../contracts/oracle/Aggregator.sol";
import {IRouterClient} from "../../contracts/ccip/IRouterClient.sol";
contract OracleCCIPTest is Test {
CCIPSender public sender;
CCIPReceiver public receiver;
Aggregator public aggregator;
address public mockRouter;
address public linkToken;
uint64 constant TARGET_CHAIN_SELECTOR = 5009297550715157269;
function setUp() public {
mockRouter = address(new MockRouter());
linkToken = address(new MockLinkToken());
aggregator = new Aggregator("ETH/USD", address(this), 60, 50);
address oracleAggregator = address(aggregator);
sender = new CCIPSender(mockRouter, oracleAggregator, linkToken);
receiver = new CCIPReceiver(mockRouter, address(aggregator));
// Add receiver as transmitter
aggregator.addTransmitter(address(receiver));
// Mint LINK tokens to aggregator (since aggregator will pay fees)
MockLinkToken(linkToken).mint(address(aggregator), 1000e18);
// Also mint to sender for fee calculations
MockLinkToken(linkToken).mint(address(sender), 1000e18);
}
function testCrossChainOracleUpdate() public {
uint256 price = 25000000000; // $250.00
uint256 roundId = 1;
uint256 timestamp = block.timestamp;
// Add destination first
sender.addDestination(TARGET_CHAIN_SELECTOR, address(receiver));
// Approve sender to spend aggregator's LINK tokens
vm.prank(address(aggregator));
MockLinkToken(linkToken).approve(address(sender), 1000e18);
// Send oracle update (must be called by aggregator)
vm.prank(address(aggregator));
sender.sendOracleUpdate(TARGET_CHAIN_SELECTOR, price, roundId, timestamp);
// Encode message data
bytes memory messageData = abi.encode(price, roundId, timestamp);
// Simulate message delivery
IRouterClient.Any2EVMMessage memory message = IRouterClient.Any2EVMMessage({
messageId: keccak256("test"),
sourceChainSelector: 138,
sender: abi.encode(address(sender)),
data: messageData,
tokenAmounts: new IRouterClient.TokenAmount[](0)
});
vm.prank(mockRouter);
receiver.ccipReceive(message);
// Verify oracle was updated
(uint80 roundIdResult, int256 answerResult, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) = aggregator.latestRoundData();
assertEq(uint256(answerResult), price, "Oracle price should match");
assertEq(uint256(roundIdResult), roundId, "Round ID should match");
}
function testMultipleOracleUpdates() public {
// Add destination first
sender.addDestination(TARGET_CHAIN_SELECTOR, address(receiver));
uint256[] memory prices = new uint256[](3);
prices[0] = 25000000000;
prices[1] = 25100000000;
prices[2] = 25200000000;
for (uint256 i = 0; i < prices.length; i++) {
uint256 roundId = i + 1;
uint256 timestamp = block.timestamp + i;
// Approve sender to spend aggregator's LINK tokens (reset to zero first to avoid non-zero to non-zero error)
vm.startPrank(address(aggregator));
MockLinkToken(linkToken).approve(address(sender), 0);
MockLinkToken(linkToken).approve(address(sender), 1000e18);
vm.stopPrank();
// Send oracle update (must be called by aggregator)
vm.prank(address(aggregator));
sender.sendOracleUpdate(TARGET_CHAIN_SELECTOR, prices[i], roundId, timestamp);
// Encode message data
bytes memory messageData = abi.encode(prices[i], roundId, timestamp);
// Simulate delivery
IRouterClient.Any2EVMMessage memory message = IRouterClient.Any2EVMMessage({
messageId: keccak256(abi.encode(i)),
sourceChainSelector: 138,
sender: abi.encode(address(sender)),
data: messageData,
tokenAmounts: new IRouterClient.TokenAmount[](0)
});
vm.prank(mockRouter);
receiver.ccipReceive(message);
}
(uint80 roundIdResult, int256 answerResult,,,) = aggregator.latestRoundData();
assertEq(uint256(answerResult), prices[2], "Latest price should be last update");
}
}
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) {
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;
}
}