feat: deployment engine

.gitignore

@@ -22,4 +22,6 @@ lcov*
 report/
 
 .DS_Store
-.venv/
+.venv/
+
+output/

Makefile

@@ -29,3 +29,12 @@ coverage :
 	make coverage-clean
 	make coverage-report
 	make coverage-badge
+
+# Deploy
+
+# Full deployment, including hubs, spokes, and gateways
+deploy-full :; 
+	FOUNDRY_PROFILE=${CHAIN} forge script scripts/deploy/AaveV4DeployBatch.s.sol:AaveV4DeployBatchScript \
+	--rpc-url ${CHAIN} --sender ${SENDER} --account ${ACCOUNT} --slow \
+	--broadcast
+

foundry.toml

@@ -3,14 +3,20 @@ src = 'src'
 test = 'tests'
 out = 'out'
 libs = ['lib']
-fs_permissions = [{ access = "read", path = "tests/mocks/JsonBindings.sol" }]
+fs_permissions = [
+  { access = "read", path = "tests/mocks/JsonBindings.sol" },
+  { access = "read", path = "./config" },
+  { access = "read-write", path = "./output" },
+  { access = "read-write", path = "./scripts/deploy/inputs" }
+]
 solc_version = "0.8.28"
 evm_version = "cancun"
 optimizer = true
 optimizer_runs = 200
 bytecode_hash = "none"
 gas_snapshot_check = false
 gas_limit = 1099511627776
+ffi = true
 
 [bind_json]
 out = "tests/mocks/JsonBindings.sol"
@@ -49,6 +55,7 @@ zkevm = "${RPC_ZKEVM}"
 gnosis = "${RPC_GNOSIS}"
 bnb = "${RPC_BNB}"
 celo = "${RPC_CELO}"
+anvil = "http://127.0.0.1:8545"
 
 [etherscan]
 mainnet = { key = "${ETHERSCAN_API_KEY_MAINNET}", chainId = 1 }

scripts/deploy/AaveV4DeployBatch.s.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (c) 2025 Aave Labs
+pragma solidity ^0.8.0;
+
+import 'scripts/deploy/AaveV4DeployBatchBase.s.sol';
+
+contract AaveV4DeployBatchScript is AaveV4DeployBatchBaseScript {}

scripts/deploy/AaveV4DeployBatchBase.s.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (c) 2025 Aave Labs
+pragma solidity ^0.8.0;
+
+import {Script} from 'forge-std/Script.sol';
+
+import {OrchestrationReports} from 'src/deployments/libraries/OrchestrationReports.sol';
+import {InputUtils} from 'src/deployments/utils/InputUtils.sol';
+import {DeployUtils} from 'src/deployments/utils/DeployUtils.sol';
+import {MetadataLogger} from 'src/deployments/utils/MetadataLogger.sol';
+import {
+  AaveV4DeployOrchestration
+} from 'src/deployments/orchestration/AaveV4DeployOrchestration.sol';
+
+abstract contract AaveV4DeployBatchBaseScript is Script, DeployUtils, InputUtils {
+  string internal constant INPUT_PATH = 'scripts/deploy/inputs/AaveV4DeployInput.json';
+  string internal constant OUTPUT_DIR = 'output/reports/deployments/';
+  string internal constant OUTPUT_FILE = 'AaveV4DeployBatch.json';
+
+  function run() external {
+    vm.createDir(OUTPUT_DIR, true);
+    MetadataLogger logger = new MetadataLogger(OUTPUT_DIR);
+    FullDeployInputs memory inputs = loadFullDeployInputs(INPUT_PATH);
+
+    _loadWarnings(logger, inputs);
+
+    logger.log('...Starting Aave V4 Batch Deployment...');
+    address deployer = msg.sender;
+    vm.startBroadcast(deployer);
+    OrchestrationReports.FullDeploymentReport memory report = AaveV4DeployOrchestration
+      .deployAaveV4({
+        logger: logger,
+        deployer: deployer,
+        admin: inputs.admin,
+        nativeWrapper: inputs.nativeWrapperAddress,
+        hubLabels: inputs.hubLabels,
+        spokeLabels: inputs.spokeLabels,
+        grantRoles: inputs.grantRoles
+      });
+    vm.stopBroadcast();
+    logger.writeJsonReportMarket(report);
+    logger.log('...Batch Deployment Completed...');
+    logger.log('...Saving Logs...');
+    logger.save({fileName: OUTPUT_FILE, withTimestamp: true});
+  }
+
+  function _loadWarnings(
+    MetadataLogger logger,
+    FullDeployInputs memory inputs
+  ) internal pure virtual {
+    if (inputs.grantRoles) {
+      logger.log('WARNING: Roles are being set');
+      if (inputs.admin == address(0)) {
+        logger.log('WARNING: Admin is zero address; Roles can not be set');
+      }
+    }
+    if (inputs.hubLabels.length == 0) {
+      logger.log('WARNING: Hub will not be deployed');
+    }
+    if (inputs.spokeLabels.length == 0) {
+      logger.log('WARNING: Spoke will not be deployed');
+    }
+    if (inputs.nativeWrapperAddress == address(0)) {
+      logger.log('WARNING: Native wrapper zero address; NativeTokenGateway will not be deployed');
+    }
+    logger.log('');
+  }
+}

