feat: add new contract to support merkl reward claiming

aa-eyup · aa-eyup · commit 1c758c8daff7 · 2025-12-01T20:53:49.000-08:00
- inherits from ATokenVault
- updates storage struct to store merkl distributor contract
  (consumes the first of 50 gap slots)
- expose functions to set/get distributor (onlyOwner)
- expose function to claim rewards from merkl distributor (onlyOwner)
- add test that forks Ethereum mainnet to claim rewards
diff --git a/.github/workflows/foundry-gas-diff.yml b/.github/workflows/foundry-gas-diff.yml
@@ -35,6 +35,7 @@ jobs:
           # due to non-deterministic fuzzing, but keep it not always deterministic
           POLYGON_RPC_URL: ${{ secrets.POLYGON_RPC_URL }}
           AVALANCHE_RPC_URL: ${{ secrets.AVALANCHE_RPC_URL }}
+          ETHEREUM_RPC_URL: ${{ secrets.ETHEREUM_RPC_URL }}
           FOUNDRY_FUZZ_SEED: 0x${{ github.event.pull_request.base.sha || github.sha }}
 
       - name: Compare gas reports
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
@@ -23,4 +23,5 @@ jobs:
         env: 
           POLYGON_RPC_URL: ${{ secrets.POLYGON_RPC_URL }}
           AVALANCHE_RPC_URL: ${{ secrets.AVALANCHE_RPC_URL }}
+          ETHEREUM_RPC_URL: ${{ secrets.ETHEREUM_RPC_URL }}
         run: forge test -vvv
diff --git a/README.md b/README.md
@@ -20,9 +20,10 @@ Some of the tests rely on an RPC connection for forking network state. Make sure
 ```
 POLYGON_RPC_URL=[Your favourite Polygon RPC URL]
 AVALANCHE_RPC_URL=[Your favourite Avalanche RPC URL]
+ETHEREUM_RPC_URL=[Your favourite Ethereum RPC URL]
 ```
 
-The fork tests all use Polygon, except tests for claiming Aave rewards, which use Avalanche.
+The fork tests all use Polygon, except tests for claiming Aave rewards, which use Avalanche, and Merkl rewards, which use Ethereum.
 
 This test suite also includes a16z's [ERC-4626 Property Tests](https://a16zcrypto.com/generalized-property-tests-for-erc4626-vaults/), which are in the `ATokenVaultProperties.t.sol` file. These tests do not use a forked network state but rather use mock contracts, found in the `test/mocks` folder.
 
diff --git a/foundry.toml b/foundry.toml
@@ -8,6 +8,7 @@ runs = 256
 gas_reports = ["ATokenVault"]
 isolate = true
 ignored_warnings_from = ["lib/", "node_modules/"] # Ignore warnings from dependencies
+evm_version = 'cancun'
 
 [fuzz]
 max_test_rejects = 65536
