Feat/productionize examples

contracts/src/v0.8/ccip/production-examples/CCIPClient.sol

@@ -0,0 +1,99 @@
+pragma solidity ^0.8.0;
+
+import {IERC20} from "../../vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "../../vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import {CCIPReceiverWithACK} from "./CCIPReceiverWithACK.sol";
+
+import {IRouterClient} from "../interfaces/IRouterClient.sol";
+import {Client} from "../libraries/Client.sol";
+
+contract CCIPClient is CCIPReceiverWithACK {
+  using SafeERC20 for IERC20;
+
+  error InvalidConfig();
+  error CannotAcknowledgeUnsentMessage(bytes32);
+
+  /// @notice You can't import CCIPReceiver and Sender due to similar parents so functionality of CCIPSender is duplicated here
+  constructor(address router, IERC20 feeToken) CCIPReceiverWithACK(router, feeToken) {}
+
+  function ccipSend(
+    uint64 destChainSelector,
+    Client.EVMTokenAmount[] memory tokenAmounts,
+    bytes memory data,
+    address feeToken
+  ) public payable validChain(destChainSelector) returns (bytes32 messageId) {
+    Client.EVM2AnyMessage memory message = Client.EVM2AnyMessage({
+      receiver: s_chains[destChainSelector],
+      data: data,
+      tokenAmounts: tokenAmounts,
+      extraArgs: s_extraArgsBytes[destChainSelector],
+      feeToken: feeToken
+    });
+
+    uint256 fee = IRouterClient(i_ccipRouter).getFee(destChainSelector, message);
+
+    bool sendingFeeTokenNormally;
+
+    for (uint256 i = 0; i < tokenAmounts.length; ++i) {
+      // Transfer the tokens to pay for tokens in tokenAmounts
+      IERC20(tokenAmounts[i].token).safeTransferFrom(msg.sender, address(this), tokenAmounts[i].amount);
+
+      // If they are sending the feeToken through, and its the same as the ack fee token, and also paying in it, then you don't need to approve
+      // it at all cause its already set as type(uint).max. You can't use safeIncreaseAllowance() either cause it will overflow the token allowance
+      if (tokenAmounts[i].token == feeToken && feeToken != address(0) && feeToken == address(s_feeToken)) {
+        sendingFeeTokenNormally = true;
+        IERC20(tokenAmounts[i].token).safeTransferFrom(msg.sender, address(this), fee);
+      }
+      // If they're not sending the fee token, then go ahead and approve
+      else {
+        IERC20(tokenAmounts[i].token).safeApprove(i_ccipRouter, tokenAmounts[i].amount);
+      }
+    }
+
+    // Since the fee token was already set in the ReceiverWithACK parent, we don't need to approve it to spend, only to ensure we have enough
+    // funds for the transfer
+    if (!sendingFeeTokenNormally && feeToken == address(s_feeToken) && feeToken != address(0)) {
+      IERC20(feeToken).safeTransferFrom(msg.sender, address(this), fee);
+    } else if (feeToken == address(0) && msg.value < fee) {
+      revert IRouterClient.InsufficientFeeTokenAmount();
+    }
+
+    messageId =
+      IRouterClient(i_ccipRouter).ccipSend{value: feeToken == address(0) ? fee : 0}(destChainSelector, message);
+
+    s_messageStatus[messageId] = CCIPReceiverWithACK.MessageStatus.SENT;
+
+    // Since the message was outgoing, and not ACK, use bytes32(0) to reflect this
+    emit MessageSent(messageId, bytes32(0));
+
+    return messageId;
+  }
+
+  /// CCIPReceiver processMessage to make easier to modify
+  /// @notice function requres that
+  function processMessage(Client.Any2EVMMessage calldata message) external virtual override onlySelf {
+    (MessagePayload memory payload) = abi.decode(message.data, (MessagePayload));
+
+    if (payload.messageType == MessageType.OUTGOING) {
+      // Insert Processing workflow here.
+
+      // If the message was outgoing, then send an ack response.
+      _sendAck(message);
+    } else if (payload.messageType == MessageType.ACK) {
+      // Decode message into the magic-bytes and the messageId to ensure the message is encoded correctly
+      (bytes memory magicBytes, bytes32 messageId) = abi.decode(payload.data, (bytes, bytes32));
+
+      // Ensure Ack Message contains proper magic-bytes
+      if (keccak256(magicBytes) != keccak256(ACKMESSAGEMAGICBYTES)) revert InvalidMagicBytes();
+
+      // Make sure the ACK message was originally sent by this contract
+      if (s_messageStatus[messageId] != MessageStatus.SENT) revert CannotAcknowledgeUnsentMessage(messageId);
+
+      // Mark the message has finalized from a proper ack-message.
+      s_messageStatus[messageId] = MessageStatus.ACKNOWLEDGED;
+
+      emit MessageAckReceived(messageId);
+    }
+  }
+}

