[WIP] Add Rebasable token to Optimism

.editorconfig

@@ -0,0 +1,15 @@
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+charset = utf-8
+indent_style = space
+indent_size = 4
+
+[*.{js,yml,json,cjs}]
+indent_size = 2
+max_line_length = 120

.env.example

@@ -28,6 +28,9 @@ ETHERSCAN_API_KEY_OPT=
 # Address of the token to deploy the bridge/gateway for
 TOKEN=
 
+# Address of the rebasable token to deploy the bridge/gateway for
+STETH_TOKEN=
+
 # Name of the network environments used by deployment scripts.
 # Might be one of: "mainnet", "goerli".
 NETWORK=mainnet
@@ -74,6 +77,9 @@ TESTING_ARB_L2_GATEWAY_ROUTER=0x57f54f87C44d816f60b92864e23b8c0897D4d81D
 TESTING_OPT_NETWORK=
 TESTING_OPT_L1_TOKEN=0xaF8a2F0aE374b03376155BF745A3421Dac711C12
 TESTING_OPT_L2_TOKEN=0xAED5F9aaF167923D34174b8E636aaF040A11f6F7
+TESTING_OPT_L1_REBASABLE_TOKEN=0xB82381A3fBD3FaFA77B3a7bE693342618240067b
+TESTING_OPT_L2_REBASABLE_TOKEN=0x6696Cb7bb602FC744254Ad9E07EfC474FBF78857
+TESTING_OPT_L2_TOKEN_RATE_ORACLE=0x8ea513d1e5Be31fb5FC2f2971897594720de9E70
 TESTING_OPT_L1_ERC20_TOKEN_BRIDGE=0x243b661276670bD17399C488E7287ea4D416115b
 TESTING_OPT_L2_ERC20_TOKEN_BRIDGE=0x447CD1794d209Ac4E6B4097B34658bc00C4d0a51
 

.env.wsteth.opt_mainnet

@@ -21,6 +21,9 @@ ETHERSCAN_API_KEY_OPT=
 # Address of the token to deploy the bridge/gateway for
 TOKEN=0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0
 
+# Address of the rebasable token to deploy the bridge/gateway for
+STETH_TOKEN=
+
 # Name of the network environments used by deployment scripts.
 # Might be one of: "mainnet", "goerli".
 NETWORK=mainnet

README.md

