feat: update LidoLocator with wstEth contract address

.github/workflows/tests-integration.yml

@@ -10,7 +10,7 @@ jobs:
 
     services:
       hardhat-node:
-        image: feofanov/hardhat-node:2.22.8
+        image: feofanov/hardhat-node:2.22.9
         ports:
           - 8545:8545
         env:

.prettierignore

@@ -1,6 +1,9 @@
 foundry
+contracts/**/*.sol
 
 .gitignore
 .prettierignore
 
+eslint.config.mjs
+
 package-lock.json

.prettierrc

@@ -3,5 +3,16 @@
   "singleQuote": false,
   "printWidth": 120,
   "tabWidth": 2,
-  "quoteProps": "consistent"
+  "quoteProps": "consistent",
+  "plugins": ["prettier-plugin-solidity"],
+  "overrides": [
+    {
+      "files": "*.sol",
+      "options": {
+        "parser": "solidity-parse",
+        "tabWidth": 4,
+        "useTabs": false
+      }
+    }
+  ]
 }

CONTRIBUTING.md

@@ -128,99 +128,93 @@ This repository features a Hardhat-Foundry dual setup:
 - Hardhat gives much more flexibility when writing complex tests;
 - The Foundry's fuzzing capabilities enable better coverage of edge cases.
 
-#### Tracing
+#### Hardhat
+
+Hardhat tests are all located in `/tests` at the root of the project.
+Each subdirectory name corresponds to the version of the contract being tested, mirroring the `/contracts` directory
+structure. Integration, regression, and other non-unit tests are placed into corresponding subdirectories,
+e.g. `/tests/integration/`, ` /tests/regression`, etc.
+
+##### Tracing
 
-`hardhat-tracer` is used to trace contract calls and state changes during tests.
+During Hardhat tests, the `hardhat-tracer` is used to trace contract calls and state changes.
 Full-scale transaction tracing is disabled by default because it can significantly slow down the tests.
 
+> [!NOTE]
+> Tracing is ONLY supported in Hardhat unit tests and integration tests using Hardhat mainnet fork (see below).
+
 To enable tracing, you need to wrap the code you want to trace with the `Tracer.enable()` and `Tracer.disable()`
-functions:
+functions and run the tests with the appropriate command postfix, e.g. `yarn test:trace`.
 
 ```typescript
-import { Tracer } from 'test/suite';
+import { Tracer } from "test/suite";
 
-describe('MyContract', () => {
-  it('should do something', async () => {
+describe("MyContract", () => {
+  it("should do something", async () => {
     Tracer.enable();
     // code to trace
     Tracer.disable();
   });
 });
 ```
 
-Then run the tests with the following commands:
+##### Unit tests
 
-```bash
-yarn test:trace                   # Run all tests with trace logging (calls only)
-yarn test:fulltrace               # Run all tests with full trace logging (calls and storage ops)
-yarn test:integration:trace       # Run all integration tests with trace logging
-yarn test:integration:fulltrace   # Run all integration tests with full trace logging
-```
+Unit tests are located in `/tests` at the root of the project.
+These tests are designed to verify the behavior of individual contracts and functions.
+Naming conventions follow utilizes the `*.test.ts` postfix, e.g. `myContract.test.ts`.
 
-> [!NOTE]
-> Tracing is not supported in Foundry tests and integration tests other than Hardhat mainnet fork tests.
+If you require mocks or wrappers for external contracts, please place them in the appropriate subdirectories, such as
+`/tests/0.4.24/contracts` and adhere to the naming conventions:
 
-#### Hardhat
+- Use the `Mock` postfix for self-established contracts that simulate the behavior of the target contract. For example,
+  `MyContract_Mock.sol` or `MyContract_MockForAnotherContract.sol`.
+- Use the `Harness` postfix for a wrapper that exposes private functions of a contract and may include test-specific
+  actions. For example, `MyContract_Wrapper.sol` or `MyContract_WrapperForAnotherContract.sol`.
 