diff --git a/src/ATokenVaultMerklRewardClaimer.sol b/src/ATokenVaultMerklRewardClaimer.sol
@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: UNLICENSED
+// All Rights Reserved © AaveCo
+
+pragma solidity ^0.8.10;
+
+import {IPoolAddressesProvider} from "@aave-v3-core/interfaces/IPoolAddressesProvider.sol";
+
+import {ATokenVault} from "./ATokenVault.sol";
+import {IATokenVaultMerklRewardClaimer} from "./interfaces/IATokenVaultMerklRewardClaimer.sol";
+
+interface IMerklDistributor {
+    function claim(
+        address[] calldata users,
+        address[] calldata tokens,
+        uint256[] calldata amounts,
+        bytes32[][] calldata proofs
+    ) external;
+}
+
+/**
+ * @title ATokenVaultMerklRewardClaimer
+ * @author Aave Protocol
+ * @notice A contract that allows the owner to claim Merkl rewards for the ATokenVault
+ */
+contract ATokenVaultMerklRewardClaimer is ATokenVault, IATokenVaultMerklRewardClaimer {
+    /**
+     * @dev Constructor.
+     * @param underlying The underlying ERC20 asset which can be supplied to Aave
+     * @param referralCode The Aave referral code to use for deposits from this vault
+     * @param poolAddressesProvider The address of the Aave v3 Pool Addresses Provider
+     */
+    constructor(address underlying, uint16 referralCode, IPoolAddressesProvider poolAddressesProvider)
+        ATokenVault(underlying, referralCode, poolAddressesProvider)
+    {}
+
+    /// @inheritdoc IATokenVaultMerklRewardClaimer
+    function getMerklDistributor() external view override returns (address) {
+        return _s.merklDistributor;
+    }
+
+    /// @inheritdoc IATokenVaultMerklRewardClaimer
+    function setMerklDistributor(address merklDistributor) external override onlyOwner {
+        require(merklDistributor != address(0), "ZERO_ADDRESS_NOT_VALID");
+        address currentMerklDistributor = _s.merklDistributor;
+        _s.merklDistributor = merklDistributor;
+        emit MerklDistributorUpdated(currentMerklDistributor, merklDistributor);
+    }
+
+    /// @inheritdoc IATokenVaultMerklRewardClaimer
+    function claimMerklRewards(address[] calldata tokens, uint256[] calldata amounts, bytes32[][] calldata proofs)
+        public
+        override
+        onlyOwner
+    {
+        require(_s.merklDistributor != address(0), "MERKL_DISTRIBUTOR_NOT_SET");
+
+        address[] memory users = new address[](tokens.length);
+        for (uint256 i = 0; i < tokens.length; i++) {
+            // users represent depositors into Aave which is this contract
+            users[i] = address(this);
+        }
+
+        IMerklDistributor(_s.merklDistributor).claim(users, tokens, amounts, proofs);
+
+        emit MerklRewardsClaimed(tokens, amounts);
+    }
+}
diff --git a/src/ATokenVaultStorage.sol b/src/ATokenVaultStorage.sol
@@ -20,8 +20,10 @@ abstract contract ATokenVaultStorage {
         uint40 __deprecated_gap;
         // as a fraction of 1e18
         uint64 fee;
+        // Merkl distributor contract address called to claim Merkl rewards
+        address merklDistributor;
         // Reserved storage space to allow for layout changes in the future
-        uint256[50] __gap;
+        uint256[49] __gap;
     }
 
     Storage internal _s;
diff --git a/src/interfaces/IATokenVaultMerklRewardClaimer.sol b/src/interfaces/IATokenVaultMerklRewardClaimer.sol
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: UNLICENSED
+// All Rights Reserved © AaveCo
+
+pragma solidity ^0.8.10;
+
+/**
+ * @title IATokenVaultMerklRewardClaimer
+ * @author Aave Protocol
+ *
+ * @notice Defines the basic interface of the ATokenVaultMerklRewardClaimer
+ */
+interface IATokenVaultMerklRewardClaimer {
+    /**
+     * @dev Emitted when Merkl rewards are claimed by the vault contract
+     * @dev The token addresses do not always match the actual tokens received by the vault contract after rewards are claimed
+     * @dev The amounts do not always match the actual amounts received by the vault contract after rewards are claimed
+     * @param tokens Addresses of the ERC-20 reward tokens claimed (the tokens passed as params to the Merkl distributor contract)
+     * @param amounts Amounts of the reward tokens claimed for each token (the amounts passed as params to the Merkl distributor contract)
+     */
+    event MerklRewardsClaimed(address[] tokens, uint256[] amounts);
+
+    /**
+     * @dev Emitted when the Merkl distributor address is updated
+     * @param oldMerklDistributor The old address of the Merkl distributor contract
+     * @param newMerklDistributor The new address of the Merkl distributor contract
+     */
+    event MerklDistributorUpdated(address indexed oldMerklDistributor, address indexed newMerklDistributor);
+
+    /**
+     * @notice Getter for the contract address called to claim Merkl rewards
+     * @return Address of the Merkl distributor contract
+     */
+    function getMerklDistributor() external view returns (address);
+
+    /**
+     * @notice Sets the Merkl distributor address for the vault uses to claim Merkl rewards.
+     * @dev Only callable by the owner
+     * @param merklDistributor Address of the new Merkl distributor contract
+     */
+    function setMerklDistributor(address merklDistributor) external;
+
+    /**
+     * @notice Claims Merkl rewards earned by deposits from this contract through the Merkl distributor contract
+     * @dev Only callable by the owner
+     * @dev Merkl distributor address must be set
+     * @dev Rewards claimed are not re-deposited into the underlying Aave pool. The owner can use `IATokenVault.emergencyRescue(...)` to rescue token rewards
+     * @dev The IMerklDistributor.claim(...) function does not return a list of tokens and amounts the users actually receive
+     * @dev The order of the tokens, amounts, and proofs must align with eachother
+     * @param tokens Addresses of the ERC-20 reward tokens to claim
+     * @param amounts Amounts of the reward tokens to claim for each token
+     * @param proofs Merkl proof passed to the Merkl distributor contract
+     */
+    function claimMerklRewards(address[] calldata tokens, uint256[] calldata amounts, bytes32[][] calldata proofs)
+        external;
+}
diff --git a/test/ATokenVaultBaseTest.t.sol b/test/ATokenVaultBaseTest.t.sol
@@ -10,6 +10,7 @@ import {IPoolAddressesProvider} from "@aave-v3-core/interfaces/IPoolAddressesPro
 import {TransparentUpgradeableProxy} from "@openzeppelin/proxy/transparent/TransparentUpgradeableProxy.sol";
 
 import {ATokenVault, MathUpgradeable} from "../src/ATokenVault.sol";
