[WIP] Add Rebasable token to Optimism

contracts/BridgeableTokens.sol

@@ -6,30 +6,40 @@
 /// @author psirex
 /// @notice Contains the logic for validation of tokens used in the bridging process
 contract BridgeableTokens {
-    /// @notice Address of the bridged token in the L1 chain
-    address public immutable l1Token;
+    /// @notice Address of the bridged non rebasable token in the L1 chain
+    address public immutable l1TokenNonRebasable;
 
-    /// @notice Address of the token minted on the L2 chain when token bridged
-    address public immutable l2Token;
+    /// @notice Address of the bridged rebasable token in the L1 chain
+    address public immutable l1TokenRebasable;
 
-    /// @param l1Token_ Address of the bridged token in the L1 chain
-    /// @param l2Token_ Address of the token minted on the L2 chain when token bridged
-    constructor(address l1Token_, address l2Token_) {
-        l1Token = l1Token_;
-        l2Token = l2Token_;
+    /// @notice Address of the non rebasable token minted on the L2 chain when token bridged
+    address public immutable l2TokenNonRebasable;
+
+    /// @notice Address of the rebasable token minted on the L2 chain when token bridged
+    address public immutable l2TokenRebasable;
+
+    /// @param l1TokenNonRebasable_ Address of the bridged non rebasable token in the L1 chain
+    /// @param l1TokenRebasable_ Address of the bridged rebasable token in the L1 chain
+    /// @param l2TokenNonRebasable_ Address of the non rebasable token minted on the L2 chain when token bridged
+    /// @param l2TokenRebasable_ Address of the rebasable token minted on the L2 chain when token bridged
+    constructor(address l1TokenNonRebasable_, address l1TokenRebasable_, address l2TokenNonRebasable_, address l2TokenRebasable_) {
+        l1TokenNonRebasable = l1TokenNonRebasable_;
+        l1TokenRebasable = l1TokenRebasable_;
+        l2TokenNonRebasable = l2TokenNonRebasable_;
+        l2TokenRebasable = l2TokenRebasable_;
     }
 
     /// @dev Validates that passed l1Token_ is supported by the bridge
     modifier onlySupportedL1Token(address l1Token_) {
-        if (l1Token_ != l1Token) {
+        if (l1Token_ != l1TokenNonRebasable && l1Token_ != l1TokenRebasable) {
             revert ErrorUnsupportedL1Token();
         }
         _;
     }
 
     /// @dev Validates that passed l2Token_ is supported by the bridge
     modifier onlySupportedL2Token(address l2Token_) {
-        if (l2Token_ != l2Token) {
+        if (l2Token_ != l2TokenNonRebasable && l2Token_ != l2TokenRebasable) {
             revert ErrorUnsupportedL2Token();
         }
         _;
@@ -43,6 +53,14 @@
         _;
     }
 
+    function isRebasableTokenFlow(address l1Token_, address l2Token_) internal view returns (bool) {
+        return l1Token_ == l1TokenRebasable && l2Token_ == l2TokenRebasable;
+    }
+
+    function isNonRebasableTokenFlow(address l1Token_, address l2Token_) internal view returns (bool) {
+        return l1Token_ == l1TokenNonRebasable && l2Token_ == l2TokenNonRebasable;
+    }
+
     error ErrorUnsupportedL1Token();
     error ErrorUnsupportedL2Token();
     error ErrorAccountIsZeroAddress();

contracts/arbitrum/InterchainERC20TokenGateway.sol

@@ -17,21 +17,25 @@
     IInterchainTokenGateway
 {
     /// @notice Address of the router in the corresponding chain
     address public immutable router;
 
     /// @inheritdoc IInterchainTokenGateway
     address public immutable counterpartGateway;
 
     /// @param router_ Address of the router in the corresponding chain
     /// @param counterpartGateway_ Address of the counterpart gateway used in the bridging process
-    /// @param l1Token_ Address of the bridged token in the Ethereum chain
-    /// @param l2Token_ Address of the token minted on the Arbitrum chain when token bridged
+    /// @param l1TokenNonRebasable Address of the bridged token in the Ethereum chain
+    /// @param l1TokenRebasable_ Address of the bridged token in the Ethereum chain
+    /// @param l2TokenNonRebasable_ Address of the token minted on the Arbitrum chain when token bridged
+    /// @param l2TokenRebasable_ Address of the token minted on the Arbitrum chain when token bridged
     constructor(
         address router_,
         address counterpartGateway_,
-        address l1Token_,
-        address l2Token_
-    ) BridgeableTokens(l1Token_, l2Token_) {
+        address l1TokenNonRebasable,
+        address l1TokenRebasable_,
+        address l2TokenNonRebasable_,
+        address l2TokenRebasable_
+    ) BridgeableTokens(l1TokenNonRebasable, l1TokenRebasable_, l2TokenNonRebasable_, l2TokenRebasable_) {
         router = router_;
         counterpartGateway = counterpartGateway_;
     }
@@ -44,8 +48,8 @@
         view
         returns (address)
     {
-        if (l1Token_ == l1Token) {
-            return l2Token;
+        if (l1Token_ == l1TokenRebasable) {
+            return l2TokenNonRebasable;
         }
         return address(0);
     }

contracts/arbitrum/L1ERC20TokenGateway.sol

@@ -32,13 +32,17 @@ contract L1ERC20TokenGateway is
         address router_,
         address counterpartGateway_,
         address l1Token_,
-        address l2Token_
+        address l1TokenRebasable_,
+        address l2Token_,
+        address l2TokenRebasable_
     )
         InterchainERC20TokenGateway(
             router_,
             counterpartGateway_,
             l1Token_,
-            l2Token_
+            l1TokenRebasable_,
+            l2Token_,
+            l2TokenRebasable_
         )
         L1CrossDomainEnabled(inbox_)
     {}
@@ -78,7 +82,7 @@ contract L1ERC20TokenGateway is
             })
         );
 
-        emit DepositInitiated(l1Token, from, to_, retryableTicketId, amount_);
+        emit DepositInitiated(l1TokenNonRebasable, from, to_, retryableTicketId, amount_);
 
         return abi.encode(retryableTicketId);
     }
@@ -113,7 +117,7 @@ contract L1ERC20TokenGateway is
             sendCrossDomainMessage(
                 from_,
                 counterpartGateway,
-                getOutboundCalldata(l1Token, from_, to_, amount_, ""),
+                getOutboundCalldata(l1TokenNonRebasable, from_, to_, amount_, ""),
                 messageOptions
             );
     }

