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
+

config/AaveV4DeployInput.json

@@ -0,0 +1,15 @@
+{
+  "accessManagerAdmin": "0x0000000000000000000000000000000000000001",
+  "hubConfiguratorOwner": "0x0000000000000000000000000000000000000002",
+  "hubAdmin": "0x0000000000000000000000000000000000000003",
+  "treasurySpokeOwner": "0x0000000000000000000000000000000000000003",
+  "spokeConfiguratorOwner": "0x0000000000000000000000000000000000000004",
+  "spokeAdmin": "0x0000000000000000000000000000000000000005",
+  "spokeProxyAdminOwner": "0x0000000000000000000000000000000000000005",
+  "gatewayOwner": "0x0000000000000000000000000000000000000005",
+  "nativeWrapper": "0x0000000000000000000000000000000000000006",
+  "grantRoles": true,
+  "hubLabels": ["Hub 1", "Hub 2", "Hub 3"],
+  "spokeLabels": ["Spoke 1", "Spoke 2", "Spoke 3"],
+  "salt": "salt"
+}

foundry.toml

@@ -3,14 +3,19 @@ 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" }
+]
 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 +54,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,11 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (c) 2025 Aave Labs
+pragma solidity ^0.8.0;
+
+import 'scripts/deploy/AaveV4DeployBatchBase.s.sol';
+
+contract AaveV4DeployBatchScript is AaveV4DeployBatchBaseScript {
+  string internal constant INPUT_FILE = 'AaveV4DeployInput.json';
+  string internal constant OUTPUT_FILE = 'AaveV4DeployBatch.json';
+  constructor() AaveV4DeployBatchBaseScript(INPUT_FILE, OUTPUT_FILE) {}
+}

scripts/deploy/AaveV4DeployBatchBase.s.sol

