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,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,162 @@
+// 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 {
+  string internal constant INPUT_PATH = 'scripts/deploy/inputs/';
+  string internal constant OUTPUT_DIR = 'output/reports/deployments/';
+
+  string internal _inputFileName;
+  string internal _outputFileName;
+
+  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();
+    _loadWarnings(logger, inputs);
+    inputs = _sanitizeInputs(inputs, deployer);
+
+    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 _loadWarnings(MetadataLogger logger, FullDeployInputs memory inputs) internal virtual {
+    bool hadWarnings = false;
+    string memory warnings = '';
+    if (inputs.grantRoles) {
+      warnings = _logAndAppend(logger, warnings, 'WARNING: Roles are being set');
+      hadWarnings = true;
+      if (inputs.accessManagerAdmin == address(0)) {
+        warnings = _logAndAppend(
+          logger,
+          warnings,
+          'WARNING: Access Manager Admin is zero address; role will be granted to deployer by default'
+        );
+      }
+      if (inputs.hubConfiguratorOwner == address(0)) {
+        warnings = _logAndAppend(
+          logger,
+          warnings,
+          'WARNING: Hub Configurator Owner is zero address; role will be granted to deployer by default'
+        );
+      }
+      if (inputs.spokeConfiguratorOwner == address(0)) {
+        warnings = _logAndAppend(
+          logger,
+          warnings,
+          'WARNING: Spoke Configurator Owner is zero address; role will be granted to deployer by default'
+        );
+      }
+      if (inputs.spokeProxyAdminOwner == address(0)) {
+        warnings = _logAndAppend(
+          logger,
+          warnings,
+          'WARNING: Spoke Proxy Admin Owner is zero address; role will be granted to deployer by default'
+        );
+      }
+      if (inputs.treasurySpokeOwner == address(0)) {
+        warnings = _logAndAppend(
+          logger,
+          warnings,
+          'WARNING: Treasury Spoke Owner is zero address; role will be granted to deployer by default'
+        );
+      }
+      if (inputs.spokeAdmin == address(0)) {
+        warnings = _logAndAppend(
+          logger,
+          warnings,
+          'WARNING: Spoke Admin is zero address; spoke admin roles will be granted to deployer by default'
+        );
+      }
+    }
+    if (inputs.hubLabels.length == 0) {
+      warnings = _logAndAppend(logger, warnings, 'WARNING: Hub will not be deployed');
+      hadWarnings = true;
+    }
+    if (inputs.spokeLabels.length == 0) {
+      warnings = _logAndAppend(logger, warnings, 'WARNING: Spoke will not be deployed');
+      hadWarnings = true;
+    }
+    if (inputs.nativeWrapper == address(0)) {
+      warnings = _logAndAppend(
+        logger,
+        warnings,
+        'WARNING: Native wrapper zero address; NativeTokenGateway & SignatureGateway will not be deployed'
+      );
+      hadWarnings = true;
+    }
+    logger.log('');
+
+    if (hadWarnings) {
+      _executeUserPrompt(warnings);
+    }
+  }
+
+  function _executeUserPrompt(string memory warnings) internal virtual {
+    string memory ack = vm.prompt(string.concat(warnings, "\nEnter 'y' to continue"));
+    if (keccak256(bytes(ack)) != keccak256(bytes('y'))) {
+      revert('User did not acknowledge warnings. Please try again.');
+    }
+  }
+
+  function _sanitizeInputs(
+    FullDeployInputs memory deployInputs,
+    address deployer
+  ) internal view virtual returns (FullDeployInputs memory) {
+    // if any admin is zero address, default to deployer as admin
+    InputUtils.FullDeployInputs memory sanitizedInputs = deployInputs;
+    sanitizedInputs.accessManagerAdmin = deployInputs.accessManagerAdmin != address(0)
+      ? deployInputs.accessManagerAdmin
+      : deployer;
+    sanitizedInputs.hubConfiguratorOwner = deployInputs.hubConfiguratorOwner != address(0)
+      ? deployInputs.hubConfiguratorOwner
+      : deployer;
+    sanitizedInputs.treasurySpokeOwner = deployInputs.treasurySpokeOwner != address(0)
+      ? deployInputs.treasurySpokeOwner
+      : deployer;
+    sanitizedInputs.spokeProxyAdminOwner = deployInputs.spokeProxyAdminOwner != address(0)
+      ? deployInputs.spokeProxyAdminOwner
+      : deployer;
+    sanitizedInputs.spokeConfiguratorOwner = deployInputs.spokeConfiguratorOwner != address(0)
+      ? deployInputs.spokeConfiguratorOwner
+      : deployer;
+    sanitizedInputs.gatewayOwner = deployInputs.gatewayOwner != address(0)
+      ? deployInputs.gatewayOwner
+      : deployer;
+
+    return sanitizedInputs;
+  }
+
+  function _logAndAppend(
+    MetadataLogger logger,
+    string memory warnings,
+    string memory warning
+  ) internal virtual returns (string memory) {
+    logger.log(warning);
+    return string.concat(warnings, warning, '\n');
+  }
+}