-Hardhat tests are all located in `/tests` at the root of the project.
-Each subdirectory name corresponds to the version of the contract being tested, mirroring the `/contracts` directory
-structure. Integration, regression, and other non-unit tests are placed into corresponding subdirectories,
-e.g. `/tests/integration/`, ` /tests/regression`, etc.
+You can run unit tests in multiple ways:
 
 ```bash
 yarn test               # Run all tests in parallel
 yarn test:sequential    # Run all tests sequentially
-yarn test:trace         # Run all tests with trace logging (see Tracing section)
+yarn test:trace         # Run all tests with trace logging (calls only)
+yarn test:fulltrace     # Run all tests with full trace logging (calls and storage ops)
 yarn test:watch         # Run all tests in watch mode
 ```
 
-#### Foundry
-
-Foundry's Solidity tests are used only for fuzzing library contracts or functions performing complex calculations
-or byte juggling. Solidity tests are located under ` / tests` and in the appropriate subdirectories. Naming conventions
-follow the Foundry's [documentation](https://book.getfoundry.sh/tutorials/best-practices#general-test-guidance):
-
-- for tests, postfix `.t.sol` is used (e.g., `MyContract.t.sol`)
-- for scripts, postfix `.s.sol` is used (e.g., `MyScript.s.sol`)
-- for helpers, postfix `.h.sol` is used (e.g., `MyHelper.h.sol`).
-
-Following the convention of distinguishing Hardhat test files from Foundry-related files is essential to ensure the
-proper execution of Hardhat tests.
-
-```bash
-yarn test:foundry        # Run all Foundry tests
-```
-
-#### Integration tests
+##### Integration tests
 
 Integration tests are located in `/tests/integration` at the root of the project.
 These tests are used to verify the interaction between different contracts and their behavior in a real-world scenario.
+Naming conventions follow the `*.int.ts` postfix, e.g. `myScenario.int.ts`.
 
 You can run integration tests in multiple ways, but for all of them, you need to have a `.env` file in the root of
 the project (you can use `.env.example` as a template).
 
-##### Hardhat Mainnet Fork
+###### Hardhat Mainnet Fork
 
 This is the most common way to run integration tests. It uses the Hardhat mainnet fork to simulate the mainnet
 environment. Requires `HARDHAT_FORKING_URL` and `HARDHAT_FORKING_BLOCK_NUMBER` (optional) to be set in the `.env` file
-along with `MAINNET_*` env variables (see `.env.example`).
+along with some `MAINNET_*` env variables (see `.env.example`).
 
 ```bash
-yarn test:integration         # Run all integration tests
-yarn test:integration:trace   # Run all integration tests with trace logging (see Tracing section) 
+yarn test:integration             # Run all integration tests
+yarn test:integration:trace       # Run all integration tests with trace logging (calls only)
+yarn test:integration:fulltrace   # Run all integration tests with full trace logging (calls and storage ops)
 ```
 
-##### Local setup
+###### Local setup
 
 This method is used to run integration tests against a local scratch deployment (
 see [scratch-deploy.md](./docs/scratch-deploy.md)).
-Requires `LOCAL_*` env variables to be set and a local deployment to be running on port `8555`.
+Requires a local deployment to be running on port `8555` and `deployed-local.json` with the deployed addresses
+(automatically generated during the scratch deployment).
 
 ```bash
 yarn test:integration:local
 ```
 
-##### Any fork setup
+###### Any fork setup
 
 This method is used to run integration tests against any fork. Requires `MAINNET_*` env variables to be set in the
 `.env` file and a fork to be running on port `8545`.
@@ -229,6 +223,23 @@ This method is used to run integration tests against any fork. Requires `MAINNET
 yarn test:integration:fork
 ```
 
