Add arcadia strategy adapter, tests

src/interfaces/external/arcadia/ITranche.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface ITranche {
+    function LENDING_POOL() external view returns (address);
+}

src/strategies/ArcadiaStrategy.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
+import {IStrategyBase, Reward} from "src/interfaces/IStrategyBase.sol";
+import {ITranche} from "src/interfaces/external/arcadia/ITranche.sol";
+
+contract ArcadiaStrategy is IStrategyBase {
+    function _decodeSupplement(bytes calldata supplement) internal pure returns (IERC4626 vault) {
+        return abi.decode(supplement, (IERC4626));
+    }
+
+    function protocol(bytes calldata supplement) external virtual returns (address) {
+        IERC4626 vault = _decodeSupplement(supplement);
+        return ITranche(address(vault)).LENDING_POOL();
+    }
+
+    function deposit(uint256 amount, bytes calldata supplement) external virtual {
+        IERC4626 vault = _decodeSupplement(supplement);
+        vault.deposit(amount, address(this));
+    }
+
+    function withdraw(uint256 amount, bytes calldata supplement) external virtual returns (uint256 withdrawn) {
+        IERC4626 vault = _decodeSupplement(supplement);
+        uint256 shares = vault.previewWithdraw(amount);
+        withdrawn = vault.redeem(shares, address(this), address(this));
+    }
+
+    function assetBalance(address yelayLiteVault, bytes calldata supplement) external view virtual returns (uint256) {
+        IERC4626 vault = _decodeSupplement(supplement);
+        return vault.previewRedeem(vault.balanceOf(address(yelayLiteVault)));
+    }
+
+    function withdrawAll(bytes calldata supplement) external virtual returns (uint256 withdrawn) {
+        IERC4626 vault = _decodeSupplement(supplement);
+        withdrawn = vault.redeem(vault.balanceOf(address(this)), address(this), address(this));
+    }
+
+    function onAdd(bytes calldata) external virtual {}
+    function onRemove(bytes calldata) external virtual {}
+    function viewRewards(address, bytes calldata) external view virtual returns (Reward[] memory rewards) {}
+    function claimRewards(bytes calldata) external virtual {}
+}

test/fork/AbstractStrategyTest.sol

@@ -20,7 +20,7 @@ abstract contract AbstractStrategyTest is Test {
     address constant owner = address(0x01);
     address constant user = address(0x02);
     address constant user2 = address(0x03);
-    address constant yieldExtractor = address(0x04);
+    address constant yieldExtractor = address(0x100);
     uint256 constant yieldProjectId = 0;
     uint256 constant projectId = 1;
 

test/fork/Arcadia.base.weth.e2e.t.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import {StrategyData} from "src/interfaces/IManagementFacet.sol";
+
+import {AbstractStrategyTest} from "./AbstractStrategyTest.sol";
+
+import {ArcadiaStrategy} from "src/strategies/ArcadiaStrategy.sol";
+
+contract ArcadiaBaseWethTest is AbstractStrategyTest {
+    function _setupFork() internal override {
+        underlyingAsset = IERC20(0x4200000000000000000000000000000000000006);
+        userBalance = 10e18;
+        toDeposit = 1e18;
+        vm.createSelectFork(vm.envString("BASE_URL"), 30000000);
+    }
+
+    function _setupStrategy() internal override {
+        vm.startPrank(owner);
+        address strategyAdapter = address(new ArcadiaStrategy());
+        StrategyData memory strategy = StrategyData({
+            adapter: strategyAdapter,
+            supplement: abi.encode(0x393893caeB06B5C16728bb1E354b6c36942b1382),
+            name: "ArcadiaV2 Wrapped Ether"
+        });
+        yelayLiteVault.addStrategy(strategy);
+        yelayLiteVault.approveStrategy(0, type(uint256).max);
+        {
+            uint256[] memory queue = new uint256[](1);
+            queue[0] = 0;
+            yelayLiteVault.activateStrategy(0, queue, queue);
+        }
+        vm.stopPrank();
+    }
+}