[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,39 @@
+// 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])),
+            time: uint256(bytes32(buffer[32:64])),
+            data: buffer[64:]
+        });
+
+        return depositData;
+    }
+
+    error ErrorDepositDataLength();
+}