+#### Foundry tests
+
+Foundry's Solidity tests are used only for fuzzing library contracts or functions performing complex calculations
+or byte juggling. Solidity tests are located under ` / tests` and in the appropriate subdirectories. Naming conventions
+follow the Foundry's [documentation](https://book.getfoundry.sh/tutorials/best-practices#general-test-guidance):
+
+- for tests, postfix `.t.sol` is used (e.g., `MyContract.t.sol`)
+- for scripts, postfix `.s.sol` is used (e.g., `MyScript.s.sol`)
+- for helpers, postfix `.h.sol` is used (e.g., `MyHelper.h.sol`).
+
+Following the convention of distinguishing Hardhat test files from Foundry-related files is essential to ensure the
+proper execution of Hardhat tests.
+
+```bash
+yarn test:foundry        # Run all Foundry tests
+```
+
 #### Coverage
 
 The project uses the `hardhat-coverage` plugin to generate coverage reports.

contracts/0.8.9/LidoLocator.sol

@@ -1,9 +1,10 @@
 // SPDX-FileCopyrightText: 2023 Lido <[email protected]>
 // SPDX-License-Identifier: GPL-3.0
 
-/* See contracts/COMPILERS.md */
 pragma solidity 0.8.9;
 
+// solhint-disable immutable-vars-naming
+
 import {ILidoLocator} from "../common/interfaces/ILidoLocator.sol";
 
 /**
@@ -28,6 +29,7 @@ contract LidoLocator is ILidoLocator {
         address withdrawalQueue;
         address withdrawalVault;
         address oracleDaemonConfig;
+        address wstEth;
     }
 
     error ZeroAddress();
@@ -46,6 +48,7 @@ contract LidoLocator is ILidoLocator {
     address public immutable withdrawalQueue;
     address public immutable withdrawalVault;
     address public immutable oracleDaemonConfig;
+    address public immutable wstEth;
 
     /**
      * @notice declare service locations
@@ -67,9 +70,10 @@ contract LidoLocator is ILidoLocator {
         withdrawalQueue = _assertNonZero(_config.withdrawalQueue);
         withdrawalVault = _assertNonZero(_config.withdrawalVault);
         oracleDaemonConfig = _assertNonZero(_config.oracleDaemonConfig);
+        wstEth = _assertNonZero(_config.wstEth);
     }
 
-    function coreComponents() external view returns(
+    function coreComponents() external view returns (
         address,
         address,
         address,
@@ -87,7 +91,7 @@ contract LidoLocator is ILidoLocator {
         );
     }
 
-    function oracleReportComponentsForLido() external view returns(
+    function oracleReportComponentsForLido() external view returns (
         address,
         address,
         address,

contracts/common/interfaces/ILidoLocator.sol

@@ -1,34 +1,41 @@
 // SPDX-FileCopyrightText: 2023 Lido <[email protected]>
 // SPDX-License-Identifier: GPL-3.0
 
-// See contracts/COMPILERS.md
 // solhint-disable-next-line
 pragma solidity >=0.4.24 <0.9.0;
 
 interface ILidoLocator {
-    function accountingOracle() external view returns(address);
-    function depositSecurityModule() external view returns(address);
-    function elRewardsVault() external view returns(address);
-    function legacyOracle() external view returns(address);
-    function lido() external view returns(address);
-    function oracleReportSanityChecker() external view returns(address);
-    function burner() external view returns(address);
-    function stakingRouter() external view returns(address);
-    function treasury() external view returns(address);
-    function validatorsExitBusOracle() external view returns(address);
-    function withdrawalQueue() external view returns(address);
-    function withdrawalVault() external view returns(address);
-    function postTokenRebaseReceiver() external view returns(address);
-    function oracleDaemonConfig() external view returns(address);
-    function coreComponents() external view returns(
+
+    function accountingOracle() external view returns (address);
+    function depositSecurityModule() external view returns (address);
+    function elRewardsVault() external view returns (address);
+    function legacyOracle() external view returns (address);
+    function lido() external view returns (address);
+    function oracleReportSanityChecker() external view returns (address);
+    function burner() external view returns (address);
+    function stakingRouter() external view returns (address);
+    function treasury() external view returns (address);
+    function validatorsExitBusOracle() external view returns (address);
+    function withdrawalQueue() external view returns (address);
+    function withdrawalVault() external view returns (address);
+    function postTokenRebaseReceiver() external view returns (address);
+    function oracleDaemonConfig() external view returns (address);
+    function wstEth() external view returns (address);
+
+    /// @dev Returns a batch of core components addresses at once.
+    ///      It's just a more gas-efficient way of calling several public getters at once.
+    function coreComponents() external view returns (
         address elRewardsVault,
         address oracleReportSanityChecker,
         address stakingRouter,
         address treasury,
         address withdrawalQueue,
         address withdrawalVault
     );
-    function oracleReportComponentsForLido() external view returns(
+
+    /// @dev Returns a batch of addresses that is used specifically during oracle report handling in the Lido contract.
+    ///      It's just a more gas-efficient way of calling several public getters at once.
+    function oracleReportComponentsForLido() external view returns (
         address accountingOracle,
         address elRewardsVault,
         address oracleReportSanityChecker,

lib/deploy.ts

@@ -54,7 +54,7 @@ async function getDeployTxParams(deployer: string) {
       maxFeePerGas: ethers.parseUnits(String(GAS_MAX_FEE), "gwei"),
     };
   } else {
-    throw new Error("Must specify gas ENV vars: \"GAS_PRIORITY_FEE\" and \"GAS_MAX_FEE\" in gwei (like just \"3\")");
+    throw new Error('Must specify gas ENV vars: "GAS_PRIORITY_FEE" and "GAS_MAX_FEE" in gwei (like just "3")');
   }
 }
 

lib/event.ts

@@ -42,11 +42,15 @@ const parseLogEntry = (entry: Log, interfaces: Interface[]): LogDescription | nu
   return null;
 };
 
-export function findEventsWithInterfaces(receipt: ContractTransactionReceipt, eventName: string, interfaces: Interface[]): LogDescription[] {
+export function findEventsWithInterfaces(
+  receipt: ContractTransactionReceipt,
+  eventName: string,
+  interfaces: Interface[],
+): LogDescription[] {
   const events: LogDescription[] = [];
   const notParsedLogs: Log[] = [];
 
-  receipt.logs.forEach(entry => {
+  receipt.logs.forEach((entry) => {
     const logDescription = parseLogEntry(entry, interfaces);
     if (logDescription) {
       events.push(logDescription);
@@ -59,7 +63,7 @@ export function findEventsWithInterfaces(receipt: ContractTransactionReceipt, ev
     // log.warning("The following logs could not be parsed:", notParsedLogs);
   }
 
-  return events.filter(e => e.name === eventName);
+  return events.filter((e) => e.name === eventName);
 }
 
 export function findEvents(receipt: ContractTransactionReceipt, eventName: string) {

lib/protocol/context.ts

@@ -13,7 +13,7 @@ const getSigner = async (signer: Signer, balance = ether("100"), signers: Protoc
 
 export const getProtocolContext = async (): Promise<ProtocolContext> => {
   const { contracts, signers } = await discover();
-  const interfaces = Object.values(contracts).map(contract => contract.interface);
+  const interfaces = Object.values(contracts).map((contract) => contract.interface);
 
   // By default, all flags are "on"
   const flags = {
@@ -30,7 +30,8 @@ export const getProtocolContext = async (): Promise<ProtocolContext> => {
     interfaces,
     flags,
     getSigner: async (signer: Signer, balance?: bigint) => getSigner(signer, balance, signers),
-    getEvents: (receipt: ContractTransactionReceipt, eventName: string) => findEventsWithInterfaces(receipt, eventName, interfaces),
+    getEvents: (receipt: ContractTransactionReceipt, eventName: string) =>
+      findEventsWithInterfaces(receipt, eventName, interfaces),
   } as ProtocolContext;
 
   await provision(context);