+import {ATokenVaultMerklRewardClaimer} from "../src/ATokenVaultMerklRewardClaimer.sol";
 
 contract ATokenVaultBaseTest is Test {
     using SafeERC20Upgradeable for IERC20Upgradeable;
@@ -143,4 +144,31 @@ contract ATokenVaultBaseTest is Test {
 
         vault = ATokenVault(address(proxy));
     }
+
+    function _deployATokenVaultMerklRewardClaimer(address underlying, address addressesProvider) internal {
+        _deployATokenVaultMerklRewardClaimer(underlying, addressesProvider, 10e18);
+    }
+
+    function _deployATokenVaultMerklRewardClaimer(address underlying, address addressesProvider, uint256 _initialLockDeposit) internal {
+        initialLockDeposit = _initialLockDeposit;
+        vault = new ATokenVaultMerklRewardClaimer(underlying, referralCode, IPoolAddressesProvider(addressesProvider));
+
+        bytes memory data = abi.encodeWithSelector(
+            ATokenVault.initialize.selector,
+            OWNER,
+            fee,
+            SHARE_NAME,
+            SHARE_SYMBOL,
+            _initialLockDeposit
+        );
+
+        deal(underlying, address(this), _initialLockDeposit);
+        address proxyAddr = computeCreateAddress(address(this), vm.getNonce(address(this)) + 1);
+
+        IERC20Upgradeable(underlying).safeApprove(address(proxyAddr), _initialLockDeposit);
+
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(vault), PROXY_ADMIN, data);
+
+        vault = ATokenVaultMerklRewardClaimer(address(proxy));
+    }
 }
