Add Zapper for LidoARM

src/contracts/Interfaces.sol

@@ -255,3 +255,8 @@ interface IStETHWithdrawal {
     function getWithdrawalRequests(address _owner) external view returns (uint256[] memory requestsIds);
     function getLastRequestId() external view returns (uint256);
 }
+
+interface ILidoARM {
+    function deposit(uint256 assets) external returns (uint256 shares);
+    function transfer(address to, uint256 shares) external returns (bool);
+}

src/contracts/ZapperLidoARM.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// Contracts
+import {Ownable} from "./Ownable.sol";
+
+// Interfaces
+import {IWETH} from "./Interfaces.sol";
+import {IERC20} from "./Interfaces.sol";
+import {ILidoARM} from "./Interfaces.sol";
+
+contract ZapperLidoARM is Ownable {
+    IWETH public immutable weth;
+    ILidoARM public immutable lidoArm;
+
+    event Zap(address indexed sender, uint256 shares);
+
+    constructor(address _weth, address _lidoArm) {
+        weth = IWETH(_weth);
+        lidoArm = ILidoARM(_lidoArm);
+
+        weth.approve(_lidoArm, type(uint256).max);
+    }
+
+    /// @notice Deposit ETH to LidoARM and receive shares
+    receive() external payable {
+        deposit();
+    }
+
+    /// @notice Deposit ETH to LidoARM and receive shares
+    function deposit() public payable returns (uint256 shares) {
+        // Wrap all ETH to WETH
+        uint256 balance = address(this).balance;
+        weth.deposit{value: balance}();
+
+        // Deposit all WETH to LidoARM
+        shares = lidoArm.deposit(balance);
+
+        // Transfer received shares to msg.sender
+        lidoArm.transfer(msg.sender, shares);
+
+        // Emit event
+        emit Zap(msg.sender, shares);
+    }
+
+    /// @notice Rescue ERC20 tokens
+    /// @param token The address of the ERC20 token
+    function rescueERC20(address token, uint256 amount) external onlyOwner {
+        IERC20(token).transfer(msg.sender, amount);
+    }
+}

test/Base.sol

@@ -9,6 +9,7 @@ import {Proxy} from "contracts/Proxy.sol";
 import {OethARM} from "contracts/OethARM.sol";
 import {LidoARM} from "contracts/LidoARM.sol";
 import {CapManager} from "contracts/CapManager.sol";
+import {ZapperLidoARM} from "contracts/ZapperLidoARM.sol";
 
 // Interfaces
 import {IERC20} from "contracts/Interfaces.sol";
@@ -37,6 +38,7 @@ abstract contract Base_Test_ is Test {
     OethARM public oethARM;
     LidoARM public lidoARM;
     CapManager public capManager;
+    ZapperLidoARM public zapperLidoARM;
 
     IERC20 public oeth;
     IERC20 public weth;

test/fork/Zapper/Deposit.t.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// Test imports
+import {Fork_Shared_Test_} from "test/fork/shared/Shared.sol";
+
+// Contracts
+import {ZapperLidoARM} from "contracts/ZapperLidoARM.sol";
+
+contract Fork_Concrete_ZapperLidoARM_Deposit_Test_ is Fork_Shared_Test_ {
+    function setUp() public override {
+        super.setUp();
+
+        vm.deal(address(this), DEFAULT_AMOUNT);
+    }
+
+    function test_Deposit_ViaFunction() public setLiquidityProviderCap(address(zapperLidoARM), DEFAULT_AMOUNT) {
+        assertEq(lidoARM.balanceOf(address(this)), 0);
+        uint256 expectedShares = lidoARM.previewDeposit(DEFAULT_AMOUNT);
+
+        vm.expectEmit({emitter: address(zapperLidoARM)});
+        emit ZapperLidoARM.Zap(address(this), expectedShares);
+        // Deposit
+        zapperLidoARM.deposit{value: DEFAULT_AMOUNT}();
+
+        // Check balance
+        assertEq(lidoARM.balanceOf(address(this)), DEFAULT_AMOUNT);
+    }
+
+    function test_Deposit_ViaCall() public setLiquidityProviderCap(address(zapperLidoARM), DEFAULT_AMOUNT) {
+        assertEq(lidoARM.balanceOf(address(this)), 0);
+        uint256 expectedShares = lidoARM.previewDeposit(DEFAULT_AMOUNT);
+
+        vm.expectEmit({emitter: address(zapperLidoARM)});
+        emit ZapperLidoARM.Zap(address(this), expectedShares);
+        // Deposit
+        (bool success,) = address(zapperLidoARM).call{value: DEFAULT_AMOUNT}("");
+        assertTrue(success);
+
+        // Check balance
+        assertEq(lidoARM.balanceOf(address(this)), DEFAULT_AMOUNT);
+    }
+}

test/fork/Zapper/RescueToken.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// Test imports
+import {Fork_Shared_Test_} from "test/fork/shared/Shared.sol";
+
+// Contracts
+import {ZapperLidoARM} from "contracts/ZapperLidoARM.sol";
+
+contract Fork_Concrete_ZapperLidoARM_RescueToken_Test_ is Fork_Shared_Test_ {
+    function test_RevertWhen_RescueToken_CalledByNonOwner() public asRandomAddress {
+        vm.expectRevert("ARM: Only owner can call this function.");
+        zapperLidoARM.rescueERC20(address(badToken), DEFAULT_AMOUNT);
+    }
+
+    function test_RescueToken() public {
+        deal(address(weth), address(zapperLidoARM), DEFAULT_AMOUNT);
+        assertEq(weth.balanceOf(address(zapperLidoARM)), DEFAULT_AMOUNT);
+        assertEq(weth.balanceOf(address(this)), 0);
+
+        // Rescue the tokens
+        vm.prank(zapperLidoARM.owner());
+        zapperLidoARM.rescueERC20(address(weth), DEFAULT_AMOUNT);
+
+        // Check balance
+        assertEq(weth.balanceOf(address(zapperLidoARM)), 0);
+        assertEq(weth.balanceOf(address(this)), DEFAULT_AMOUNT);
+    }
+}

test/fork/shared/Shared.sol

@@ -12,6 +12,7 @@ import {Proxy} from "contracts/Proxy.sol";
 import {OethARM} from "contracts/OethARM.sol";
 import {LidoARM} from "contracts/LidoARM.sol";
 import {CapManager} from "contracts/CapManager.sol";
+import {ZapperLidoARM} from "contracts/ZapperLidoARM.sol";
 
 // Interfaces
 import {IERC20} from "contracts/Interfaces.sol";
@@ -165,6 +166,9 @@ abstract contract Fork_Shared_Test_ is Modifiers {
 
         // set prices
         lidoARM.setPrices(992 * 1e33, 1001 * 1e33);
+
+        // --- Deploy ZapperLidoARM ---
+        zapperLidoARM = new ZapperLidoARM(address(weth), address(lidoProxy));
     }
 
     function _label() internal {
@@ -178,6 +182,7 @@ abstract contract Fork_Shared_Test_ is Modifiers {
         vm.label(address(lidoARM), "LIDO ARM");
         vm.label(address(lidoProxy), "LIDO ARM PROXY");
         vm.label(address(capManager), "LIQUIDITY PROVIDER CONTROLLER");
+        vm.label(address(zapperLidoARM), "ZAPPER LIDO ARM");
         vm.label(operator, "OPERATOR");
         vm.label(oethWhale, "WHALE OETH");
         vm.label(governor, "GOVERNOR");