@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (c) 2025 Aave Labs
+pragma solidity ^0.8.0;
+
+import {OrchestrationReports} from 'src/deployments/libraries/OrchestrationReports.sol';
+import {InputUtils} from 'src/deployments/utils/InputUtils.sol';
+import {MetadataLogger} from 'src/deployments/utils/MetadataLogger.sol';
+import {
+  AaveV4DeployOrchestration
+} from 'src/deployments/orchestration/AaveV4DeployOrchestration.sol';
+
+import {Script} from 'forge-std/Script.sol';
+
+abstract contract AaveV4DeployBatchBaseScript is Script, InputUtils {
+  struct Warnings {
+    string[] s;
+  }
+
+  string internal constant INPUT_PATH = 'config/';
+  string internal constant OUTPUT_DIR = 'output/reports/deployments/';
+  string internal _inputFileName;
+  string internal _outputFileName;
+  Warnings internal _warnings;
+
+  constructor(string memory inputFileName_, string memory outputFileName_) {
+    _inputFileName = inputFileName_;
+    _outputFileName = outputFileName_;
+  }
+
+  function run() external virtual {
+    vm.createDir(OUTPUT_DIR, true);
+    MetadataLogger logger = new MetadataLogger(OUTPUT_DIR);
+    FullDeployInputs memory inputs = loadFullDeployInputs(
+      string.concat(INPUT_PATH, _inputFileName)
+    );
+    (, address deployer, ) = vm.readCallers();
+    inputs = _loadWarningsAndSanitizeInputs(logger, inputs, deployer);
+
+    logger.log('CHAIN ID', block.chainid);
+    logger.log('...Starting Aave V4 Batch Deployment...');
+    vm.startBroadcast(deployer);
+    OrchestrationReports.FullDeploymentReport memory report = AaveV4DeployOrchestration
+      .deployAaveV4(logger, deployer, inputs);
+    vm.stopBroadcast();
+    logger.writeJsonReportMarket(report);
+    logger.log('...Batch Deployment Completed...');
+    logger.log('...Saving Logs...');
+    logger.save({fileName: _outputFileName, withTimestamp: true});
+  }
+
+  function _loadWarningsAndSanitizeInputs(
+    MetadataLogger logger,
+    FullDeployInputs memory inputs,
+    address deployer
+  ) internal virtual returns (FullDeployInputs memory) {
+    string memory message = ' is zero address';
+    string memory outcome = '; defaulting to deployer';
+
+    FullDeployInputs memory sanitizedInputs = inputs;
+    bool hadWarnings = false;
+    if (inputs.grantRoles) {
+      _logAndAppend(logger, string.concat('Roles are being set'));
+      hadWarnings = true;
+      if (inputs.accessManagerAdmin == address(0)) {
+        _logAndAppend(logger, string.concat('Access Manager Admin', message, outcome));
+        sanitizedInputs.accessManagerAdmin = deployer;
+      }
+      if (inputs.hubConfiguratorOwner == address(0)) {
+        _logAndAppend(logger, string.concat('Hub Configurator Owner', message, outcome));
+        sanitizedInputs.hubConfiguratorOwner = deployer;
+      }
+      if (inputs.spokeConfiguratorOwner == address(0)) {
+        _logAndAppend(logger, string.concat('Spoke Configurator Owner', message, outcome));
+        sanitizedInputs.spokeConfiguratorOwner = deployer;
+      }
+      if (inputs.spokeProxyAdminOwner == address(0)) {
+        _logAndAppend(logger, string.concat('Spoke Proxy Admin Owner', message, outcome));
+        sanitizedInputs.spokeProxyAdminOwner = deployer;
+      }
+      if (inputs.treasurySpokeOwner == address(0)) {
+        _logAndAppend(logger, string.concat('Treasury Spoke Owner', message, outcome));
+        sanitizedInputs.treasurySpokeOwner = deployer;
+      }
+      if (inputs.spokeAdmin == address(0)) {
+        _logAndAppend(logger, string.concat('Spoke Admin', message, outcome));
+        sanitizedInputs.spokeAdmin = deployer;
+      }
+      if (inputs.hubAdmin == address(0)) {
+        _logAndAppend(logger, string.concat('Hub Admin', message, outcome));
+        sanitizedInputs.hubAdmin = deployer;
+      }
+    }
+    if (inputs.hubLabels.length == 0) {
+      _logAndAppend(logger, string.concat('Hub will not be deployed'));
+      hadWarnings = true;
+      sanitizedInputs.hubLabels = new string[](0);
+    }
+    if (inputs.spokeLabels.length == 0) {
+      _logAndAppend(logger, string.concat('Spoke will not be deployed'));
+      hadWarnings = true;
+      sanitizedInputs.spokeLabels = new string[](0);
+    }
+    if (inputs.nativeWrapper == address(0)) {
+      _logAndAppend(
+        logger,
+        string.concat(
+          'Native wrapper',
+          message,
+          "; NativeTokenGateway & SignatureGateway will not be deployed'"
+        )
+      );
+      hadWarnings = true;
+      sanitizedInputs.nativeWrapper = address(0);
+    }
+    if (inputs.gatewayOwner == address(0)) {
+      _logAndAppend(logger, string.concat('Gateway owner', message, outcome));
+      hadWarnings = true;
+      sanitizedInputs.gatewayOwner = deployer;
+    }
+    if (hadWarnings) {
+      _executeUserPrompt();
+    }
+    return sanitizedInputs;
+  }
+
+  function _executeUserPrompt() internal virtual {
+    string memory ack = vm.prompt(
+      string.concat(_joinWarnings(_warnings), "\nEnter 'y' to continue")
+    );
+    if (keccak256(bytes(ack)) != keccak256(bytes('y'))) {
+      revert('User did not acknowledge warnings. Please try again.');
+    }
+  }
+
+  function _logAndAppend(MetadataLogger logger, string memory warning) internal virtual {
+    warning = string.concat('WARNING: ', warning);
+    logger.log(warning);
+    _warnings.s.push(warning);
+  }
+
+  function _joinWarnings(Warnings storage warnings) internal view virtual returns (string memory) {
+    uint256 n = warnings.s.length;
+    if (n == 0) return '';
+    string memory out = warnings.s[0];
+    for (uint256 i = 1; i < n; i++) {
+      out = string.concat(out, '\n', warnings.s[i]);
+    }
+    return string.concat(out, '\n');
+  }
+}

snapshots/Hub.Operations.json

@@ -1,6 +1,6 @@
 {
   "add": "88006",
-  "add: with transfer": "109613",
+  "add: with transfer": "109652",
   "draw": "105931",
   "eliminateDeficit: full": "59781",
   "eliminateDeficit: partial": "69429",
@@ -11,8 +11,8 @@
   "remove: partial": "81640",
   "reportDeficit": "115225",
   "restore: full": "80471",
-  "restore: full - with transfer": "173377",
+  "restore: full - with transfer": "173421",
   "restore: partial": "89137",
-  "restore: partial - with transfer": "147400",
+  "restore: partial - with transfer": "147439",
   "transferShares": "71192"
 }

snapshots/SignatureGateway.Operations.json