contracts/src/v0.8/ccip/production-examples/CCIPClientBase.sol

@@ -0,0 +1,100 @@
+pragma solidity ^0.8.0;
+
+import {OwnerIsCreator} from "../../shared/access/OwnerIsCreator.sol";
+
+import {IERC20} from "../../vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "../../vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/utils/SafeERC20.sol";
+import {Address} from "../../vendor/openzeppelin-solidity/v4.8.3/contracts/utils/Address.sol";
+
+import {ICCIPClientBase} from "./interfaces/ICCIPClientBase.sol";
+
+abstract contract CCIPClientBase is ICCIPClientBase, OwnerIsCreator {
+  using SafeERC20 for IERC20;
+  using Address for address;
+
+  address internal immutable i_ccipRouter;
+
+  mapping(uint64 destChainSelector => mapping(bytes sender => bool approved)) public s_approvedSenders;
+  mapping(uint64 destChainSelector => bytes recipient) public s_chains;
+  mapping(uint64 destChainselector => bytes extraArgsBytes) public s_extraArgsBytes;
+
+  constructor(address router) {
+    if (router == address(0)) revert InvalidRouter(address(0));
+    i_ccipRouter = router;
+  }
+
+  /////////////////////////////////////////////////////////////////////
+  // Router Management
+  /////////////////////////////////////////////////////////////////////
+
+  function getRouter() public view returns (address) {
+    return i_ccipRouter;
+  }
+
+  /// @dev only calls from the set router are accepted.
+  modifier onlyRouter() {
+    if (msg.sender != getRouter()) revert InvalidRouter(msg.sender);
+    _;
+  }
+
+  /////////////////////////////////////////////////////////////////////
+  // Sender/Receiver Management
+  /////////////////////////////////////////////////////////////////////
+
+  function updateApprovedSenders(
+    approvedSenderUpdate[] calldata adds,
+    approvedSenderUpdate[] calldata removes
+  ) external onlyOwner {
+    for (uint256 i = 0; i < removes.length; ++i) {
+      delete s_approvedSenders[removes[i].destChainSelector][removes[i].sender];
+    }
+
+    for (uint256 i = 0; i < adds.length; ++i) {
+      s_approvedSenders[adds[i].destChainSelector][adds[i].sender] = true;
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////
+  // Fee Token Management
+  /////////////////////////////////////////////////////////////////////
+
+  fallback() external payable {}
+  receive() external payable {}
+
+  function withdrawNativeToken(address payable to, uint256 amount) external onlyOwner {
+    Address.sendValue(to, amount);
+  }
+
+  function withdrawTokens(address token, address to, uint256 amount) external onlyOwner {
+    IERC20(token).safeTransfer(to, amount);
+  }
+
+  /////////////////////////////////////////////////////////////////////
+  // Chain Management
+  /////////////////////////////////////////////////////////////////////
+
+  function enableChain(
+    uint64 chainSelector,
+    bytes calldata recipient,
+    bytes calldata extraArgsBytes
+  ) external onlyOwner {
+    s_chains[chainSelector] = recipient;
+
+    if (extraArgsBytes.length != 0) s_extraArgsBytes[chainSelector] = extraArgsBytes;
+  }
+
+  function disableChain(uint64 chainSelector) external onlyOwner {
+    delete s_chains[chainSelector];
+    delete s_extraArgsBytes[chainSelector];
+  }
+
+  modifier validChain(uint64 chainSelector) {
+    if (s_chains[chainSelector].length == 0) revert InvalidChain(chainSelector);
+    _;
+  }
+
+  modifier validSender(uint64 chainSelector, bytes memory sender) {
+    if (!s_approvedSenders[chainSelector][sender]) revert InvalidSender(sender);
+    _;
+  }
+}

contracts/src/v0.8/ccip/production-examples/CCIPReceiver.sol

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {Client} from "../libraries/Client.sol";
+import {CCIPClientBase} from "./CCIPClientBase.sol";
+
+import {IERC20} from "../../vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "../../vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/utils/SafeERC20.sol";
+import {EnumerableMap} from "../../vendor/openzeppelin-solidity/v4.8.3/contracts/utils/structs/EnumerableMap.sol";
+
+contract CCIPReceiver is CCIPClientBase {
+  using SafeERC20 for IERC20;
+  using EnumerableMap for EnumerableMap.Bytes32ToUintMap;
+
+  error OnlySelf();
+  error ErrorCase();
+  error MessageNotFailed(bytes32 messageId);
+
+  event MessageFailed(bytes32 indexed messageId, bytes reason);
+  event MessageSucceeded(bytes32 indexed messageId);
+  event MessageRecovered(bytes32 indexed messageId);
+
+  // Example error code, could have many different error codes.
+  enum ErrorCode {
+    // RESOLVED is first so that the default value is resolved.
+    RESOLVED,
+    // Could have any number of error codes here.
+    FAILED
+  }
+
+  // The message contents of failed messages are stored here.
+  mapping(bytes32 messageId => Client.Any2EVMMessage contents) internal s_messageContents;
+
+  // Contains failed messages and their state.
+  EnumerableMap.Bytes32ToUintMap internal s_failedMessages;
+
+  bool internal s_simRevert;
+
+  constructor(address router) CCIPClientBase(router) {}
+
+  /// @notice The entrypoint for the CCIP router to call. This function should
+  /// never revert, all errors should be handled internally in this contract.
+  /// @param message The message to process.
+  /// @dev Extremely important to ensure only router calls this.
+  function ccipReceive(Client.Any2EVMMessage calldata message)
+    external
+    virtual
+    onlyRouter
+    validChain(message.sourceChainSelector)
+  {
+    try this.processMessage(message) {}
+    catch (bytes memory err) {
+      // Could set different error codes based on the caught error. Each could be
+      // handled differently.
+      s_failedMessages.set(message.messageId, uint256(ErrorCode.FAILED));
+
+      s_messageContents[message.messageId] = message;
+
+      // Don't revert so CCIP doesn't revert. Emit event instead.
+      // The message can be retried later without having to do manual execution of CCIP.
+      emit MessageFailed(message.messageId, err);
+      return;
+    }
+
+    emit MessageSucceeded(message.messageId);
+  }
+
+  /// @notice This function the entrypoint for this contract to process messages.
+  /// @param message The message to process.
+  /// @dev This example just sends the tokens to the owner of this contracts. More
+  /// interesting functions could be implemented.
+  /// @dev It has to be external because of the try/catch.
+  function processMessage(Client.Any2EVMMessage calldata message)
+    external
+    virtual
+    onlySelf
+    validSender(message.sourceChainSelector, message.sender)
+  {
+    // Insert Custom logic here
+    if (s_simRevert) revert ErrorCase();
+  }
+
+  function _retryFailedMessage(Client.Any2EVMMessage memory message) internal virtual {
+    // Owner rescues tokens sent with a failed message
+    for (uint256 i = 0; i < message.destTokenAmounts.length; ++i) {
+      uint256 amount = message.destTokenAmounts[i].amount;
+      address token = message.destTokenAmounts[i].token;
+
+      IERC20(token).safeTransfer(owner(), amount);
+    }
+  }
+
+  /// @notice This function is callable by the owner when a message has failed
+  /// to unblock the tokens that are associated with that message.
+  /// @dev This function is only callable by the owner.
+  function retryFailedMessage(bytes32 messageId) external onlyOwner {
+    if (s_failedMessages.get(messageId) != uint256(ErrorCode.FAILED)) revert MessageNotFailed(messageId);
+
+    // Set the error code to 0 to disallow reentry and retry the same failed message
+    // multiple times.
+    s_failedMessages.set(messageId, uint256(ErrorCode.RESOLVED));
+
+    // Do stuff to retry message, potentially just releasing the associated tokens
+    Client.Any2EVMMessage memory message = s_messageContents[messageId];
+
+    // Let the user override the implementation, since different workflow may be desired for retrying a merssage
+    _retryFailedMessage(message);
+
+    s_failedMessages.remove(messageId); // If retry succeeds, remove from set of failed messages.
+
+    emit MessageRecovered(messageId);
+  }
+
+  function getMessageContents(bytes32 messageId) public view returns (Client.Any2EVMMessage memory) {
+    return s_messageContents[messageId];
+  }
+
+  function getMessageStatus(bytes32 messageId) public view returns (uint256) {
+    return s_failedMessages.get(messageId);
+  }
+
+  // An example function to demonstrate recovery
+  function setSimRevert(bool simRevert) external onlyOwner {
+    s_simRevert = simRevert;
+  }
+
+  modifier onlySelf() {
+    if (msg.sender != address(this)) revert OnlySelf();
+    _;
+  }
+}