scripts/deploy/inputs/AaveV4DeployInput.json

@@ -0,0 +1,14 @@
+{
+  "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"]
+}

snapshots/Hub.Operations.json

@@ -1,6 +1,6 @@
 {
   "add": "88006",
-  "add: with transfer": "109613",
+  "add: with transfer": "109642",
   "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": "173405",
   "restore: partial": "89137",
-  "restore: partial - with transfer": "147400",
-  "transferShares": "71192"
+  "restore: partial - with transfer": "147429",
+  "transferShares": "71180"
 }

snapshots/SignatureGateway.Operations.json

@@ -2,7 +2,7 @@
   "borrowWithSig": "215605",
   "repayWithSig": "188872",
   "setSelfAsUserPositionManagerWithSig": "75402",
-  "setUsingAsCollateralWithSig": "85053",
+  "setUsingAsCollateralWithSig": "85065",
   "supplyWithSig": "153205",
   "updateUserDynamicConfigWithSig": "62769",
   "updateUserRiskPremiumWithSig": "61579",

snapshots/Spoke.Operations.ZeroRiskPremium.json

@@ -6,7 +6,7 @@
   "liquidationCall: full": "310468",
   "liquidationCall: partial": "310186",
   "permitReserve + repay (multicall)": "166029",
-  "permitReserve + supply (multicall)": "146862",
+  "permitReserve + supply (multicall)": "146850",
   "permitReserve + supply + enable collateral (multicall)": "160573",
   "repay: full": "126094",
   "repay: partial": "130983",

snapshots/Spoke.Operations.json

@@ -6,7 +6,7 @@
   "liquidationCall: full": "344031",
   "liquidationCall: partial": "343749",
   "permitReserve + repay (multicall)": "163273",
-  "permitReserve + supply (multicall)": "146862",
+  "permitReserve + supply (multicall)": "146850",
   "permitReserve + supply + enable collateral (multicall)": "160573",
   "repay: full": "120256",
   "repay: partial": "139545",

src/deployments/batches/AaveV4AccessBatch.sol

@@ -0,0 +1,22 @@
+// 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_) {
+    assert(admin_ != address(0));
+    address accessManager = _deployAccessManagerEnumerable(admin_);
+    _report = BatchReports.AccessBatchReport({accessManager: accessManager});
+  }
+
+  function getReport() external view returns (BatchReports.AccessBatchReport memory) {
+    return _report;
+  }
+}

src/deployments/batches/AaveV4ConfiguratorBatch.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 {
+  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_) {
+    assert(hubConfiguratorOwner_ != address(0));
+    assert(spokeConfiguratorOwner_ != address(0));
+
+    address hubConfigurator = _deployHubConfigurator(hubConfiguratorOwner_);
+    address spokeConfigurator = _deploySpokeConfigurator(spokeConfiguratorOwner_);
+
+    _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,38 @@
+// 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_) {
+    assert(owner_ != address(0));
+    assert(nativeWrapper_ != address(0));
+
+    address nativeGateway = _deployNativeTokenGateway({
+      nativeWrapper: nativeWrapper_,
+      owner: owner_
+    });
+    address signatureGateway = _deploySignatureGateway(owner_);
+
+    _report = BatchReports.GatewaysBatchReport({
+      nativeGateway: nativeGateway,
+      signatureGateway: signatureGateway
+    });
+  }
+
+  function getReport() external view returns (BatchReports.GatewaysBatchReport memory) {
+    return _report;
+  }
+}