feat: generic payload exec; gho caps adjustment

Author: yan-man

diffs/AaveV3Horizon_GHOcaps_20260312_before_AaveV3Horizon_GHOcaps_20260312_after.md

@@ -0,0 +1,56 @@
+## Reserve changes
+
+### Reserves altered
+
+#### GHO ([0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f](https://etherscan.io/address/0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f))
+
+| description | value before | value after |
+| --- | --- | --- |
+| supplyCap | 55,000,000 GHO | 45,000,000 GHO |
+| borrowCap | 43,000,000 GHO | 35,000,000 GHO |
+
+
+## Raw diff
+
+```json
+{
+  "reserves": {
+    "0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f": {
+      "borrowCap": {
+        "from": 43000000,
+        "to": 35000000
+      },
+      "supplyCap": {
+        "from": 55000000,
+        "to": 45000000
+      }
+    }
+  },
+  "raw": {
+    "0xae05cd22df81871bc7cc2a04becfb516bfe332c8": {
+      "label": null,
+      "contract": "lib/aave-umbrella/lib/aave-v3-origin/lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol:TransparentUpgradeableProxy",
+      "balanceDiff": null,
+      "nonceDiff": null,
+      "stateDiff": {
+        "0xfd2dab4be6d07bba0109696859cf3ea9f610b92569d2a062e705af4b9c58ff16": {
+          "previousValue": "0x10000000000000000000000000003473bc00029020c003e80512000000000000",
+          "newValue": "0x10000000000000000000000000002aea540002160ec003e80512000000000000"
+        }
+      }
+    },
+    "0xe6ec1f0ae6cd023bd0a9b4d0253bdc755103253c": {
+      "label": null,
+      "contract": null,
+      "balanceDiff": null,
+      "nonceDiff": null,
+      "stateDiff": {
+        "0x0000000000000000000000000000000000000000000000000000000000000005": {
+          "previousValue": "0x000000000000000000000000000000000000000000000000000000000000002a",
+          "newValue": "0x000000000000000000000000000000000000000000000000000000000000002b"
+        }
+      }
+    }
+  }
+}
+```

src/AaveV3Horizon_ACREDListing_20260217/AaveV3Horizon_ACREDListing_20260217.t.sol

@@ -19,10 +19,6 @@ abstract contract AaveV3Horizon_ACREDListing_20260217_TestBase is ProtocolV3Hori
     _setExpectedConfig();
   }
 