contracts/arbitrum/L2ERC20TokenGateway.sol

@@ -21,20 +21,26 @@ contract L2ERC20TokenGateway is
     /// @param arbSys_ Address of the Arbitrum’s ArbSys contract in the L2 chain
     /// @param router_ Address of the router in the L2 chain
     /// @param counterpartGateway_ Address of the counterpart L1 gateway
-    /// @param l1Token_ Address of the bridged token in the L1 chain
-    /// @param l2Token_ Address of the token minted on the Arbitrum chain when token bridged
+    /// @param l1TokenNonRebasable_ Address of the bridged token in the L1 chain
+    /// @param l1TokenRebasable_ Address of the bridged token in the L1 chain
+    /// @param l2TokenNonRebasable_ Address of the token minted on the Arbitrum chain when token bridged
+    /// @param l2TokenRebasable_ Address of the token minted on the Arbitrum chain when token bridged
     constructor(
         address arbSys_,
         address router_,
         address counterpartGateway_,
-        address l1Token_,
-        address l2Token_
+        address l1TokenNonRebasable_,
+        address l1TokenRebasable_,
+        address l2TokenNonRebasable_,
+        address l2TokenRebasable_
     )
         InterchainERC20TokenGateway(
             router_,
             counterpartGateway_,
-            l1Token_,
-            l2Token_
+            l1TokenNonRebasable_,
+            l1TokenRebasable_,
+            l2TokenNonRebasable_,
+            l2TokenRebasable_
         )
         L2CrossDomainEnabled(arbSys_)
     {}
