[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,36 @@ 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
+REBASABLE_TOKEN=
+
+# Address of token rate notifier. Connects Lido core protocol.
+TOKEN_RATE_NOTIFIER=
+
+# Address of token rate pusher
+L1_OP_STACK_TOKEN_RATE_PUSHER=
+
+# Gas limit required to complete pushing token rate on L2.
+L2_GAS_LIMIT_FOR_PUSHING_TOKEN_RATE=
+
+# A time period when token rate can be considered outdated.
+RATE_OUTDATED_DELAY=
+
+# Address of L1 token bridge proxy.
+L1_TOKEN_BRIDGE=
+
+# Address of L2 token bridge proxy.
+L2_TOKEN_BRIDGE=
+
+# Address of the non-rebasable token proxy on L2.
+L2_TOKEN=
+
+# Address of token rate oracle on L2
+L2_TOKEN_RATE_ORACLE=
+
+# Address of bridge executor.
+GOV_BRIDGE_EXECUTOR=
+
 # Name of the network environments used by deployment scripts.
 # Might be one of: "mainnet", "goerli".
 NETWORK=mainnet
@@ -74,6 +104,10 @@ TESTING_ARB_L2_GATEWAY_ROUTER=0x57f54f87C44d816f60b92864e23b8c0897D4d81D
 TESTING_OPT_NETWORK=
 TESTING_OPT_L1_TOKEN=0xaF8a2F0aE374b03376155BF745A3421Dac711C12
 TESTING_OPT_L2_TOKEN=0xAED5F9aaF167923D34174b8E636aaF040A11f6F7
+TESTING_OPT_L1_TOKEN_RATE_NOTIFIER=0x554f2C7D58522c050d38Ebea4FF072ED7C4e61cb
+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
+REBASABLE_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.
+- [`REBASABLE_TOKEN`] (#REBASABLE_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.
+
+#### `REBASABLE_TOKEN`
+
+Address of the rebasable token to deploy new bridge on the Ethereum chain.
 
 #### `NETWORK`
 

contracts/arbitrum/README.md

@@ -695,36 +695,6 @@ Returns a `bool` value indicating whether the operation succeeded.
 
 Transfers `amount` of token from the `from_` account to `to_` using the allowance mechanism. `amount_` is then deducted from the caller's allowance. Returns a `bool` value indicating whether the operation succeed.
 
-#### `increaseAllowance(address,uint256)`
-
-> **Visibility:**     `external`
->
-> **Returns**        `(bool)`
->
-> **Arguments:**
->
-> - **`spender_`** - an address of the tokens spender
-> - **`addedValue_`** - a number to increase allowance
->
-> **Emits:** `Approval(address indexed owner, address indexed spender, uint256 value)`
-
-Atomically increases the allowance granted to `spender` by the caller. Returns a `bool` value indicating whether the operation succeed.
-
-#### `decreaseAllowance(address,uint256)`
-
-> **Visibility:**     `external`
->
-> **Returns**        `(bool)`
->
-> **Arguments:**
->
-> - **`spender_`** - an address of the tokens spender
-> - **`subtractedValue_`** - a number to decrease allowance
->
-> **Emits:** `Approval(address indexed owner, address indexed spender, uint256 value)`
-
-Atomically decreases the allowance granted to `spender` by the caller. Returns a `bool` value indicating whether the operation succeed.
-
 ## `ERC20Bridged`
 
 **Implements:** [`IERC20Bridged`](https://github.com/lidofinance/lido-l2/blob/main/contracts/token/interfaces/IERC20Bridged.sol)

contracts/lib/SignatureChecker.sol

@@ -0,0 +1,77 @@
+// SPDX-FileCopyrightText: 2024 OpenZeppelin, Lido <[email protected]>
+// SPDX-License-Identifier: GPL-3.0
+// Writen based on (utils/cryptography/SignatureChecker.sol from d398d68
+
+pragma solidity 0.8.10;
+
+import {ECDSA} from "@openzeppelin/contracts-v4.9/utils/cryptography/ECDSA.sol";
+import {IERC1271} from "@openzeppelin/contracts-v4.9/interfaces/IERC1271.sol";
+
+
+
+/**
+ * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
+ * signatures from externally owned accounts (EOAs) as well as ERC-1271 signatures from smart contract wallets like
+ * Argent and Safe Wallet (previously Gnosis Safe).
+ */
+library SignatureChecker {
+ /**
+ * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
+ * signature is validated against that smart contract using ERC-1271, otherwise it's validated using `ECDSA.recover`.
+ *
+ * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
+ * change through time. It could return true at block N and false at block N+1 (or the opposite).
+ */
+ function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
+ if (signer.code.length == 0) {
+ // return true;
+ (address recovered, ECDSA.RecoverError err) = ECDSA.tryRecover(hash, signature);
+ return err == ECDSA.RecoverError.NoError && recovered == signer;
+ } else {
+ return isValidERC1271SignatureNow(signer, hash, signature);
+ }
+ }
+
+ /**
+ * @dev Checks signature validity.
+ *
+ * If the signer address doesn't contain any code, assumes that the address is externally owned
+ * and the signature is a ECDSA signature generated using its private key. Otherwise, issues a
+ * static call to the signer address to check the signature validity using the ERC-1271 standard.
+ */
+ function isValidSignatureNow(
+ address signer,
+ bytes32 msgHash,
+ uint8 v,
+ bytes32 r,
+ bytes32 s
+ ) internal view returns (bool) {
+ if (signer.code.length == 0) {
+ (address recovered, ECDSA.RecoverError err) = ECDSA.tryRecover(msgHash, v, r, s);
+ return err == ECDSA.RecoverError.NoError && recovered == signer;
+ } else {
+ bytes memory signature = abi.encodePacked(r, s, v);
+ return isValidERC1271SignatureNow(signer, msgHash, signature);
+ }
+ }
+
+ /**
+ * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated
+ * against the signer smart contract using ERC-1271.
+ *
+ * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
+ * change through time. It could return true at block N and false at block N+1 (or the opposite).
+ */
+ function isValidERC1271SignatureNow(
+ address signer,
+ bytes32 hash,
+ bytes memory signature
+ ) internal view returns (bool) {
+ (bool success, bytes memory result) = signer.staticcall(
+ abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature)
+ );
+ return (success &&
+ result.length >= 32 &&
+ abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
+ }
+}

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)
+ );
+ }
+}