-  function _pool() internal pure returns (IPool) {
-    return IPool(AaveV3EthereumHorizonCustom.POOL);
-  }
-
   function _setExpectedConfig() internal virtual override {
     expectedAssetConfig = ExpectedAssetConfig({
       underlying: AaveV3EthereumHorizonCustom.ACRED_UNDERLYING,
@@ -75,8 +71,12 @@ contract AaveV3Horizon_ACREDListing_20260217_Test is AaveV3Horizon_ACREDListing_
   /**
    * @dev executes the generic test suite including e2e and config snapshots
    */
+  function _executeACREDListing() internal {
+    _executeHorizonPayload(address(proposal));
+  }
+
   function test_defaultProposalExecution() public virtual {
-    defaultTest_v3_3('AaveV3Horizon_ACREDListing_20260217', _pool(), address(proposal));
+    defaultTest_v3_3('AaveV3Horizon_ACREDListing_20260217', _pool(), _executeACREDListing);
   }
 
   /**

src/AaveV3Horizon_GHOcaps_20260312/AaveV3Horizon_GHOcaps_20260312.t.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IPoolDataProvider} from 'aave-v3-origin/contracts/interfaces/IPoolDataProvider.sol';
+import {ProtocolV3HorizonTestBase, ReserveConfig} from 'tests/utils/ProtocolV3HorizonTestBase.sol';
+import {AaveV3EthereumHorizon, AaveV3EthereumHorizonAssets} from 'aave-address-book-latest/AaveV3EthereumHorizon.sol';
+
+/**
+ * @dev Test for GHO caps update via multisig transaction.
+ * command: FOUNDRY_PROFILE=test forge test --match-contract AaveV3Horizon_GHOcaps_20260312_Test -vv
+ */
+contract AaveV3Horizon_GHOcaps_20260312_Test is ProtocolV3HorizonTestBase {
+  address internal constant OPS_TARGET = 0x9641d764fc13c8B624c04430C7356C1C7C8102e2;
+  bytes internal constant OPS_DATA =
+    hex'8d80ff0a000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000001320083cb1b4af26eef6463ac20afbac9c0e2e017202f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044571f03e500000000000000000000000040d16fc0246ad3160ccc09b8d0d3a2cd28ae6c2f0000000000000000000000000000000000000000000000000000000002aea5400083cb1b4af26eef6463ac20afbac9c0e2e017202f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044d14a098300000000000000000000000040d16fc0246ad3160ccc09b8d0d3a2cd28ae6c2f0000000000000000000000000000000000000000000000000000000002160ec00000000000000000000000000000';
+  uint256 internal constant OPS_NONCE = 42;
+
+  function setUp() public {
+    vm.createSelectFork(vm.rpcUrl('mainnet'), 24644395);
+  }
+
+  function _executeGHOcapsUpdate() internal {
+    _executeOpsMultisigTx({to: OPS_TARGET, data: OPS_DATA, operation: 1, nonce: OPS_NONCE});
+  }
+
+  /**
+   * @dev Full test suite: snapshots, state diff, validations, e2e.
+   */
+  function test_defaultProposalExecution() public {
+    defaultTest_v3_3('AaveV3Horizon_GHOcaps_20260312', _pool(), _executeGHOcapsUpdate);
+  }
+
+  /**
+   * @dev Custom before/after assertions for the GHO caps change.
+   */
+  function test_ghoCapsChange() public {
+    (uint256 borrowCapBefore, uint256 supplyCapBefore) = (
+      IPoolDataProvider(AaveV3EthereumHorizon.AAVE_PROTOCOL_DATA_PROVIDER).getReserveCaps(
+        AaveV3EthereumHorizonAssets.GHO_UNDERLYING
+      )
+    );
+
+    assertEq(borrowCapBefore, 43_000_000, 'Borrow cap before');
+    assertEq(supplyCapBefore, 55_000_000, 'Supply cap before');
+
+    _executeGHOcapsUpdate();
+
+    (uint256 borrowCapAfter, uint256 supplyCapAfter) = (
+      IPoolDataProvider(AaveV3EthereumHorizon.AAVE_PROTOCOL_DATA_PROVIDER).getReserveCaps(
+        AaveV3EthereumHorizonAssets.GHO_UNDERLYING
+      )
+    );
+
+    assertEq(borrowCapAfter, 35_000_000, 'Borrow cap after');
+    assertEq(supplyCapAfter, 45_000_000, 'Supply cap after');
+  }
+}

src/dependencies/ISafeAccount.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface ISafeAccount {
+  function execTransaction(
+    address to,
+    uint256 value,
+    bytes calldata data,
+    uint8 operation,
+    uint256 safeTxGas,
+    uint256 baseGas,
+    uint256 gasPrice,
+    address gasToken,
+    address payable refundReceiver,
+    bytes memory signatures
+  ) external payable returns (bool success);
+  function getOwners() external view returns (address[] memory);
+}

tests/utils/ProtocolV3HorizonTestBase.sol

@@ -12,6 +12,7 @@ import {AaveV3EthereumHorizonCustom} from 'src/utils/AaveV3EthereumHorizonCustom
 import {HorizonRwaWhitelistHelper} from 'tests/utils/HorizonRwaWhitelistHelper.sol';
 import {HorizonConfigAssertionHelper} from 'tests/utils/HorizonConfigAssertionHelper.sol';
 import {Errors} from 'src/dependencies/Errors.sol';
+import {ISafeAccount} from 'src/dependencies/ISafeAccount.sol';
 
 /**
  * @dev Adapted from ProtocolV3TestBase for the Horizon market (currently at Aave v3.3).
@@ -45,19 +46,22 @@ abstract contract ProtocolV3HorizonTestBase is
    * - diffing the config
    * - checking if the changes are plausible (no conflicting config changes etc)
    * - running an e2e testsuite over all assets
+   * @param reportName the name of the report
+   * @param pool the pool that should be tested
+   * @param executeTx the function that will execute the transaction that is being tested
    */
   function defaultTest_v3_3(
     string memory reportName,
     IPool pool,
-    address payload
-  ) public returns (ReserveConfig[] memory, ReserveConfig[] memory) {
+    function() internal executeTx
+  ) internal returns (ReserveConfig[] memory, ReserveConfig[] memory) {
     string memory beforeString = string(abi.encodePacked(reportName, '_before'));
     ReserveConfig[] memory configBefore = createConfigurationSnapshot(beforeString, pool);
 
     uint256 startGas = gasleft();
 
     vm.startStateDiffRecording();
-    _executeHorizonPayload(payload);
+    executeTx(); // execute the transaction that is being tested
     string memory rawDiff = vm.getStateDiffJson();
 
     uint256 gasUsed = startGas - gasleft();
@@ -278,6 +282,10 @@ abstract contract ProtocolV3HorizonTestBase is
     }
   }
 
+  function _pool() internal pure returns (IPool) {
+    return IPool(AaveV3EthereumHorizonCustom.POOL);
+  }
+
   /**
    * @dev Execute a Horizon payload through the real executor path.
    * HORIZON_EMERGENCY calls HORIZON_EXECUTOR.executeTransaction() which delegatecalls
@@ -490,4 +498,96 @@ abstract contract ProtocolV3HorizonTestBase is
   }
 
   function _setExpectedConfig() internal virtual {}
+
+  // ---------------------------------------------------------------------------
+  // Gnosis Safe multisig transaction helpers
+  // ---------------------------------------------------------------------------
+
+  /**
+   * @dev Execute a transaction as the HORIZON_EMERGENCY multisig.
+   * @param to      The `to` address of the Safe transaction.
+   * @param data    The calldata of the Safe transaction.
+   * @param operation 0 = call, 1 = delegatecall.
+   */
+  function _executeEmergencyMultisigTx(
+    address to,
+    bytes memory data,
+    uint8 operation,
+    uint256 nonce
+  ) internal {
+    _executeSafeTx({
+      safe: AaveV3EthereumHorizonCustom.HORIZON_EMERGENCY,
+      to: to,
+      data: data,
+      operation: operation,
+      nonce: nonce
+    });
+  }
+
+  /**
+   * @dev Execute a transaction as the HORIZON_OPS multisig.
+   * @param to        The `to` address of the Safe transaction.
+   * @param data      The calldata of the Safe transaction.
+   * @param operation 0 = call, 1 = delegatecall.
+   * @param nonce     The Safe nonce to set before execution.
+   */
+  function _executeOpsMultisigTx(
+    address to,
+    bytes memory data,
+    uint8 operation,
+    uint256 nonce
+  ) internal {
+    _executeSafeTx({
+      safe: AaveV3EthereumHorizonCustom.HORIZON_OPS,
+      to: to,
+      data: data,
+      operation: operation,
+      nonce: nonce
+    });
+  }
+
+  /**
+   * @dev Core Safe execution: sets threshold to 1 and nonce, picks the first owner,
+   *      and calls execTransaction with a minimal pre-approved signature.
+   */
+  function _executeSafeTx(
+    address safe,
+    address to,
+    bytes memory data,
+    uint8 operation,
+    uint256 nonce
+  ) internal {
+    // reset signer threshold to 1 (slot 4) and set nonce (slot 5)
+    vm.store(safe, bytes32(uint256(4)), bytes32(uint256(1)));
+    vm.store(safe, bytes32(uint256(5)), bytes32(nonce));
+    address signer = ISafeAccount(safe).getOwners()[0];
+
+    vm.prank(signer);
+    (bool ok, bytes memory ret) = safe.call(
+      abi.encodeCall(
+        ISafeAccount.execTransaction,
+        (
+          to, // to
+          0, // value
+          data,
+          operation,
+          0, // safeTxGas
+          0, // baseGas
+          0, // gasPrice
+          address(0), // gasToken
+          payable(address(0)), // refundReceiver
+          abi.encodePacked(bytes32(uint256(uint160(signer))), bytes32(0), uint8(1)) // r, s, v
+        )
+      )
+    );
+
+    if (!ok) {
+      if (ret.length > 0) {
+        assembly {
+          revert(add(ret, 32), mload(ret))
+        }
+      }
+      revert('_executeSafeTx: unknown error');
+    }
+  }
 }