Gho ccip bridge (#7)

diffs/default_before_default_after.md

@@ -1,5 +1,3 @@
-## Emodes changes
-
 ## Raw diff
 
 ```json

diffs/preTestV2RatesUpdates_postTestV2RatesUpdates.md

@@ -11,7 +11,7 @@
 | stableRateSlope1 | 2 % | 69 % |
 | optimalUsageRatio | 90 % | 69 % |
 | maxExcessUsageRatio | 10 % | 31 % |
-| interestRate | ![before](/.assets/23e67c7d46dd80f36d580b243c5716c84080a34f.svg) | ![after](/.assets/64fd6acec636adec0e975e8031f8e3f7fb87bb7d.svg) |
+| interestRate | ![before](https://dash.onaave.com/api/static?variableRateSlope1=65000000000000000000000000&variableRateSlope2=600000000000000000000000000&optimalUsageRatio=900000000000000000000000000&baseVariableBorrowRate=0&maxVariableBorrowRate=undefined) | ![after](https://dash.onaave.com/api/static?variableRateSlope1=420000000000000000000000000&variableRateSlope2=600000000000000000000000000&optimalUsageRatio=690000000000000000000000000&baseVariableBorrowRate=0&maxVariableBorrowRate=undefined) |
 
 ## Raw diff
 

foundry.toml

@@ -7,6 +7,7 @@ libs = ['lib']
 remappings = []
 fs_permissions = [{ access = "read-write", path = "./reports" }]
 ffi = true
+solc = '0.8.20'
 evm_version = 'shanghai'
 
 [profile.zksync]

package.json

@@ -22,6 +22,9 @@
   },
   "homepage": "https://github.com/bgd-labs/aave-helpers#readme",
   "devDependencies": {
+    "@chainlink/contracts": "^1.3.0",
+    "@chainlink/contracts-ccip": "^1.5.0",
+    "@chainlink/local": "^0.2.3",
     "prettier": "^2.8.3",
     "prettier-plugin-solidity": "^1.1.3"
   },

remappings.txt

@@ -3,3 +3,7 @@ aave-v3-origin/=lib/aave-address-book/lib/aave-v3-origin/src/
 aave-v3-origin-tests/=lib/aave-address-book/lib/aave-v3-origin/tests
 forge-std/=lib/forge-std/src/
 solidity-utils/=lib/aave-address-book/lib/aave-v3-origin/lib/solidity-utils/src/
+@chainlink/contracts/=node_modules/@chainlink/contracts
+@chainlink/contracts-ccip/=node_modules/@chainlink/contracts-ccip
+@chainlink/local/=node_modules/@chainlink/local
+

scripts/DeployBridges.s.sol

@@ -6,11 +6,17 @@ import {IERC20} from 'solidity-utils/contracts/oz-common/interfaces/IERC20.sol';
 import {GovernanceV3Ethereum} from 'aave-address-book/GovernanceV3Ethereum.sol';
 import {GovernanceV3Optimism} from 'aave-address-book/GovernanceV3Optimism.sol';
 import {GovernanceV3Polygon} from 'aave-address-book/GovernanceV3Polygon.sol';
+import {GovernanceV3Arbitrum} from 'aave-address-book/GovernanceV3Arbitrum.sol';
+import {AaveV3Ethereum, AaveV3EthereumAssets} from 'aave-address-book/AaveV3Ethereum.sol';
+import {AaveV3Arbitrum, AaveV3ArbitrumAssets} from 'aave-address-book/AaveV3Arbitrum.sol';
+import {MiscEthereum} from 'aave-address-book/MiscEthereum.sol';
+import {MiscArbitrum} from 'aave-address-book/MiscArbitrum.sol';
 import {ArbitrumScript, EthereumScript, OptimismScript, PolygonScript} from 'solidity-utils/contracts/utils/ScriptUtils.sol';
 import {AaveArbEthERC20Bridge} from 'src/bridges/arbitrum/AaveArbEthERC20Bridge.sol';
 import {AavePolEthERC20Bridge} from 'src/bridges/polygon/AavePolEthERC20Bridge.sol';
 import {AavePolEthPlasmaBridge} from 'src/bridges/polygon/AavePolEthPlasmaBridge.sol';
 import {AaveOpEthERC20Bridge} from 'src/bridges/optimism/AaveOpEthERC20Bridge.sol';
+import {AaveCcipGhoBridge} from 'src/bridges/chainlink-ccip/AaveCcipGhoBridge.sol';
 
 contract DeployEthereum is EthereumScript {
   function run() external broadcast {
@@ -60,3 +66,33 @@ contract DeployArbBridgeArbitrum is ArbitrumScript {
     new AaveArbEthERC20Bridge{salt: salt}(0x3765A685a401622C060E5D700D9ad89413363a91);
   }
 }
+
+contract DeployAaveCcipGhoBridgeEthereum is EthereumScript {
+  // https://etherscan.io/address/0x80226fc0Ee2b096224EeAc085Bb9a8cba1146f7D
+  address constant CCIP_ROUTER_ETHEREUM = 0x80226fc0Ee2b096224EeAc085Bb9a8cba1146f7D; // ccip router address
+
+  function run() external broadcast {
+    bytes32 salt = 'GHO Chainlink CCIP Bridge';
+    new AaveCcipGhoBridge{salt: salt}(
+      CCIP_ROUTER_ETHEREUM,
+      AaveV3EthereumAssets.GHO_UNDERLYING,
+      address(AaveV3Ethereum.COLLECTOR),
+      GovernanceV3Ethereum.EXECUTOR_LVL_1
+    );
+  }
+}
+
+contract DeployAaveCcipGhoBridgeArbitrum is ArbitrumScript {
+  // https://arbiscan.io/address/0x141fa059441E0ca23ce184B6A78bafD2A517DdE8
+  address constant CCIP_ROUTER_ARBITRUM = 0x141fa059441E0ca23ce184B6A78bafD2A517DdE8; // ccip router address
+
+  function run() external broadcast {
+    bytes32 salt = 'GHO Chainlink CCIP Bridge';
+    new AaveCcipGhoBridge{salt: salt}(
+      CCIP_ROUTER_ARBITRUM,
+      AaveV3ArbitrumAssets.GHO_UNDERLYING,
+      address(AaveV3Arbitrum.COLLECTOR),
+      GovernanceV3Arbitrum.EXECUTOR_LVL_1
+    );
+  }
+}

src/bridges/chainlink-ccip/AaveCcipGhoBridge.sol

@@ -0,0 +1,293 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import {IERC20} from 'solidity-utils/contracts/oz-common/interfaces/IERC20.sol';
+import {SafeERC20} from 'solidity-utils/contracts/oz-common/SafeERC20.sol';
+import {Rescuable} from 'solidity-utils/contracts/utils/Rescuable.sol';
+import {RescuableBase, IRescuableBase} from 'solidity-utils/contracts/utils/RescuableBase.sol';
+import {AccessControl, IAccessControl} from 'aave-v3-origin/contracts/dependencies/openzeppelin/contracts/AccessControl.sol';
+import {CCIPReceiver, IAny2EVMMessageReceiver, IERC165} from '@chainlink/contracts-ccip/src/v0.8/ccip/applications/CCIPReceiver.sol';
+import {IRouterClient} from '@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol';
+import {Client} from '@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol';
+
+import {IAaveCcipGhoBridge} from './IAaveCcipGhoBridge.sol';
+
+/**
+ * @title AaveCcipGhoBridge
+ * @author LucasWongC
+ * @notice Helper contract to bridge GHO using Chainlink CCIP
+ * @dev Sends GHO to AAVE collector of destination chain using chainlink CCIP
+ */
+contract AaveCcipGhoBridge is IAaveCcipGhoBridge, CCIPReceiver, AccessControl, Rescuable {
+  using SafeERC20 for IERC20;
+
+  /// @dev This role defines which users can call bridge functions.
+  bytes32 public constant BRIDGER_ROLE = keccak256('BRIDGER_ROLE');
+
+  /// @dev Chainlink CCIP router address
+  address public immutable ROUTER;
+  /// @dev GHO token address
+  address public immutable GHO;
+  /// @dev Aave Collector address
+  address public immutable COLLECTOR;
+  /// @dev Aave Executor address
+  address public immutable EXECUTOR;
+
+  /// @dev Address of bridge (chainSelector => bridge address)
+  mapping(uint64 selector => address bridge) public bridges;
+
+  /// @dev Saves invalid message
+  mapping(bytes32 messageId => Client.EVMTokenAmount[] message) private invalidTokenTransfers;
+  /// @dev Saves state of invalid message.
+  mapping(bytes32 messageId => bool failed) public isInvalidMessage;
+
+  /// @dev Checks if the destination bridge has been set up
+  modifier checkDestination(uint64 chainSelector) {
+    if (bridges[chainSelector] == address(0)) {
+      revert UnsupportedChain();
+    }
+    _;
+  }
+
+  /// @dev Checks if invalid message exists
+  modifier checkInvalidMessage(bytes32 messageId) {
+    if (!isInvalidMessage[messageId]) {
+      revert MessageNotFound();
+    }
+    _;
+  }
+
+  /**
+   * @dev Modifier to allow only the contract itself to execute a function.
+   *      Throws an exception if called by any account other than the contract itself.
+   */
+  modifier onlySelf() {
+    if (msg.sender != address(this)) revert OnlySelf();
+    _;
+  }
+
+  /**
+   * @param _router The address of the Chainlink CCIP router
+   * @param _gho The address of the GHO token
+   * @param _collector The address of collector on same chain
+   * @param _executor The address of the contract executor
+   */
+  constructor(
+    address _router,
+    address _gho,
+    address _collector,
+    address _executor
+  ) CCIPReceiver(_router) {
+    ROUTER = _router;
+    GHO = _gho;
+    COLLECTOR = _collector;
+    EXECUTOR = _executor;
+
+    _setupRole(DEFAULT_ADMIN_ROLE, _executor);
+  }
+
+  /**
+   * @dev See {IERC165-supportsInterface}.
+   */
+  function supportsInterface(
+    bytes4 interfaceId
+  ) public pure virtual override(AccessControl, CCIPReceiver) returns (bool) {
+    return
+      interfaceId == type(IAccessControl).interfaceId ||
+      interfaceId == type(IAny2EVMMessageReceiver).interfaceId ||
+      interfaceId == type(IERC165).interfaceId;
+  }
+
+  /// @inheritdoc IAaveCcipGhoBridge
+  function bridge(
+    uint64 destinationChainSelector,
+    uint256 amount,
+    uint256 gasLimit,
+    address feeToken
+  )
+    external
+    payable
+    checkDestination(destinationChainSelector)
+    onlyRole(BRIDGER_ROLE)
+    returns (bytes32 messageId)
+  {
+    Client.EVM2AnyMessage memory message = _buildCCIPMessage(
+      destinationChainSelector,
+      amount,
+      gasLimit,
+      feeToken
+    );
+
+    uint256 fee = IRouterClient(ROUTER).getFee(destinationChainSelector, message);
+
+    uint256 inBalance = IERC20(GHO).balanceOf(address(this));
+    uint256 totalGhoAmount = amount;
+
+    if (feeToken == address(0)) {
+      if (msg.value < fee) revert InsufficientNativeFee();
+    } else if (feeToken == GHO) {
+      totalGhoAmount += fee;
+    } else {
+      revert InvalidFeeToken();
+    }
+
+    if (inBalance < totalGhoAmount) {
+      IERC20(GHO).transferFrom(msg.sender, address(this), totalGhoAmount - inBalance);
+    }
+    IERC20(GHO).approve(ROUTER, totalGhoAmount);
+
+    messageId = IRouterClient(ROUTER).ccipSend{value: feeToken == address(0) ? fee : 0}(
+      destinationChainSelector,
+      message
+    );
+
+    if (feeToken == address(0)) {
+      if (msg.value > fee) {
+        payable(msg.sender).call{value: msg.value - fee}('');
+      }
+    } else {
+      payable(msg.sender).call{value: msg.value}('');
+    }
+
+    emit TransferIssued(messageId, destinationChainSelector, msg.sender, amount);
+  }
+
+  /// @inheritdoc IAaveCcipGhoBridge
+  function quoteBridge(
+    uint64 destinationChainSelector,
+    uint256 amount,
+    uint256 gasLimit,
+    address feeToken
+  ) external view checkDestination(destinationChainSelector) returns (uint256 fee) {
+    Client.EVM2AnyMessage memory message = _buildCCIPMessage(
+      destinationChainSelector,
+      amount,
+      gasLimit,
+      feeToken
+    );
+
+    fee = IRouterClient(ROUTER).getFee(destinationChainSelector, message);
+  }
+
+  /**
+   * @dev Builds ccip message for token transfer
+   */
+  function _buildCCIPMessage(
+    uint64 destinationChainSelector,
+    uint256 amount,
+    uint256 gasLimit,
+    address feeToken
+  ) internal view returns (Client.EVM2AnyMessage memory message) {
+    if (amount == 0) {
+      revert InvalidTransferAmount();
+    }
+    Client.EVMTokenAmount[] memory tokenAmounts = new Client.EVMTokenAmount[](1);
+    tokenAmounts[0] = Client.EVMTokenAmount({token: GHO, amount: amount});
+
+    message = Client.EVM2AnyMessage({
+      receiver: abi.encode(bridges[destinationChainSelector]),
+      data: '',
+      tokenAmounts: tokenAmounts,
+      extraArgs: gasLimit == 0
+        ? bytes('')
+        : Client._argsToBytes(
+          Client.EVMExtraArgsV2({gasLimit: gasLimit, allowOutOfOrderExecution: false})
+        ),
+      feeToken: feeToken
+    });
+  }
+
+  /// @inheritdoc CCIPReceiver
+  function ccipReceive(Client.Any2EVMMessage calldata message) external override onlyRouter {
+    try this.processMessage(message) {} catch {
+      bytes32 messageId = message.messageId;
+
+      Client.EVMTokenAmount[] memory tokenAmounts = message.destTokenAmounts;
+      uint256 length = tokenAmounts.length;
+      for (uint256 i = 0; i < length; ++i) {
+        invalidTokenTransfers[messageId].push(tokenAmounts[i]);
+      }
+      isInvalidMessage[messageId] = true;
+
+      emit ReceivedInvalidMessage(messageId);
+    }
+  }
+
+  /// @dev wrap _ccipReceive as a external function
+  function processMessage(Client.Any2EVMMessage calldata message) external onlySelf {
+    if (bridges[message.sourceChainSelector] != abi.decode(message.sender, (address))) {
+      revert();
+    }
+
+    _ccipReceive(message);
+  }
+
+  /// @inheritdoc CCIPReceiver
+  function _ccipReceive(Client.Any2EVMMessage memory message) internal override {
+    uint256 ghoAmount = message.destTokenAmounts[0].amount;
+
+    IERC20(GHO).transfer(COLLECTOR, ghoAmount);
+
+    emit TransferFinished(message.messageId, COLLECTOR, ghoAmount);
+  }
+
+  /// @inheritdoc IAaveCcipGhoBridge
+  function getInvalidMessage(
+    bytes32 messageId
+  )
+    external
+    view
+    checkInvalidMessage(messageId)
+    returns (Client.EVMTokenAmount[] memory tokenAmounts)
+  {
+    uint256 length = invalidTokenTransfers[messageId].length;
+    tokenAmounts = new Client.EVMTokenAmount[](length);
+
+    for (uint256 i = 0; i < length; ++i) {
+      tokenAmounts[i] = invalidTokenTransfers[messageId][i];
+    }
+  }
+
+  /// @inheritdoc IAaveCcipGhoBridge
+  function handleInvalidMessage(
+    bytes32 messageId
+  ) external onlyRole(DEFAULT_ADMIN_ROLE) checkInvalidMessage(messageId) {
+    isInvalidMessage[messageId] = false;
+
+    Client.EVMTokenAmount[] memory tokenAmounts = invalidTokenTransfers[messageId];
+    uint256 length = tokenAmounts.length;
+    for (uint256 i = 0; i < length; ++i) {
+      IERC20(tokenAmounts[i].token).safeTransfer(COLLECTOR, tokenAmounts[i].amount);
+    }
+
+    emit HandledInvalidMessage(messageId);
+  }
+
+  /**
+   * @notice Set up destination bridge data
+   * @param _destinationChainSelector The selector of the destination chain
+   *        chain selector can be found https://docs.chain.link/ccip/supported-networks/v1_2_0/mainnet
+   * @param _bridge The address of the bridge deployed on destination chain
+   */
+  function setDestinationBridge(
+    uint64 _destinationChainSelector,
+    address _bridge
+  ) external onlyRole(DEFAULT_ADMIN_ROLE) {
+    bridges[_destinationChainSelector] = _bridge;
+
+    emit DestinationUpdated(_destinationChainSelector, _bridge);
+  }
+
+  /// @inheritdoc Rescuable
+  function whoCanRescue() public view override returns (address) {
+    return EXECUTOR;
+  }
+
+  /// @inheritdoc IRescuableBase
+  function maxRescue(
+    address
+  ) public pure override(RescuableBase, IRescuableBase) returns (uint256) {
+    return type(uint256).max;
+  }
+}