scripts/deploy/inputs/AaveV4DeployInput.json

@@ -0,0 +1,7 @@
+{
+  "admin": "0x0000000000000000000000000000000000000001",
+  "nativeWrapperAddress": "0x0000000000000000000000000000000000000002",
+  "grantRoles": true,
+  "hubLabels": ["Hub 1", "Hub 2", "Hub 3"],
+  "spokeLabels": ["Spoke 1", "Spoke 2", "Spoke 3"]
+}

snapshots/Spoke.Operations.ZeroRiskPremium.json

@@ -5,7 +5,7 @@
   "liquidationCall (receiveShares): partial": "299821",
   "liquidationCall: full": "310468",
   "liquidationCall: partial": "310186",
-  "permitReserve + repay (multicall)": "166029",
+  "permitReserve + repay (multicall)": "166017",
   "permitReserve + supply (multicall)": "146862",
   "permitReserve + supply + enable collateral (multicall)": "160573",
   "repay: full": "126094",

snapshots/Spoke.Operations.json

@@ -5,7 +5,7 @@
   "liquidationCall (receiveShares): partial": "333384",
   "liquidationCall: full": "344031",
   "liquidationCall: partial": "343749",
-  "permitReserve + repay (multicall)": "163273",
+  "permitReserve + repay (multicall)": "163264",
   "permitReserve + supply (multicall)": "146862",
   "permitReserve + supply + enable collateral (multicall)": "160573",
   "repay: full": "120256",

src/deployments/batches/AaveV4AccessBatch.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (c) 2025 Aave Labs
+pragma solidity ^0.8.0;
+
+import {BatchReports} from 'src/deployments/libraries/BatchReports.sol';
+import {AaveV4AccessManagerEnumerableDeployProcedure} from 'src/deployments/procedures/deploy/AaveV4AccessManagerEnumerableDeployProcedure.sol';
+
+contract AaveV4AccessBatch is AaveV4AccessManagerEnumerableDeployProcedure {
+  BatchReports.AccessBatchReport internal _report;
+
+  constructor(address admin_) {
+    address accessManagerAddress = _deployAccessManagerEnumerable(admin_);
+    _report = BatchReports.AccessBatchReport({accessManagerAddress: accessManagerAddress});
+  }
+
+  function getReport() external view returns (BatchReports.AccessBatchReport memory) {
+    return _report;
+  }
+}