diff --git a/test/ATokenVaultMerklRewardClaimer.t.sol b/test/ATokenVaultMerklRewardClaimer.t.sol
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.10;
+
+import "forge-std/Test.sol";
+import {stdStorage, StdStorage} from "forge-std/Test.sol";
+
+import {IAToken} from "@aave-v3-core/interfaces/IAToken.sol";
+import {IERC20} from "@openzeppelin/interfaces/IERC20.sol";
+
+import {ATokenVaultBaseTest} from "./ATokenVaultBaseTest.t.sol";
+
+import {IATokenVaultMerklRewardClaimer} from "../src/interfaces/IATokenVaultMerklRewardClaimer.sol";
+
+/**
+ * @title ATokenVaultMerklRewardClaimerTest
+ * @notice Test suite for claiming Merkl rewards from the ATokenVault
+ * @dev Forks Ethereum mainnet to etch the ATokenVault onto an address that has claimable rewards as of the forked block
+ * @dev foundry.toml must use evm_version = 'cancun' to run this test
+ */
+contract ATokenVaultMerklRewardClaimerTest is ATokenVaultBaseTest {
+    using stdStorage for StdStorage;
+    uint256 ethereumFork;
+    // The block before rewards claim in tx: https://etherscan.io/tx/0x42ef6b499d1b6e96a4250f2d5a005b60173386e2ac3a3e424aa407db3da802ea
+    uint256 ETHEREUM_FORK_BLOCK = 23921479; // Dec 1st 2025
+
+    address constant MERKL_DISTRIBUTOR = 0x3Ef3D8bA38EBe18DB133cEc108f4D14CE00Dd9Ae;
+    address constant ADDRESS_WITH_CLAIMABLE_REWARDS = 0x424629A0D581B6076322A952FB43b78624dB8A15;
+    address constant ETHEREUM_POOL_ADDRESSES_PROVIDER = 0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e;
+    address constant ETHEREUM_RLUSD = 0x8292Bb45bf1Ee4d140127049757C2E0fF06317eD;
+    address constant A_HOR_RWA_RLUSD = 0xE3190143Eb552456F88464662f0c0C4aC67A77eB;
+    address constant WRAPPED_A_HOR_RWA_RLUSD = 0x503D751B13a71D8e69Db021DF110bfa7aE1dA889;
+    address constant A_ETH_RLUSD = 0xFa82580c16A31D0c1bC632A36F82e83EfEF3Eec0;
+    address constant WRAPPED_A_ETH_RLUSD = 0x72eEED8043Dcce2Fe7CdAC950D928F80f472ab80;
+    IAToken constant aHorRwaRLUSD = IAToken(A_HOR_RWA_RLUSD);
+
+    function setUp() public override {
+        ethereumFork = vm.createFork(vm.envString("ETHEREUM_RPC_URL"));
+        vm.selectFork(ethereumFork);
+        vm.rollFork(ETHEREUM_FORK_BLOCK);
+
+        vaultAssetAddress = address(aHorRwaRLUSD);
+
+        // Sets the `vault`, but we will not use the vault deployment
+        _deployATokenVaultMerklRewardClaimer(ETHEREUM_RLUSD, ETHEREUM_POOL_ADDRESSES_PROVIDER);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                        ETHEREUM FORK TESTS
+    //////////////////////////////////////////////////////////////*/
+
+    function testEthereumForkWorks() public {
+        assertEq(vm.activeFork(), ethereumFork);
+    }
+
+    function testEthereumForkAtExpectedBlock() public {
+        assertEq(block.number, ETHEREUM_FORK_BLOCK);
+    }
+
+    function testEthereumForkBalanceOfAddressWithClaimableRewards() public {
+        assertEq(ADDRESS_WITH_CLAIMABLE_REWARDS.balance, 154288817306978598);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                            MERKL REWARDS CLAIM TESTS
+    //////////////////////////////////////////////////////////////*/
+
+    function testOwnerCanClaimMerklRewards() public {
+        _setMerklDistributor();
+        // Set the code for an address that has claimable rewards as of the fork block
+        // We will use this in place of the vault deployment
+        _etchVault(ADDRESS_WITH_CLAIMABLE_REWARDS);
+
+        uint256 beforeBalanceOfAHorRwaRLUSD = IERC20(A_HOR_RWA_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS);
+        uint256 beforeBalanceOfWrappedAHorRwaRLUSD = IERC20(WRAPPED_A_HOR_RWA_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS);
+        uint256 beforeBalanceOfAETHRLUSD = IERC20(A_ETH_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS);
+        uint256 beforeBalanceOfWrappedAETHRLUSD = IERC20(WRAPPED_A_ETH_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS);
+
+        address[] memory tokens = new address[](2);
+        tokens[0] = address(WRAPPED_A_HOR_RWA_RLUSD);
+        tokens[1] = address(WRAPPED_A_ETH_RLUSD);
+
+        uint256[] memory amounts = new uint256[](2);
+        amounts[0] = 108475300663546315531064;
+        amounts[1] = 39262212365620131551622;
+
+        bytes32[][] memory proofs = new bytes32[][](2);
+        proofs[0] = new bytes32[](18);
+        proofs[1] = new bytes32[](18);
+        proofs[0][0] = 0xcd60c655efb4b907fcd241863868d14b469487021d66d1edfdbda9472f9a64fa;
+        proofs[0][1] = 0xb8fb6ed03a4fe66e40d0393936caaf89288f0f0d45a54b2d021e6436e08d5cab;
+        proofs[0][2] = 0x51da9788480e72478a3983b1fcc6417d6e2fb23f17d82402980bf7a662951ebc;
+        proofs[0][3] = 0xbd1e1f1f6b3bff2c96cdaac05eef648a12d7b26aff0cb6bf2e01df739326d221;
+        proofs[0][4] = 0xc3666e909b4378eb3190a55407b3992791f45947ccfb78a450618fd0d2d186ef;
+        proofs[0][5] = 0xeae511fe93c29449d7dc421a00989e9b90193b1ea95a6727edfd0ac23c85b1a8;
+        proofs[0][6] = 0x7cb3e28ed93250acb734cf34cf07ae533800fc0161e936ee29c20f36c66e7d4a;
+        proofs[0][7] = 0x467aa2d6889230db0b841374136b586ded4697016c9cb5b9259677357c9de435;
+        proofs[0][8] = 0xb1b5b41688ba77f9426265f60c5f9a922062156ab08bdde674dceebacc1c92b3;
+        proofs[0][9] = 0x51dda19784b96153bcda1086489d5d6c5f17566202c92a0d911cbd2aa7a3ff7a;
+        proofs[0][10] = 0x4606c269974519cf0d4fe1907baab3ca27c5eef64560408e4137eaf62d273c08;
+        proofs[0][11] = 0xcc7bdca69b12e1f75d7b26045ba5e0c108de8d85bcee444ac05a02b940a20ea7;
+        proofs[0][12] = 0x67cfe6ef02168544a983543b06f1823d97e78d17e67bd6833f7fc6b8e3a2cc77;
+        proofs[0][13] = 0x3f2a8d6cb9b7784fe51ac5719c41e1a973856a7f89f3847b2ec5e259b6977b90;
+        proofs[0][14] = 0xed9131f643d7100fcdfcebbf4abb97e7bcf31ee08f7ab8fb3230231f6f3f7533;
+        proofs[0][15] = 0x4dd1263f903416095b1556a5b9473082ee23a3eda267d6f98dbdcb200ba1d648;
+        proofs[0][16] = 0x5df7d74a8a29e2552ddecdd29e57b8e1daedbc786f9f9ca6d308506f14b13995;
+        proofs[0][17] = 0xa8568c4dc81b1ee1667791a9567914d57f698ab8f6444fd1bd9fa88b158598c6;
+
+        proofs[1][0] = 0x2553b0621d281b8ff48e95ae951cca33ea3468a8938b2e4df5432143652d4e4a;
+        proofs[1][1] = 0xd98dc700cb20b65209167e4794e111a3e6f5b321e87addd9f31fad5b9227aa77;
+        proofs[1][2] = 0xef27cdadbbce6f35a63b010602c810e1f610924d97671658f721c39b14314b23;
+        proofs[1][3] = 0x6e0a90db4e79aaa85f7d02e5b51e731ae6d3c5a55e7f7823e69617dc658cf403;
+        proofs[1][4] = 0xeaac81bbf63022e8203c818f098166e2a07dc5606ec3c78a8025910420c4bf5f;
+        proofs[1][5] = 0x757d3fd4bfe411a574405bf91b1cbd2f11987fb4237b8d5fa64176cf0cb20fe3;
+        proofs[1][6] = 0xbd699a6f29ee97f0234bf9322953a1d284e2c911a0b86aa256f5265fd03df512;
+        proofs[1][7] = 0xe37c2c040c7977b9d4b05857925086e6ba7e7227b836f241c3f5dddd852852e6;
+        proofs[1][8] = 0xd981d4e3f9077020c96ba37e849ec7d27de10a84269255a563f4f5387e15a42e;
+        proofs[1][9] = 0x7755254f566658f3d7cae2cca32b7428ba4faa8471bbec83987cf0748b374f42;
+        proofs[1][10] = 0x58cd9e5a37c2770d44fdc248cf3e2d7b335156a1613721c3ef390e03637748ac;
+        proofs[1][11] = 0x53fea05c23a6e006a865c38e05f42ebb46f7ab9e09337e0ee2a064d4b8e2b90a;
+        proofs[1][12] = 0x4d98b5449e9af673e13565b42fe5129c5d774be4a5d87d46ef7773913161679a;
+        proofs[1][13] = 0x6b120817b20d5b394061ee70d0c5b222282054a4ecff068943c8f29455a5a0ae;
+        proofs[1][14] = 0x880e3fa286a8e8f7cda32454aba6f4e03a5a4e6e12765c2ed81d02f1f387cd5d;
+        proofs[1][15] = 0x9bfa48207586367dd5d549803d11cc165a50760ef6da82c2200289fae3cd9188;
+        proofs[1][16] = 0xd973d9d68f5e750326e9811fccb748c601432c59b2d2ac08d334218027b0f754;
+        proofs[1][17] = 0x6fd7ba9a8ab999e39fa33e96b722ab10d2e07d65b53319639a7145f9f0cbfece;
+
+        vm.prank(OWNER);
+        IATokenVaultMerklRewardClaimer(ADDRESS_WITH_CLAIMABLE_REWARDS).claimMerklRewards(tokens, amounts, proofs);
+
+        uint256 afterBalanceOfAHorRwaRLUSD = IERC20(A_HOR_RWA_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS);
+        uint256 afterBalanceOfWrappedAHorRwaRLUSD = IERC20(WRAPPED_A_HOR_RWA_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS);
+        uint256 afterBalanceOfAETHRLUSD = IERC20(A_ETH_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS);
+        uint256 afterBalanceOfWrappedAETHRLUSD = IERC20(WRAPPED_A_ETH_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS);
+
+        // Wrapped token balances should not change because the claimer receives the unwrapped tokens
+        assertEq(afterBalanceOfWrappedAHorRwaRLUSD, beforeBalanceOfWrappedAHorRwaRLUSD);
+        assertGt(afterBalanceOfAHorRwaRLUSD, beforeBalanceOfAHorRwaRLUSD);
+        assertEq(afterBalanceOfWrappedAETHRLUSD, beforeBalanceOfWrappedAETHRLUSD);
+        assertGt(afterBalanceOfAETHRLUSD, beforeBalanceOfAETHRLUSD);
+    }
+
+    // TODO: add moar tests for the Merkl distributor setter and getter
+    // TODO: add error path tests
+
+    function _setMerklDistributor() internal {
+        vm.prank(OWNER);
+        IATokenVaultMerklRewardClaimer(address(vault)).setMerklDistributor(MERKL_DISTRIBUTOR);
+    }
+
+    function _etchVault(address target) internal {
+        // 1. Fix the Proxy: Copy the implementation address from 'vault' to the etched address
+        // EIP-1967 Implementation slot: bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)
+        bytes32 implSlot = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
+        bytes32 implementation = vm.load(address(vault), implSlot);
+        
+        vm.etch(target, address(vault).code);
+        vm.store(target, implSlot, implementation);
+
+        // 2. Fix State: Copy Owner and MerklDistributor
+        // Based on forge inspect storage layout:
+        // _owner is at slot 151
+        uint256 ownerSlot = 151;
+        vm.store(target, bytes32(ownerSlot), vm.load(address(vault), bytes32(ownerSlot)));
+        // _s starts at slot 254
+        // _s.merklDistributor is at slot 256 (254: balances/fees, 255: gap/fee, 256: merkl)
+        uint256 merklSlot = 256;
+        vm.store(target, bytes32(merklSlot), vm.load(address(vault), bytes32(merklSlot)));
+    }
+}
