[WIP] Add Rebasable token to Optimism

contracts/BridgeableTokens.sol

@@ -7,29 +7,37 @@
 /// @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 rebasable token in the L1 chain
+    address public immutable l1TokenRebasable;
+
     /// @notice Address of the token minted on the L2 chain when token bridged
     address public immutable l2Token;
 
+    /// @notice Address of the rebasable token minted on the L2 chain when token bridged
+    address public immutable l2TokenRebasable;
+
     /// @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_) {
+    constructor(address l1Token_, address l1TokenRebasable_, address l2Token_, address l2TokenRebasable_) {
         l1Token = l1Token_;
+        l1TokenRebasable = l1TokenRebasable_;
         l2Token = l2Token_;
+        l2TokenRebasable = l2TokenRebasable_;
     }
 
     /// @dev Validates that passed l1Token_ is supported by the bridge
     modifier onlySupportedL1Token(address l1Token_) {
-        if (l1Token_ != l1Token) {
+        if (l1Token_ != l1Token && l1Token_ != l1TokenRebasable) {
             revert ErrorUnsupportedL1Token();
         }
         _;
     }
 
     /// @dev Validates that passed l2Token_ is supported by the bridge
     modifier onlySupportedL2Token(address l2Token_) {
-        if (l2Token_ != l2Token) {
+        if (l2Token_ != l2Token && l2Token_ != l2TokenRebasable) {
             revert ErrorUnsupportedL2Token();
         }
         _;

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 l1TokenRebasable_ Address of the bridged token in the Ethereum chain
     /// @param l2Token_ 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 l1TokenRebasable_,
+        address l2Token_,
+        address l2TokenRebasable_
+    ) BridgeableTokens(l1Token_, l1TokenRebasable_, l2Token_, l2TokenRebasable_) {
         router = router_;
         counterpartGateway = counterpartGateway_;
     }

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_)
     {}

contracts/arbitrum/L2ERC20TokenGateway.sol

@@ -22,19 +22,24 @@ contract L2ERC20TokenGateway is
     /// @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 l1TokenRebasable_ Address of the bridged token in the L1 chain
     /// @param l2Token_ Address of the token minted on the Arbitrum chain when token bridged
     constructor(
         address arbSys_,
         address router_,
         address counterpartGateway_,
         address l1Token_,
-        address l2Token_
+        address l1TokenRebasable_,
+        address l2Token_,
+        address l2TokenRebasable_
     )
         InterchainERC20TokenGateway(
             router_,
             counterpartGateway_,
             l1Token_,
-            l2Token_
+            l1TokenRebasable_,
+            l2Token_,
+            l2TokenRebasable_
         )
         L2CrossDomainEnabled(arbSys_)
     {}

contracts/optimism/L1ERC20TokenBridge.sol

@@ -14,6 +14,9 @@
 import {BridgeableTokens} from "../BridgeableTokens.sol";
 import {CrossDomainEnabled} from "./CrossDomainEnabled.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
 ///     on the L2 side, and finalizes token withdrawals from L2. Additionally, adds the methods for
@@ -32,19 +35,22 @@
     /// @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 l1TokenRebasable_ 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 messenger_,
         address l2TokenBridge_,
-        address l1Token_,
-        address l2Token_
-    ) CrossDomainEnabled(messenger_) BridgeableTokens(l1Token_, l2Token_) {
+        address l1Token_,           // wstETH
+        address l1TokenRebasable_,  // stETH
+        address l2Token_,
+        address l2TokenRebasable_
+    ) CrossDomainEnabled(messenger_) BridgeableTokens(l1Token_, l1TokenRebasable_, l2Token_, l2TokenRebasable_) {
         l2TokenBridge = l2TokenBridge_;
     }
 
     /// @inheritdoc IL1ERC20Bridge
     function depositERC20(
-        address l1Token_,
+        address l1Token_, // stETH or wstETH
         address l2Token_,
         uint256 amount_,
         uint32 l2Gas_,
@@ -54,11 +60,26 @@
         whenDepositsEnabled
         onlySupportedL1Token(l1Token_)
         onlySupportedL2Token(l2Token_)
-    {
+    {        
         if (Address.isContract(msg.sender)) {
             revert ErrorSenderNotEOA();
         }
-        _initiateERC20Deposit(msg.sender, msg.sender, amount_, l2Gas_, data_);
+
+        if(l1Token_ == l1TokenRebasable) {
+            bytes memory data = bytes.concat(hex'01', data_); // add rate
+            IERC20(l1TokenRebasable).safeTransferFrom(msg.sender, address(this), amount_);
+            IERC20(l1TokenRebasable).approve(l1Token, amount_);
+            uint256 wstETHAmount = IERC20Wrapable(l1Token).wrap(amount_);
+            console.log("wstETHAmount=",wstETHAmount);
+
+            uint256 balanceOfl1Token = IERC20(l1Token).balanceOf(address(this));
+            console.log("balanceOfl1Token=",balanceOfl1Token);
+
+            _initiateERC20Deposit(msg.sender, msg.sender, wstETHAmount, l2Gas_, data);
+        } else {
+            IERC20(l1Token).safeTransferFrom(msg.sender, address(this), amount_);
+            _initiateERC20Deposit(msg.sender, msg.sender, amount_, l2Gas_, data_);
+        }
     }
 
     /// @inheritdoc IL1ERC20Bridge
@@ -120,9 +141,8 @@
         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,
@@ -133,6 +153,7 @@
             amount_,
             data_
         );
+        console.log("SEND l2TokenBridge=%s l1Token=%s l2Token=%s", l2TokenBridge, l1Token, l2Token);
 
         sendCrossDomainMessage(l2TokenBridge, l2Gas_, message);
 

contracts/optimism/L2ERC20TokenBridge.sol

@@ -6,11 +6,14 @@
 import {IL1ERC20Bridge} from "./interfaces/IL1ERC20Bridge.sol";
 import {IL2ERC20Bridge} from "./interfaces/IL2ERC20Bridge.sol";
 import {IERC20Bridged} from "../token/interfaces/IERC20Bridged.sol";
+import {ERC20Rebasable} from "../token/ERC20Rebasable.sol";
 
 import {BridgingManager} from "../BridgingManager.sol";
 import {BridgeableTokens} from "../BridgeableTokens.sol";
 import {CrossDomainEnabled} from "./CrossDomainEnabled.sol";
 
+import { console } from "hardhat/console.sol";
+
 /// @author psirex
 /// @notice The L2 token bridge works with the L1 token bridge to enable ERC20 token bridging
 ///     between L1 and L2. It acts as a minter for new tokens when it hears about
@@ -34,8 +37,10 @@
         address messenger_,
         address l1TokenBridge_,
         address l1Token_,
-        address l2Token_
-    ) CrossDomainEnabled(messenger_) BridgeableTokens(l1Token_, l2Token_) {
+        address l1TokenRebasable_,
+        address l2Token_,
+        address l2TokenRebasable_
+    ) CrossDomainEnabled(messenger_) BridgeableTokens(l1Token_, l1TokenRebasable_, l2Token_, l2TokenRebasable_) {
         l1TokenBridge = l1TokenBridge_;
     }
 