@@ -55,7 +61,7 @@ contract L2ERC20TokenGateway is
     {
         address from = L2OutboundDataParser.decode(router, data_);
 
-        IERC20Bridged(l2Token).bridgeBurn(from, amount_);
+        IERC20Bridged(l2TokenNonRebasable).bridgeBurn(from, amount_);
 
         uint256 id = sendCrossDomainMessage(
             from,
@@ -83,7 +89,7 @@ contract L2ERC20TokenGateway is
         onlySupportedL1Token(l1Token_)
         onlyFromCrossDomainAccount(counterpartGateway)
     {
-        IERC20Bridged(l2Token).bridgeMint(to_, amount_);
+        IERC20Bridged(l2TokenNonRebasable).bridgeMint(to_, amount_);
 
         emit DepositFinalized(l1Token_, from_, to_, amount_);
     }

contracts/optimism/DepositDataCodec.sol

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: 2023 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.10;
+
+contract DepositDataCodec {
+
+    struct DepositData {
+        uint256 rate;
+        uint256 time;
+        bytes data;
+    }
+
+    function encodeDepositData(DepositData memory depositData) internal pure returns (bytes memory) {
+        bytes memory data = bytes.concat(
+            abi.encodePacked(depositData.rate),
+            abi.encodePacked(depositData.time),
+            abi.encodePacked(depositData.data)
+        );
+        return data;
+    }
+
+    function decodeDepositData(bytes calldata buffer) internal pure returns (DepositData memory) {
+
+        if (buffer.length < 32 * 2) {
+            revert ErrorDepositDataLength();
+        }
+
+        DepositData memory depositData;
+        depositData.rate = uint256(bytes32(buffer[0:32]));
+        depositData.time = uint256(bytes32(buffer[32:64]));
+        depositData.data = buffer[64:];
+
+        return depositData;
+    }
+
+    error ErrorDepositDataLength();
+}

contracts/optimism/L1ERC20TokenBridge.sol

@@ -13,6 +13,10 @@
 import {BridgingManager} from "../BridgingManager.sol";
 import {BridgeableTokens} from "../BridgeableTokens.sol";
 import {CrossDomainEnabled} from "./CrossDomainEnabled.sol";
+import {DepositDataCodec} from "./DepositDataCodec.sol";
+
+import {IERC20Wrapable} from "../token/interfaces/IERC20Wrapable.sol";
+import "hardhat/console.sol";
 
 /// @author psirex
 /// @notice The L1 ERC20 token bridge locks bridged tokens on the L1 side, sends deposit messages
@@ -22,7 +26,8 @@
     IL1ERC20Bridge,
     BridgingManager,
     BridgeableTokens,
-    CrossDomainEnabled
+    CrossDomainEnabled,
+    DepositDataCodec
 {
     using SafeERC20 for IERC20;
 
@@ -31,14 +36,18 @@
 
     /// @param messenger_ L1 messenger address being used for cross-chain communications
     /// @param l2TokenBridge_ Address of the corresponding L2 bridge
-    /// @param l1Token_ Address of the bridged token in the L1 chain
-    /// @param l2Token_ Address of the token minted on the L2 chain when token bridged
+    /// @param l1TokenNonRebasable_ Address of the bridged token in the L1 chain
+    /// @param l1TokenRebasable_ Address of the bridged token in the L1 chain
+    /// @param l2TokenNonRebasable_ Address of the token minted on the L2 chain when token bridged
+    /// @param l2TokenRebasable_ Address of the token minted on the L2 chain when token bridged
     constructor(
         address messenger_,
         address l2TokenBridge_,
-        address l1Token_,
-        address l2Token_
-    ) CrossDomainEnabled(messenger_) BridgeableTokens(l1Token_, l2Token_) {
+        address l1TokenNonRebasable_,
+        address l1TokenRebasable_,
+        address l2TokenNonRebasable_,
+        address l2TokenRebasable_
+    ) CrossDomainEnabled(messenger_) BridgeableTokens(l1TokenNonRebasable_, l1TokenRebasable_, l2TokenNonRebasable_, l2TokenRebasable_) {
         l2TokenBridge = l2TokenBridge_;
     }
 
@@ -54,11 +63,12 @@
         whenDepositsEnabled
         onlySupportedL1Token(l1Token_)
         onlySupportedL2Token(l2Token_)
-    {
+    {        
         if (Address.isContract(msg.sender)) {
             revert ErrorSenderNotEOA();
         }
-        _initiateERC20Deposit(msg.sender, msg.sender, amount_, l2Gas_, data_);
+
+        _depositERC20To(l1Token_, l2Token_, msg.sender, amount_, l2Gas_, data_);
     }
 
     /// @inheritdoc IL1ERC20Bridge
@@ -76,7 +86,7 @@
         onlySupportedL1Token(l1Token_)
         onlySupportedL2Token(l2Token_)
     {
-        _initiateERC20Deposit(msg.sender, to_, amount_, l2Gas_, data_);
+        _depositERC20To(l1Token_, l2Token_, to_, amount_, l2Gas_, data_);
     }
 
     /// @inheritdoc IL1ERC20Bridge
@@ -94,7 +104,12 @@
         onlySupportedL2Token(l2Token_)
         onlyFromCrossDomainAccount(l2TokenBridge)
     {
-        IERC20(l1Token_).safeTransfer(to_, amount_);
+        if (isRebasableTokenFlow(l1Token_, l2Token_)) {
+            uint256 stETHAmount = IERC20Wrapable(l1TokenNonRebasable).unwrap(amount_);
+            IERC20(l1TokenRebasable).safeTransfer(to_, stETHAmount);
+        } else if (isNonRebasableTokenFlow(l1Token_, l2Token_)) {
+            IERC20(l1TokenNonRebasable).safeTransfer(to_, amount_);
+        }
 
         emit ERC20WithdrawalFinalized(
             l1Token_,
@@ -106,6 +121,38 @@
         );
     }
 
+    function _depositERC20To(
+        address l1Token_,
+        address l2Token_,
+        address to_,
+        uint256 amount_,
+        uint32 l2Gas_,
+        bytes calldata data_
+    ) internal {
+
+        DepositData memory depositData;
+        depositData.rate = IERC20Wrapable(l1TokenNonRebasable).tokensPerStEth();
+        depositData.time = block.timestamp;
+        depositData.data = data_;
+
+        bytes memory encodedDepositData = encodeDepositData(depositData);
+
+        if (amount_ == 0) {
+            _initiateERC20Deposit(l1Token_, l2Token_, msg.sender, to_, amount_, l2Gas_, encodedDepositData);
+            return;
+        }
+
+        if (isRebasableTokenFlow(l1Token_, l2Token_)) {
+            IERC20(l1TokenRebasable).safeTransferFrom(msg.sender, address(this), amount_);
+            IERC20(l1TokenRebasable).approve(l1TokenNonRebasable, amount_);
+            uint256 wstETHAmount = IERC20Wrapable(l1TokenNonRebasable).wrap(amount_);
+            _initiateERC20Deposit(l1TokenRebasable, l2TokenRebasable, msg.sender, to_, wstETHAmount, l2Gas_, encodedDepositData);
+        } else if (isNonRebasableTokenFlow(l1Token_, l2Token_)) {
+            IERC20(l1TokenNonRebasable).safeTransferFrom(msg.sender, address(this), amount_);
+            _initiateERC20Deposit(l1TokenNonRebasable, l2TokenNonRebasable, msg.sender, to_, amount_, l2Gas_, encodedDepositData);
+        }
+    }
+
     /// @dev Performs the logic for deposits by informing the L2 token bridge contract
     ///     of the deposit and calling safeTransferFrom to lock the L1 funds.
     /// @param from_ Account to pull the deposit from on L1
@@ -116,18 +163,19 @@
     ///        solely as a convenience for external contracts. Aside from enforcing a maximum
     ///        length, these contracts provide no guarantees about its content.
     function _initiateERC20Deposit(
+        address l1Token_,
+        address l2Token_,
         address from_,
         address to_,
         uint256 amount_,
         uint32 l2Gas_,
-        bytes calldata data_
+        bytes memory data_
     ) internal {
-        IERC20(l1Token).safeTransferFrom(from_, address(this), amount_);
 
         bytes memory message = abi.encodeWithSelector(
             IL2ERC20Bridge.finalizeDeposit.selector,
-            l1Token,
-            l2Token,
+            l1Token_,
+            l2Token_,
             from_,
             to_,
             amount_,
@@ -137,8 +185,8 @@
         sendCrossDomainMessage(l2TokenBridge, l2Gas_, message);
 
         emit ERC20DepositInitiated(
-            l1Token,
-            l2Token,
+            l1Token_,
+            l2Token_,
             from_,
             to_,
             amount_,