[OETHb] Direct Staking

contracts/contracts/crosschain/AbstractDirectStakingHandler.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { CCIPReceiver } from "@chainlink/contracts-ccip/src/v0.8/ccip/applications/CCIPReceiver.sol";
+import { Client } from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";
+import { IARM } from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IARM.sol";
+
+import { IRouterClient } from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
+
+import { ICCIPRouter } from "../interfaces/chainlink/ICCIPRouter.sol";
+import { Governable } from "../governance/Governable.sol";
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+abstract contract AbstractDirectStakingHandler is CCIPReceiver, Governable {
+    using SafeERC20 for IERC20;
+
+    struct ChainConfig {
+        bool isSupported;
+        // Address of the Handler on the chain
+        address handlerAddr;
+    }
+
+    mapping(uint64 => ChainConfig) public chainConfigs;
+
+    // For future use
+    uint256[49] private __gap;
+
+    event ChainConfigAdded(uint64 chainId, address handlerAddr);
+    event ChainConfigRemoved(uint64 chainId);
+
+    /**
+     * @dev Reverts if CCIP's Risk Management contract (ARM) is cursed
+     */
+    modifier onlyIfNotCursed() {
+        IARM arm = IARM(ICCIPRouter(this.getRouter()).getArmProxy());
+
+        require(!arm.isCursed(), "CCIP Router is cursed");
+
+        _;
+    }
+
+    constructor(address _router) CCIPReceiver(_router) {
+        // Nobody owns the implementation
+        _setGovernor(address(0));
+    }
+
+    /**
+     * @dev Adds a chain config
+     */
+    function addChainConfig(uint64 chainId, address _handler)
+        external
+        onlyGovernor
+    {
+        require(!chainConfigs[chainId].isSupported, "Chain config exists");
+
+        emit ChainConfigAdded(chainId, _handler);
+
+        chainConfigs[chainId] = ChainConfig({
+            isSupported: true,
+            handlerAddr: _handler
+        });
+    }
+
+    /**
+     * @dev Removes a chain config
+     */
+    function removeChainConfig(uint64 chainId) external onlyGovernor {
+        require(chainConfigs[chainId].isSupported, "Unknown chain ID");
+
+        emit ChainConfigRemoved(chainId);
+
+        delete chainConfigs[chainId];
+    }
+
+    /**
+     * @dev Returns the CCIP fees that the contract needs to execute the command
+     * @param chainSelector Destination chain
+     * @param data Message data
+     * @param tokenAddr Token to send
+     * @param tokenAmount Amount of tokens to send
+     * @param maxGasLimit Max Gas Limit to use
+     */
+    function getCCIPFees(
+        uint64 chainSelector,
+        bytes memory data,
+        address tokenAddr,
+        uint256 tokenAmount,
+        uint256 maxGasLimit
+    ) external view returns (uint256) {
+        // Build the message
+        (, uint256 fee) = _buildCCIPMessage(
+            chainSelector,
+            data,
+            tokenAddr,
+            tokenAmount,
+            maxGasLimit
+        );
+
+        return fee;
+    }
+
+    /**
+     * @dev Builds the CCIP message
+     * @param chainSelector Destination chain
+     * @param data Message data
+     * @param tokenAddr Token to send
+     * @param tokenAmount Amount of tokens to send
+     * @param maxGasLimit Max Gas Limit to use
+     */
+    function _buildCCIPMessage(
+        uint64 chainSelector,
+        bytes memory data,
+        address tokenAddr,
+        uint256 tokenAmount,
+        uint256 maxGasLimit
+    )
+        internal
+        view
+        returns (Client.EVM2AnyMessage memory message, uint256 fee)
+    {
+        ChainConfig memory config = chainConfigs[chainSelector];
+
+        require(config.isSupported, "Unsupported destination chain");
+
+        bytes memory extraArgs = hex"";
+        // Set gas limit if needed
+        if (maxGasLimit > 0) {
+            extraArgs = Client._argsToBytes(
+                // Set gas limit
+                Client.EVMExtraArgsV1({ gasLimit: maxGasLimit })
+            );
+        }
+
+        // Tokens to transfer
+        Client.EVMTokenAmount[]
+            memory tokenAmounts = new Client.EVMTokenAmount[](1);
+        tokenAmounts[0] = Client.EVMTokenAmount({
+            token: tokenAddr,
+            amount: tokenAmount
+        });
+
+        // Build the message
+        message = Client.EVM2AnyMessage({
+            receiver: abi.encode(config.handlerAddr),
+            data: data,
+            tokenAmounts: tokenAmounts,
+            extraArgs: extraArgs,
+            feeToken: address(0)
+        });
+
+        // Estimate fee
+        fee = IRouterClient(i_router).getFee(chainSelector, message);
+    }
+
+    /**
+     * @dev Grant token approval for contracts that can move tokens from here
+     */
+    function approveAllTokens() external virtual;
+
+    /**
+     * @notice Owner function to withdraw a specific amount of a token
+     * @param token token to be transferered
+     * @param amount amount of the token to be transferred
+     */
+    function transferToken(address token, uint256 amount)
+        external
+        onlyGovernor
+        nonReentrant
+    {
+        if (token == address(0)) {
+            // Transfer out Native token to governor
+            (bool success, ) = _governor().call{ value: amount }("");
+            require(success, "Native token transfer failed");
+            return;
+        }
+
+        IERC20(token).safeTransfer(_governor(), amount);
+    }
+
+    // Accept ETH to pay for gas
+    receive() external payable {}
+}