@@ -75,8 +80,21 @@
         onlySupportedL2Token(l2Token_)
         onlyFromCrossDomainAccount(l1TokenBridge)
     {
-        IERC20Bridged(l2Token_).bridgeMint(to_, amount_);
-        emit DepositFinalized(l1Token_, l2Token_, from_, to_, amount_, data_);
+        if (data_.length > 0 && data_[0] == hex'01') {
+            console.log("finalizeDeposit1 l2TokenRebasable balanceBefore=",ERC20Rebasable(l2TokenRebasable).balanceOf(to_));
+
+            ERC20Rebasable(l2TokenRebasable).mintShares(to_, amount_);
+
+            console.log("finalizeDeposit1 l2TokenRebasable balanceafter==",ERC20Rebasable(l2TokenRebasable).balanceOf(to_));
+
+            bytes memory data = data_[1:];
+            emit DepositFinalized(l1Token_, l2Token_, from_, to_, amount_, data);
+        } else {
+            console.log("finalizeDeposit2 data=", data_.length);
+
+            IERC20Bridged(l2Token_).bridgeMint(to_, amount_);
+            emit DepositFinalized(l1Token_, l2Token_, from_, to_, amount_, data_);
+        }
     }
 
     /// @notice Performs the logic for withdrawals by burning the token and informing