src/deployments/batches/AaveV4ConfiguratorBatch.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (c) 2025 Aave Labs
+pragma solidity ^0.8.0;
+
+import {BatchReports} from 'src/deployments/libraries/BatchReports.sol';
+import {AaveV4HubConfiguratorDeployProcedure} from 'src/deployments/procedures/deploy/AaveV4HubConfiguratorDeployProcedure.sol';
+import {AaveV4SpokeConfiguratorDeployProcedure} from 'src/deployments/procedures/deploy/AaveV4SpokeConfiguratorDeployProcedure.sol';
+
+contract AaveV4ConfiguratorBatch is
+  AaveV4HubConfiguratorDeployProcedure,
+  AaveV4SpokeConfiguratorDeployProcedure
+{
+  BatchReports.ConfiguratorBatchReport internal _report;
+
+  constructor(address admin_) {
+    address hubConfiguratorAddress = _deployHubConfigurator(admin_);
+    address spokeConfiguratorAddress = _deploySpokeConfigurator(admin_);
+
+    _report = BatchReports.ConfiguratorBatchReport({
+      hubConfiguratorAddress: hubConfiguratorAddress,
+      spokeConfiguratorAddress: spokeConfiguratorAddress
+    });
+  }
+
+  function getReport() external view returns (BatchReports.ConfiguratorBatchReport memory) {
+    return _report;
+  }
+}

src/deployments/batches/AaveV4GatewayBatch.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (c) 2025 Aave Labs
+pragma solidity ^0.8.0;
+
+import {BatchReports} from 'src/deployments/libraries/BatchReports.sol';
+import {
+  AaveV4NativeTokenGatewayDeployProcedure
+} from 'src/deployments/procedures/deploy/AaveV4NativeTokenGatewayDeployProcedure.sol';
+import {
+  AaveV4SignatureGatewayDeployProcedure
+} from 'src/deployments/procedures/deploy/AaveV4SignatureGatewayDeployProcedure.sol';
+
+contract AaveV4GatewayBatch is
+  AaveV4NativeTokenGatewayDeployProcedure,
+  AaveV4SignatureGatewayDeployProcedure
+{
+  BatchReports.GatewaysBatchReport internal _report;
+
+  constructor(address admin_, address nativeWrapper_) {
+    address nativeGatewayAddress;
+    if (nativeWrapper_ != address(0)) {
+      nativeGatewayAddress = _deployNativeTokenGateway(nativeWrapper_, admin_);
+    }
+    address signatureGatewayAddress = _deploySignatureGateway(admin_);
+
+    _report = BatchReports.GatewaysBatchReport({
+      nativeGatewayAddress: nativeGatewayAddress,
+      signatureGatewayAddress: signatureGatewayAddress
+    });
+  }
+
+  function getReport() external view returns (BatchReports.GatewaysBatchReport memory) {
+    return _report;
+  }
+}

src/deployments/batches/AaveV4HubBatch.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (c) 2025 Aave Labs
+pragma solidity ^0.8.0;
+
+import {BatchReports} from 'src/deployments/libraries/BatchReports.sol';
+import {AaveV4HubDeployProcedure} from 'src/deployments/procedures/deploy/AaveV4HubDeployProcedure.sol';
+import {AaveV4InterestRateStrategyDeployProcedure} from 'src/deployments/procedures/deploy/AaveV4InterestRateStrategyDeployProcedure.sol';
+import {AaveV4TreasurySpokeDeployProcedure} from 'src/deployments/procedures/deploy/AaveV4TreasurySpokeDeployProcedure.sol';
+
+contract AaveV4HubBatch is
+  AaveV4HubDeployProcedure,
+  AaveV4InterestRateStrategyDeployProcedure,
+  AaveV4TreasurySpokeDeployProcedure
+{
+  BatchReports.HubBatchReport internal _report;
+
+  constructor(address admin_, address accessManagerAddress_) {
+    address hubAddress = _deployHub(accessManagerAddress_);
+    address irStrategyAddress = _deployInterestRateStrategy(hubAddress);
+    address treasurySpokeAddress = _deployTreasurySpoke(admin_, hubAddress);
+
+    _report = BatchReports.HubBatchReport({
+      hubAddress: hubAddress,
+      irStrategyAddress: irStrategyAddress,
+      treasurySpokeAddress: treasurySpokeAddress
+    });
+  }
+
+  function getReport() external view returns (BatchReports.HubBatchReport memory) {
+    return _report;
+  }
+}