contracts/contracts/crosschain/CCIPChainSelector.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// Ref: https://docs.chain.link/ccip/supported-networks/v1_2_0/mainnet
+uint64 constant MAINNET_SELECTOR = 5009297550715157269;
+uint64 constant ARBITRUM_ONE_SELECTOR = 4949039107694359620;
+uint64 constant BASE_SELECTOR = 15971525489660198786;

contracts/contracts/crosschain/DirectStakingL2Handler.sol

@@ -0,0 +1,183 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { CCIPReceiver } from "@chainlink/contracts-ccip/src/v0.8/ccip/applications/CCIPReceiver.sol";
+import { Client } from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";
+import { IRouterClient } from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
+
+import { IVault } from "../interfaces/IVault.sol";
+import { IOUSD } from "../interfaces/IOUSD.sol";
+import { IDirectStakingCaller } from "../interfaces/IDirectStakingCaller.sol";
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { IERC4626 } from "../../lib/openzeppelin/interfaces/IERC4626.sol";
+
+import { AbstractDirectStakingHandler } from "./AbstractDirectStakingHandler.sol";
+
+import { MAINNET_SELECTOR } from "./CCIPChainSelector.sol";
+
+contract DirectStakingL2Handler is AbstractDirectStakingHandler {
+    IERC20 public immutable weth;
+    IERC4626 public immutable woeth;
+
+    struct StakeRequest {
+        address requester;
+        bool processed;
+        bool callback;
+        uint256 amountIn;
+        uint256 minAmountOut;
+        uint256 amountReceived;
+        uint256 createdAt;
+    }
+    mapping(bytes32 => StakeRequest) public stakeRequests;
+
+    event DirectStakeRequestCreated(
+        bytes32 messageId,
+        uint64 destChain,
+        address tokenIn,
+        address tokenOut,
+        uint256 amountIn,
+        uint256 minAmountOut,
+        uint256 fee
+    );
+
+    event DirectStakeRequestCompleted(bytes32 messageId, uint256 amountOut);
+
+    constructor(
+        address _router,
+        address _weth,
+        address _woeth
+    ) AbstractDirectStakingHandler(_router) {
+        weth = IERC20(_weth);
+        woeth = IERC4626(_woeth);
+    }
+
+    function _ccipReceive(Client.Any2EVMMessage memory message)
+        internal
+        virtual
+        override
+        onlyIfNotCursed
+        nonReentrant
+    {
+        // Make sure it's from mainnet
+        require(
+            message.sourceChainSelector == MAINNET_SELECTOR,
+            "Not from mainnet"
+        );
+
+        ChainConfig memory cc = chainConfigs[MAINNET_SELECTOR];
+
+        // Make sure mainnet is marked as supported
+        require(cc.isSupported, "Mainnet not configured");
+        require(
+            abi.decode(message.sender, (address)) == cc.handlerAddr,
+            "Unknown sender"
+        );
+
+        // Make sure it contains wOETH from mainnet
+        require(
+            message.destTokenAmounts.length == 1,
+            "Invalid tokens received"
+        );
+
+        Client.EVMTokenAmount memory tokenAmount = message.destTokenAmounts[0];
+        require(tokenAmount.token == address(woeth), "Unsupported token");
+        require(tokenAmount.amount > 0, "No tokens received");
+
+        // Decode messageId
+        bytes32 originalMessageId = abi.decode(message.data, (bytes32));
+
+        // Make sure the requests exists
+        StakeRequest memory request = stakeRequests[originalMessageId];
+        require(request.requester != address(0), "Unknown request message");
+
+        // And that it wasn't processed
+        require(!request.processed, "Already processed");
+
+        // Check slippage
+        require(tokenAmount.amount >= request.minAmountOut, "Slippage error");
+
+        // Mark as processed
+        stakeRequests[originalMessageId].processed = true;
+        // Store amount received (would be easier to lookup/debug if needed)
+        stakeRequests[originalMessageId].amountReceived = tokenAmount.amount;
+
+        emit DirectStakeRequestCompleted(originalMessageId, tokenAmount.amount);
+
+        // Transfer tokens to the caller
+        // slither-disable-start unused-return
+        // slither-disable-next-line unchecked-transfer
+        woeth.transfer(request.requester, tokenAmount.amount);
+        // slither-disable-end unused-return
+
+        if (request.callback) {
+            // If requester needs a callback, invoke it
+            IDirectStakingCaller(request.requester)
+                .onDirectStakingRequestCompletion(
+                    originalMessageId,
+                    tokenAmount.amount
+                );
+        }
+    }
+
+    function stake(
+        uint256 wethAmount,
+        uint256 minAmountOut,
+        bool callback
+    ) external payable nonReentrant returns (bytes32) {
+        require(wethAmount > 0, "Invalid amount");
+
+        ChainConfig memory cc = chainConfigs[MAINNET_SELECTOR];
+
+        // Make sure mainnet is marked as supported
+        require(cc.isSupported, "Mainnet not configured");
+
+        // Transfer WETH in
+        // slither-disable-start unused-return
+        // slither-disable-next-line unchecked-transfer
+        weth.transferFrom(msg.sender, address(this), wethAmount);
+        // slither-disable-end unused-return
+
+        // Build message to initiate
+        (Client.EVM2AnyMessage memory message, uint256 fee) = _buildCCIPMessage(
+            MAINNET_SELECTOR,
+            abi.encode(minAmountOut),
+            address(weth),
+            wethAmount,
+            // Just a rough gas estimation
+            700000
+        );
+
+        bytes32 messageId = IRouterClient(i_router).ccipSend{ value: fee }(
+            MAINNET_SELECTOR,
+            message
+        );
+
+        emit DirectStakeRequestCreated(
+            messageId,
+            MAINNET_SELECTOR,
+            address(weth),
+            address(woeth),
+            wethAmount,
+            minAmountOut,
+            fee
+        );
+
+        stakeRequests[messageId] = StakeRequest({
+            requester: msg.sender,
+            processed: false,
+            callback: callback,
+            amountIn: wethAmount,
+            minAmountOut: minAmountOut,
+            amountReceived: 0,
+            createdAt: block.timestamp
+        });
+
+        return messageId;
+    }
+
+    function approveAllTokens() external override onlyGovernor {
+        // Allow CCIP Router to move WETH from here
+        weth.approve(i_router, type(uint256).max);
+    }
+}