contracts/stubs/ERC20Stub.sol

@@ -0,0 +1,66 @@
+// SPDX-FileCopyrightText: 2022 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.10;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { console } from "hardhat/console.sol";
+
+contract ERC20Stub is IERC20 {
+
+    uint256 totalSupply_;
+    uint256 balanceOf_;
+    bool transfer_;
+    uint256 allowance_;
+    bool approve_;
+    bool transferFrom_;
+
+    constructor() {
+        totalSupply_ = 0;
+        balanceOf_ = 0;
+        transfer_ = true;
+        allowance_ = 0;
+        approve_ = true;
+        transferFrom_ = true;
+    }
+
+    function totalSupply() external view returns (uint256) {
+        return totalSupply_;
+    }
+
+    function balanceOf(address account) external view returns (uint256) {
+        return balanceOf_;
+    }
+
+    address public transferTo;
+    uint256 public transferAmount;
+
+    function transfer(address to, uint256 amount) external returns (bool) {
+        transferTo = to;
+        transferAmount = amount;
+        return true;
+    }
+
+    function allowance(address owner, address spender) external view returns (uint256) {
+        return 0;
+    }
+
+    function approve(address spender, uint256 amount) external returns (bool) {
+        return true;
+    }
+
+    address public transferFromAddress;
+    address public transferFromTo;
+    uint256 public transferFromAmount;
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 amount
+    ) external returns (bool) {
+        transferFromAddress = from;
+        transferFromTo = to;
+        transferFromAmount = amount;
+        return true;
+    }
+}

contracts/stubs/ERC20WrapableStub.sol

@@ -0,0 +1,56 @@
+// SPDX-FileCopyrightText: 2022 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.10;
+
+import {IERC20Bridged} from "../token/interfaces/IERC20Bridged.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC20Wrapable} from "../token/interfaces/IERC20Wrapable.sol";
+// import {ERC20Core} from "../token/ERC20Core.sol";
+import { console } from "hardhat/console.sol";
+
+// represents wstETH on L1
+contract ERC20WrapableStub is IERC20Wrapable, ERC20 {
+
+    IERC20 public stETH;
+    address public bridge;
+    uint256 public tokensRate; /// wst/st
+
+    constructor(IERC20 stETH_, string memory name_, string memory symbol_)
+        ERC20(name_, symbol_)
+    {
+        stETH = stETH_;
+        console.log("constructor wrap stETH=",address(stETH));
+
+        tokensRate = 2 * 10 **18;
+        _mint(msg.sender, 1000000 * 10**18);
+    }
+
+    function wrap(uint256 _stETHAmount) external returns (uint256) {
+        require(_stETHAmount > 0, "wstETH: can't wrap zero stETH");
+
+        uint256 wstETHAmount = (_stETHAmount * tokensRate) / (10 ** uint256(decimals()));
+
+
+        console.log("wrap msg.sender=",msg.sender);
+        console.log("wrap address(this)=",address(this));
+        console.log("wrap _stETHAmount=",_stETHAmount);
+        console.log("wrap wstETHAmount=",wstETHAmount);
+
+        _mint(msg.sender, wstETHAmount);
+        stETH.transferFrom(msg.sender, address(this), _stETHAmount);
+
+        return wstETHAmount;
+    }
+
+    function unwrap(uint256 _wstETHAmount) external returns (uint256) {
+        require(_wstETHAmount > 0, "wstETH: zero amount unwrap not allowed");
+
+        // uint256 stETHAmount = (_wstETHAmount * (10 ** uint256(decimals()))) / tokensRate;
+        // _burn(msg.sender, _wstETHAmount);
+        // stETH.transfer(msg.sender, stETHAmount);
+
+        return 0; //stETHAmount;
+    }
+}