@@ -1,7 +1,7 @@
 {
   "borrowWithSig": "215605",
-  "repayWithSig": "188872",
-  "setSelfAsUserPositionManagerWithSig": "75402",
+  "repayWithSig": "188860",
+  "setSelfAsUserPositionManagerWithSig": "75390",
   "setUsingAsCollateralWithSig": "85053",
   "supplyWithSig": "153205",
   "updateUserDynamicConfigWithSig": "62769",

snapshots/Spoke.Operations.ZeroRiskPremium.json

@@ -10,7 +10,7 @@
   "permitReserve + supply + enable collateral (multicall)": "160573",
   "repay: full": "126094",
   "repay: partial": "130983",
-  "setUserPositionManagerWithSig: disable": "44846",
+  "setUserPositionManagerWithSig: disable": "44822",
   "setUserPositionManagerWithSig: enable": "68875",
   "supply + enable collateral (multicall)": "140624",
   "supply: 0 borrows, collateral disabled": "123679",

snapshots/Spoke.Operations.json

@@ -10,7 +10,7 @@
   "permitReserve + supply + enable collateral (multicall)": "160573",
   "repay: full": "120256",
   "repay: partial": "139545",
-  "setUserPositionManagerWithSig: disable": "44846",
+  "setUserPositionManagerWithSig: disable": "44822",
   "setUserPositionManagerWithSig: enable": "68875",
   "supply + enable collateral (multicall)": "140624",
   "supply: 0 borrows, collateral disabled": "123679",

src/deployments/batches/AaveV4AccessBatch.sol

@@ -0,0 +1,24 @@
+// 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_, bytes32 salt_) {
+    address accessManager = _deployAccessManagerEnumerable(
+      admin_,
+      keccak256(abi.encodePacked(SALT, salt_, 'accessManager'))
+    );
+    _report = BatchReports.AccessBatchReport({accessManager: accessManager});
+  }
+
+  function getReport() external view returns (BatchReports.AccessBatchReport memory) {
+    return _report;
+  }
+}

src/deployments/batches/AaveV4ConfiguratorBatch.sol

@@ -0,0 +1,38 @@
+// 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/hub/AaveV4HubConfiguratorDeployProcedure.sol';
+import {
+  AaveV4SpokeConfiguratorDeployProcedure
+} from 'src/deployments/procedures/deploy/spoke/AaveV4SpokeConfiguratorDeployProcedure.sol';
+
+contract AaveV4ConfiguratorBatch is
+  AaveV4HubConfiguratorDeployProcedure,
+  AaveV4SpokeConfiguratorDeployProcedure
+{
+  BatchReports.ConfiguratorBatchReport internal _report;
+
+  constructor(address hubConfiguratorOwner_, address spokeConfiguratorOwner_, bytes32 salt_) {
+    address hubConfigurator = _deployHubConfigurator(
+      hubConfiguratorOwner_,
+      keccak256(abi.encodePacked(SALT, salt_, 'hubConfigurator'))
+    );
+    address spokeConfigurator = _deploySpokeConfigurator(
+      spokeConfiguratorOwner_,
+      keccak256(abi.encodePacked(SALT, salt_, 'spokeConfigurator'))
+    );
+
+    _report = BatchReports.ConfiguratorBatchReport({
+      hubConfigurator: hubConfigurator,
+      spokeConfigurator: spokeConfigurator
+    });
+  }
+
+  function getReport() external view returns (BatchReports.ConfiguratorBatchReport memory) {
+    return _report;
+  }
+}

src/deployments/batches/AaveV4GatewayBatch.sol

@@ -0,0 +1,39 @@
+// 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/position-manager/AaveV4NativeTokenGatewayDeployProcedure.sol';
+import {
+  AaveV4SignatureGatewayDeployProcedure
+} from 'src/deployments/procedures/deploy/position-manager/AaveV4SignatureGatewayDeployProcedure.sol';
+
+contract AaveV4GatewayBatch is
+  AaveV4NativeTokenGatewayDeployProcedure,
+  AaveV4SignatureGatewayDeployProcedure
+{
+  BatchReports.GatewaysBatchReport internal _report;
+
+  constructor(address owner_, address nativeWrapper_, bytes32 salt_) {
+    address nativeGateway = _deployNativeTokenGateway({
+      nativeWrapper: nativeWrapper_,
+      owner: owner_,
+      salt: keccak256(abi.encodePacked(SALT, salt_, 'nativeGateway'))
+    });
+    address signatureGateway = _deploySignatureGateway(
+      owner_,
+      keccak256(abi.encodePacked(SALT, salt_, 'signatureGateway'))
+    );
+
+    _report = BatchReports.GatewaysBatchReport({
+      nativeGateway: nativeGateway,
+      signatureGateway: signatureGateway
+    });
+  }
+
+  function getReport() external view returns (BatchReports.GatewaysBatchReport memory) {
+    return _report;
+  }
+}