@@ -42,7 +42,8 @@ Fill the newly created `.env` file with the required variables. See the [Project
 
 The configuration of the deployment scripts happens via the ENV variables. The following variables are required:
 
-- [`TOKEN`](#TOKEN) - address of the token to deploy a new bridge on the Ethereum chain.
+- [`TOKEN`](#TOKEN) - address of the non-rebasable token to deploy a new bridge on the Ethereum chain.
+- [`STETH_TOKEN`] (#STETH_TOKEN) - address of the rebasable token to deploy new bridge on the Ethereum chain.
 - [`NETWORK`](#NETWORK) - name of the network environments used by deployment scripts. Allowed values: `mainnet`, `goerli`.
 - [`FORKING`](#FORKING) - run deployment in the forking network instead of real ones
 - [`ETH_DEPLOYER_PRIVATE_KEY`](#ETH_DEPLOYER_PRIVATE_KEY) - The private key of the deployer account in the Ethereum network is used during the deployment process.
@@ -314,7 +315,11 @@ Below variables used in the Arbitrum/Optimism bridge deployment process.
 
 #### `TOKEN`
 
-Address of the token to deploy a new bridge on the Ethereum chain.
+Address of the non-rebasable token to deploy a new bridge on the Ethereum chain.
+
+#### `STETH_TOKEN`
+
+Address of the rebasable token to deploy new bridge on the Ethereum chain.
 
 #### `NETWORK`
 

contracts/lido/TokenRateNotifier.sol

@@ -0,0 +1,120 @@
+// SPDX-FileCopyrightText: 2024 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.10;
+
+import {IPostTokenRebaseReceiver} from "./interfaces/IPostTokenRebaseReceiver.sol";
+import {ITokenRatePusher} from "./interfaces/ITokenRatePusher.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
+
+/// @author kovalgek
+/// @notice Notifies all observers when rebase event occures.
+contract TokenRateNotifier is Ownable, IPostTokenRebaseReceiver {
+ using ERC165Checker for address;
+
+ /// @notice Maximum amount of observers to be supported.
+ uint256 public constant MAX_OBSERVERS_COUNT = 16;
+
+ /// @notice Invalid interface id.
+ bytes4 public constant INVALID_INTERFACE_ID = 0xffffffff;
+
+ /// @notice A value that indicates that value was not found.
+ uint256 public constant INDEX_NOT_FOUND = type(uint256).max;
+
+ /// @notice An interface that each observer should support.
+ bytes4 public constant REQUIRED_INTERFACE = type(ITokenRatePusher).interfaceId;
+
+ /// @notice All observers.
+ address[] public observers;
+
+ /// @notice Add a `observer_` to the back of array
+ /// @param observer_ observer address
+ function addObserver(address observer_) external onlyOwner {
+ if (observer_ == address(0)) {
+ revert ErrorZeroAddressObserver();
+ }
+ if (!observer_.supportsInterface(REQUIRED_INTERFACE)) {
+ revert ErrorBadObserverInterface();
+ }
+ if (observers.length >= MAX_OBSERVERS_COUNT) {
+ revert ErrorMaxObserversCountExceeded();
+ }
+
+ observers.push(observer_);
+ emit ObserverAdded(observer_);
+ }
+
+ /// @notice Remove a observer at the given `observer_` position
+ /// @param observer_ observer remove position
+ function removeObserver(address observer_) external onlyOwner {
+
+ uint256 observerIndexToRemove = _observerIndex(observer_);
+
+ if (observerIndexToRemove == INDEX_NOT_FOUND) {
+ revert ErrorNoObserverToRemove();
+ }
+
+ for (uint256 obIndex = observerIndexToRemove; obIndex < observers.length - 1; obIndex++) {
+ observers[obIndex] = observers[obIndex + 1];
+ }
+
+ observers.pop();
+
+ emit ObserverRemoved(observer_);
+ }
+
+ /// @inheritdoc IPostTokenRebaseReceiver
+ function handlePostTokenRebase(
+ uint256,
+ uint256,
+ uint256,
+ uint256,
+ uint256,
+ uint256,
+ uint256
+ ) external {
+ for (uint256 obIndex = 0; obIndex < observers.length; obIndex++) {
+ try ITokenRatePusher(observers[obIndex]).pushTokenRate() {}
+ catch (bytes memory lowLevelRevertData) {
+ /// @dev This check is required to prevent incorrect gas estimation of the method.
+ /// Without it, Ethereum nodes that use binary search for gas estimation may
+ /// return an invalid value when the pushTokenRate() reverts because of the
+ /// "out of gas" error. Here we assume that the pushTokenRate() method doesn't
+ /// have reverts with empty error data except "out of gas".
+ if (lowLevelRevertData.length == 0) revert ErrorTokenRateNotifierRevertedWithNoData();
+ emit PushTokenRateFailed(
+ observers[obIndex],
+ lowLevelRevertData
+ );
+ }
+ }
+ }
+
+ /// @notice Observer length
+ /// @return Added observers count
+ function observersLength() public view returns (uint256) {
+ return observers.length;
+ }
+
+ /// @notice `observer_` index in `observers` array.
+ /// @return An index of `observer_` or `INDEX_NOT_FOUND` if it wasn't found.
+ function _observerIndex(address observer_) internal view returns (uint256) {
+ for (uint256 obIndex = 0; obIndex < observers.length; obIndex++) {
+ if (observers[obIndex] == observer_) {
+ return obIndex;
+ }
+ }
+ return INDEX_NOT_FOUND;
+ }
+
+ event PushTokenRateFailed(address indexed observer, bytes lowLevelRevertData);
+ event ObserverAdded(address indexed observer);
+ event ObserverRemoved(address indexed observer);
+
+ error ErrorTokenRateNotifierRevertedWithNoData();
+ error ErrorZeroAddressObserver();
+ error ErrorBadObserverInterface();
+ error ErrorMaxObserversCountExceeded();
+ error ErrorNoObserverToRemove();
+}

contracts/lido/interfaces/IPostTokenRebaseReceiver.sol

@@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: 2024 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.10;
+
+/// @author kovalgek
+/// @notice An interface to subscribe on the `stETH` token rebases (defined in the `Lido` core contract)
+interface IPostTokenRebaseReceiver {
+
+ /// @notice Is called in the context of `Lido.handleOracleReport` to notify the subscribers about each token rebase
+ function handlePostTokenRebase(
+ uint256 _reportTimestamp,
+ uint256 _timeElapsed,
+ uint256 _preTotalShares,
+ uint256 _preTotalEther,
+ uint256 _postTotalShares,
+ uint256 _postTotalEther,
+ uint256 _sharesMintedAsFees
+ ) external;
+}

contracts/lido/interfaces/ITokenRatePusher.sol

@@ -0,0 +1,11 @@
+// SPDX-FileCopyrightText: 2024 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.10;
+
+/// @author kovalgek
+/// @notice An interface for entity that pushes rate.
+interface ITokenRatePusher {
+ /// @notice Pushes token rate to L2 by depositing zero tokens.
+ function pushTokenRate() external;
+}

contracts/lido/stubs/OpStackTokenRatePusherWithOutOfGasErrorStub.sol

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: 2024 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.10;
+
+import {ITokenRatePusher} from "../interfaces/ITokenRatePusher.sol";
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+
+contract OpStackTokenRatePusherWithOutOfGasErrorStub is ERC165, ITokenRatePusher {
+
+ mapping (uint256 => uint256) data;
+
+ function pushTokenRate() external {
+ for (uint256 i = 0; i < 1000000000000; ++i) {
+ data[i] = i;
+ }
+ }
+
+ /// @inheritdoc ERC165
+ function supportsInterface(bytes4 _interfaceId) public view virtual override returns (bool) {
+ return (
+ _interfaceId == type(ITokenRatePusher).interfaceId
+ || super.supportsInterface(_interfaceId)
+ );
+ }
+}

contracts/lido/stubs/OpStackTokenRatePusherWithSomeErrorStub.sol

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: 2024 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.10;
+
+import {ITokenRatePusher} from "../interfaces/ITokenRatePusher.sol";
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+
+contract OpStackTokenRatePusherWithSomeErrorStub is ERC165, ITokenRatePusher {
+
+ error SomeError();
+
+ function pushTokenRate() external {
+ revert SomeError();
+ }
+
+ /// @inheritdoc ERC165
+ function supportsInterface(bytes4 _interfaceId) public view virtual override returns (bool) {
+ return (
+ _interfaceId == type(ITokenRatePusher).interfaceId
+ || super.supportsInterface(_interfaceId)
+ );
+ }
+}

contracts/optimism/CrossDomainEnabled.sol

@@ -8,11 +8,11 @@ import {ICrossDomainMessenger} from "./interfaces/ICrossDomainMessenger.sol";
 /// @dev Helper contract for contracts performing cross-domain communications
 contract CrossDomainEnabled {
  /// @notice Messenger contract used to send and receive messages from the other domain
- ICrossDomainMessenger public immutable messenger;
+ ICrossDomainMessenger public immutable MESSENGER;
 
  /// @param messenger_ Address of the CrossDomainMessenger on the current layer
  constructor(address messenger_) {
- messenger = ICrossDomainMessenger(messenger_);
+ MESSENGER = ICrossDomainMessenger(messenger_);
  }
 
  /// @dev Sends a message to an account on another domain
@@ -25,17 +25,17 @@ contract CrossDomainEnabled {
  uint32 gasLimit_,
  bytes memory message_
  ) internal {
- messenger.sendMessage(crossDomainTarget_, message_, gasLimit_);
+ MESSENGER.sendMessage(crossDomainTarget_, message_, gasLimit_);
  }
 
  /// @dev Enforces that the modified function is only callable by a specific cross-domain account
  /// @param sourceDomainAccount_ The only account on the originating domain which is
  /// authenticated to call this function
  modifier onlyFromCrossDomainAccount(address sourceDomainAccount_) {
- if (msg.sender != address(messenger)) {
+ if (msg.sender != address(MESSENGER)) {
  revert ErrorUnauthorizedMessenger();
  }
- if (messenger.xDomainMessageSender() != sourceDomainAccount_) {
+ if (MESSENGER.xDomainMessageSender() != sourceDomainAccount_) {
  revert ErrorWrongCrossDomainSender();
  }
  _;

contracts/optimism/DepositDataCodec.sol

@@ -0,0 +1,44 @@
+// SPDX-FileCopyrightText: 2023 Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity 0.8.10;
+
+/// @author kovalgek
+/// @notice encodes and decodes DepositData for crosschain transfering.
+contract DepositDataCodec {
+
+ uint8 internal constant RATE_FIELD_SIZE = 12;
+ uint8 internal constant TIMESTAMP_FIELD_SIZE = 5;
+
+ struct DepositData {
+ uint96 rate;
+ uint40 timestamp;
+ bytes data;
+ }
+
+ function encodeDepositData(DepositData memory depositData) internal pure returns (bytes memory) {
+ bytes memory data = bytes.concat(
+ abi.encodePacked(depositData.rate),
+ abi.encodePacked(depositData.timestamp),
+ abi.encodePacked(depositData.data)
+ );
+ return data;
+ }
+
+ function decodeDepositData(bytes calldata buffer) internal pure returns (DepositData memory) {
+
+ if (buffer.length < RATE_FIELD_SIZE + TIMESTAMP_FIELD_SIZE) {
+ revert ErrorDepositDataLength();
+ }
+
+ DepositData memory depositData = DepositData({
+ rate: uint96(bytes12(buffer[0:RATE_FIELD_SIZE])),
+ timestamp: uint40(bytes5(buffer[RATE_FIELD_SIZE:RATE_FIELD_SIZE + TIMESTAMP_FIELD_SIZE])),
+ data: buffer[RATE_FIELD_SIZE + TIMESTAMP_FIELD_SIZE:]
+ });
+
+ return depositData;
+ }
+
+ error ErrorDepositDataLength();
+}