src/deployments/batches/AaveV4SpokeInstanceBatch.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (c) 2025 Aave Labs
+pragma solidity ^0.8.0;
+
+import {BatchReports} from 'src/deployments/libraries/BatchReports.sol';
+import {
+  AaveV4SpokeInstanceDeployProcedure
+} from 'src/deployments/procedures/deploy/AaveV4SpokeInstanceDeployProcedure.sol';
+import {
+  AaveV4TransparentUpgradeableProxyDeployProcedure
+} from 'src/deployments/procedures/deploy/AaveV4TransparentUpgradeableProxyDeployProcedure.sol';
+import {
+  AaveV4AaveOracleDeployProcedure
+} from 'src/deployments/procedures/deploy/AaveV4AaveOracleDeployProcedure.sol';
+import {Utils} from 'src/deployments/utils/libraries/Utils.sol';
+
+contract AaveV4SpokeInstanceBatch is
+  AaveV4SpokeInstanceDeployProcedure,
+  AaveV4TransparentUpgradeableProxyDeployProcedure,
+  AaveV4AaveOracleDeployProcedure
+{
+  BatchReports.SpokeInstanceBatchReport internal _report;
+
+  constructor(
+    address admin_,
+    address accessManagerAddress_,
+    uint8 oracleDecimals_,
+    string memory oracleDescription_
+  ) {
+    // additional 3 nonces for AaveOracle, SpokeInstance, and TransparentUpgradeableProxy
+    address predictedSpokeInstanceAddress = Utils.computeCreateAddress(address(this), 3);
+
+    address aaveOracleAddress = _deployAaveOracle(
+      predictedSpokeInstanceAddress,
+      oracleDecimals_,
+      oracleDescription_
+    );
+    address spokeImplementationAddress = _deploySpokeInstance(aaveOracleAddress);
+    address spokeProxyAddress = _proxify(
+      spokeImplementationAddress,
+      admin_,
+      abi.encodeWithSignature('initialize(address)', accessManagerAddress_)
+    );
+
+    require(spokeProxyAddress == predictedSpokeInstanceAddress, 'SpokeInstance address mismatch');
+
+    _report = BatchReports.SpokeInstanceBatchReport({
+      aaveOracleAddress: aaveOracleAddress,
+      spokeImplementationAddress: spokeImplementationAddress,
+      spokeProxyAddress: spokeProxyAddress
+    });
+  }
+
+  function getReport() external view returns (BatchReports.SpokeInstanceBatchReport memory) {
+    return _report;
+  }
+}

src/deployments/libraries/BatchReports.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (c) 2025 Aave Labs
+pragma solidity ^0.8.0;
+
+library BatchReports {
+  struct AccessBatchReport {
+    address accessManagerAddress;
+  }
+
+  struct ConfiguratorBatchReport {
+    address hubConfiguratorAddress;
+    address spokeConfiguratorAddress;
+  }
+
+  struct SpokeInstanceBatchReport {
+    address spokeImplementationAddress;
+    address spokeProxyAddress;
+    address aaveOracleAddress;
+  }
+
+  struct HubBatchReport {
+    address hubAddress;
+    address irStrategyAddress;
+    address treasurySpokeAddress;
+  }
+
+  struct GatewaysBatchReport {
+    address signatureGatewayAddress;
+    address nativeGatewayAddress;
+  }
+
+  struct TestTokensBatchReport {
+    address wethAddress;
+    address[] tokenAddresses;
+  }
+}