fix: dual governance deployment after rebase

sandstone-ag · sandstone-ag · commit 4b6dc0923546 · 2025-09-29T12:36:12.000+04:00
diff --git a/lib/config-schemas.ts b/lib/config-schemas.ts
@@ -238,6 +238,66 @@ const LidoApmSchema = z.object({
   ensRegDurationSec: PositiveIntSchema,
 });
 
+// DG deployment config schemas
+const DGConfigDGSanityCheckParamsSchema = z.object({
+  max_min_assets_lock_duration: PositiveIntSchema,
+  max_sealable_withdrawal_blockers_count: PositiveIntSchema,
+  max_tiebreaker_activation_timeout: PositiveIntSchema,
+  min_tiebreaker_activation_timeout: NonNegativeIntSchema,
+  min_withdrawals_batch_size: PositiveIntSchema,
+});
+
+const DGConfigDGSchema = z.object({
+  tiebreaker_activation_timeout: NonNegativeIntSchema,
+  sanity_check_params: DGConfigDGSanityCheckParamsSchema,
+});
+
+const DGConfigDGConfigProviderSchema = z.object({
+  first_seal_rage_quit_support: BigIntStringSchema,
+  second_seal_rage_quit_support: BigIntStringSchema,
+  min_assets_lock_duration: NonNegativeIntSchema,
+  rage_quit_eth_withdrawals_delay_growth: PositiveIntSchema,
+  rage_quit_eth_withdrawals_min_delay: NonNegativeIntSchema,
+  rage_quit_eth_withdrawals_max_delay: PositiveIntSchema,
+  rage_quit_extension_period_duration: NonNegativeIntSchema,
+  veto_cooldown_duration: NonNegativeIntSchema,
+  veto_signalling_deactivation_max_duration: PositiveIntSchema,
+  veto_signalling_min_duration: NonNegativeIntSchema,
+  veto_signalling_max_duration: PositiveIntSchema,
+  veto_signalling_min_active_duration: NonNegativeIntSchema,
+});
+
+const DGConfigTimelockSanityCheckParamsSchema = z.object({
+  min_execution_delay: NonNegativeIntSchema,
+  max_after_submit_delay: PositiveIntSchema,
+  max_after_schedule_delay: PositiveIntSchema,
+  max_emergency_mode_duration: PositiveIntSchema,
+  max_emergency_protection_duration: PositiveIntSchema,
+});
+
+const DGConfigTimelockEmergencyProtectionSchema = z.object({
+  emergency_mode_duration: NonNegativeIntSchema,
+  emergency_protection_end_date: PositiveIntSchema,
+});
+
+const DGConfigTimelockSchema = z.object({
+  after_submit_delay: NonNegativeIntSchema,
+  after_schedule_delay: NonNegativeIntSchema,
+  sanity_check_params: DGConfigTimelockSanityCheckParamsSchema,
+  emergency_protection: DGConfigTimelockEmergencyProtectionSchema,
+});
+
+const DGConfigTiebreakerSchema = z.object({
+  execution_delay: NonNegativeIntSchema,
+});
+
+const DGConfigSchema = z.object({
+  dual_governance: DGConfigDGSchema,
+  dual_governance_config_provider: DGConfigDGConfigProviderSchema,
+  timelock: DGConfigTimelockSchema,
+  tiebreaker: DGConfigTiebreakerSchema,
+});
+
 // Scratch parameters schema
 export const ScratchParametersSchema = z.object({
   chainSpec: ChainSpecSchema.omit({ genesisTime: true, depositContract: true }),
@@ -267,6 +327,7 @@ export const ScratchParametersSchema = z.object({
   triggerableWithdrawalsGateway: TriggerableWithdrawalsGatewaySchema,
   predepositGuarantee: PredepositGuaranteeSchema.omit({ genesisForkVersion: true }),
   operatorGrid: OperatorGridSchema,
+  dualGovernanceConfig: DGConfigSchema,
 });
 
 // Inferred types from zod schemas
diff --git a/lib/dg-installation.ts b/lib/dg-installation.ts
@@ -1,6 +1,6 @@
-import child_process from "node:child_process";
 import fs from "node:fs/promises";
-import util from "node:util";
+
+import { runCommand } from "./subprocess";
 
 const DG_REPOSITORY_URL = "https://github.com/lidofinance/dual-governance.git";
 const DG_REPOSITORY_BRANCH = "feature/scratch-deploy-support2"; // TODO: use release branch
@@ -31,18 +31,6 @@ async function runUnitTests(workingDirectory: string) {
   await runCommand("npm run test:unit", workingDirectory);
 }
 
-async function runCommand(command: string, workingDirectory: string) {
-  const exec = util.promisify(child_process.exec);
-
-  try {
-    const { stdout } = await exec(command, { cwd: workingDirectory });
-    console.log("stdout:", stdout);
-  } catch (error) {
-    console.error(`Error running command ${command}`, `${error}`);
-    throw error;
-  }
-}
-
 main()
   .then(() => process.exit(0))
   .catch((error) => {
diff --git a/lib/dg-regression-tests.ts b/lib/dg-regression-tests.ts
@@ -0,0 +1,22 @@
+import { log } from "./log";
+import { runCommand } from "./subprocess";
+
+const DG_INSTALL_DIR = `${process.cwd()}/dg`;
+
+async function runDGRegressionTests() {
+  log.header("Run Dual Governance regression tests");
+  try {
+    await runCommand("npm run test:regressions", DG_INSTALL_DIR);
+  } catch (error) {
+    // TODO: some of regression tests don't work at the moment, need to fix it.
+    log.error("DG regression tests run failed");
+    log(`${error}`);
+  }
+}
+
+runDGRegressionTests()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/lib/subprocess.ts b/lib/subprocess.ts
@@ -0,0 +1,14 @@
+import child_process from "node:child_process";
+import util from "node:util";
+
+export async function runCommand(command: string, workingDirectory: string) {
+  const exec = util.promisify(child_process.exec);
+
+  try {
+    const { stdout } = await exec(command, { cwd: workingDirectory });
+    console.log("stdout:", stdout);
+  } catch (error) {
+    console.error(`Error running command ${command}`, `${error}`);
+    throw error;
+  }
+}
diff --git a/package.json b/package.json
@@ -43,6 +43,7 @@
     "validate:configs": "yarn hardhat validate-configs",
     "typecheck": "tsc --noEmit",
     "dg:install": "yarn ts-node lib/dg-installation.ts",
+    "dg:regression-tests": "yarn ts-node lib/dg-regression-tests.ts",
     "abis:extract": "hardhat abis:extract",
     "verify:deployed": "hardhat verify:deployed",
     "postinstall": "husky"
diff --git a/scripts/dao-local-deploy.sh b/scripts/dao-local-deploy.sh
@@ -26,8 +26,6 @@ export INTEGRATION_WITH_CSM="off"
 yarn test:integration:fork:local
 
 # If Dual Governance was deployed
-if grep "dg:dual_governance" $NETWORK_STATE_FILE -q; then
-  # Run DG regression tests
-  echo "Run Dual Governance regression tests"
-  (cd dg && npm run test:regressions)
+if grep "dg:dualGovernance" $NETWORK_STATE_FILE -q; then
+  yarn dg:regression-tests
 fi
diff --git a/scripts/dao-local-upgrade.sh b/scripts/dao-local-upgrade.sh
@@ -24,8 +24,6 @@ yarn hardhat --network $NETWORK run --no-compile scripts/utils/mine.ts
 yarn test:integration:fork:local
 
 # If Dual Governance was deployed
-if grep "dg:dual_governance" $NETWORK_STATE_FILE -q; then
-  # Run DG regression tests
-  echo "Run Dual Governance regression tests"
-  (cd dg && npm run test:regressions)
+if grep "dg:dualGovernance" $NETWORK_STATE_FILE -q; then
+  yarn dg:regression-tests
 fi
diff --git a/scripts/scratch/steps/0150-transfer-roles.ts b/scripts/scratch/steps/0150-transfer-roles.ts
@@ -65,10 +65,6 @@ export async function main() {
     await makeTx(depositSecurityModule, "setOwner", [agent], { from: deployer });
   }
 
-  // Transfer ownership of LidoTemplate to agent
-  const lidoTemplate = await loadContract("LidoTemplate", state[Sk.lidoTemplate].address);
-  await makeTx(lidoTemplate, "setOwner", [agent], { from: deployer });
-
   // Transfer admin for WithdrawalsManagerProxy from deployer to voting
   const withdrawalsManagerProxy = await loadContract("WithdrawalsManagerProxy", state.withdrawalVault.proxy.address);
   await makeTx(withdrawalsManagerProxy, "proxy_changeAdmin", [voting], { from: deployer });
diff --git a/scripts/scratch/steps/0160-deploy-dual-governance.ts b/scripts/scratch/steps/0160-deploy-dual-governance.ts
@@ -1,15 +1,14 @@
-import child_process from "node:child_process";
 import fs from "node:fs/promises";
-import util from "node:util";
 
 import { ethers } from "hardhat";
 
 import { LidoTemplate, WithdrawalQueueERC721 } from "typechain-types";
 
 import { log } from "lib";
-import { loadContract } from "lib/contract";
+import { loadContract, LoadedContract } from "lib/contract";
 import { makeTx } from "lib/deploy";
 import { DeploymentState, getAddress, readNetworkState, Sk, updateObjectInState } from "lib/state-file";
+import { runCommand } from "lib/subprocess";
 
 const DG_INSTALL_DIR = `${process.cwd()}/dg`;
 const DG_DEPLOY_ARTIFACTS_DIR = `${DG_INSTALL_DIR}/deploy-artifacts`;
@@ -99,6 +98,16 @@ async function finalizePermissionsWithoutDGDeployment() {
   const lidoTemplate = await loadContract<LidoTemplate>("LidoTemplate", lidoTemplateAddress);
 
   await makeTx(lidoTemplate, "finalizePermissionsWithoutDGDeployment", [], { from: deployer });
+
+  await transferLidoTemplateOwnershipToAgent(deployer, lidoTemplate, getAddress(Sk.appAgent, networkState));
+}
+
+async function transferLidoTemplateOwnershipToAgent(
+  deployer: string,
+  lidoTemplate: LoadedContract<LidoTemplate>,
+  aragonAgentAddress: string,
+) {
+  await makeTx(lidoTemplate, "setOwner", [aragonAgentAddress], { from: deployer });
 }
 
 async function transferRoles(deployer: string, dgDeployArtifacts: DGDeployArtifacts, networkState: DeploymentState) {
@@ -149,6 +158,8 @@ async function transferRoles(deployer: string, dgDeployArtifacts: DGDeployArtifa
   await makeTx(lidoTemplate, "finalizePermissionsAfterDGDeployment", [dgDeployArtifacts.admin_executor], {
     from: deployer,
   });
+
+  await transferLidoTemplateOwnershipToAgent(deployer, lidoTemplate, aragonAgentAddress);
 }
 
 async function unpauseWithdrawalQueue(deployer: string, networkState: DeploymentState) {
@@ -173,18 +184,6 @@ async function prepareDGRegressionTestsRun(networkChainId: string, networkState:
   await writeDGDotEnvFile(dotEnvFile);
 }
 
-async function runCommand(command: string, workingDirectory: string) {
-  const exec = util.promisify(child_process.exec);
-
-  try {
-    const { stdout } = await exec(command, { cwd: workingDirectory });
-    log("stdout:", stdout);
-  } catch (error) {
-    log.error(`Error running command ${command}`, `${error}`);
-    throw error;
-  }
-}
-
 async function writeDGConfigFile(dgConfig: string, filename: string) {
   const dgConfigFilePath = `${DG_INSTALL_DIR}/deploy-config/${filename}`;
 
@@ -252,60 +251,13 @@ function getDGConfig(chainId: string, networkState: DeploymentState) {
         wst_eth: wstEth,
         withdrawal_queue: withdrawalQueue,
       },
-      sanity_check_params: {
-        max_min_assets_lock_duration:
-          networkState[Sk.dualGovernanceConfig].dual_governance.sanity_check_params.max_min_assets_lock_duration,
-        max_sealable_withdrawal_blockers_count:
-          networkState[Sk.dualGovernanceConfig].dual_governance.sanity_check_params
-            .max_sealable_withdrawal_blockers_count,
-        max_tiebreaker_activation_timeout:
-          networkState[Sk.dualGovernanceConfig].dual_governance.sanity_check_params.max_tiebreaker_activation_timeout,
-        min_tiebreaker_activation_timeout:
-          networkState[Sk.dualGovernanceConfig].dual_governance.sanity_check_params.min_tiebreaker_activation_timeout,
-        min_withdrawals_batch_size:
-          networkState[Sk.dualGovernanceConfig].dual_governance.sanity_check_params.min_withdrawals_batch_size,
-      },
-    },
-    dual_governance_config_provider: {
-      first_seal_rage_quit_support:
-        networkState[Sk.dualGovernanceConfig].dual_governance_config_provider.first_seal_rage_quit_support,
-      second_seal_rage_quit_support:
-        networkState[Sk.dualGovernanceConfig].dual_governance_config_provider.second_seal_rage_quit_support,
-      min_assets_lock_duration:
-        networkState[Sk.dualGovernanceConfig].dual_governance_config_provider.min_assets_lock_duration,
-      rage_quit_eth_withdrawals_delay_growth:
-        networkState[Sk.dualGovernanceConfig].dual_governance_config_provider.rage_quit_eth_withdrawals_delay_growth,
-      rage_quit_eth_withdrawals_min_delay:
-        networkState[Sk.dualGovernanceConfig].dual_governance_config_provider.rage_quit_eth_withdrawals_min_delay,
-      rage_quit_eth_withdrawals_max_delay:
-        networkState[Sk.dualGovernanceConfig].dual_governance_config_provider.rage_quit_eth_withdrawals_max_delay,
-      rage_quit_extension_period_duration:
-        networkState[Sk.dualGovernanceConfig].dual_governance_config_provider.rage_quit_extension_period_duration,
-      veto_cooldown_duration:
-        networkState[Sk.dualGovernanceConfig].dual_governance_config_provider.veto_cooldown_duration,
-      veto_signalling_deactivation_max_duration:
-        networkState[Sk.dualGovernanceConfig].dual_governance_config_provider.veto_signalling_deactivation_max_duration,
-      veto_signalling_min_active_duration:
-        networkState[Sk.dualGovernanceConfig].dual_governance_config_provider.veto_signalling_min_active_duration,
-      veto_signalling_min_duration:
-        networkState[Sk.dualGovernanceConfig].dual_governance_config_provider.veto_signalling_min_duration,
-      veto_signalling_max_duration:
-        networkState[Sk.dualGovernanceConfig].dual_governance_config_provider.veto_signalling_max_duration,
+      sanity_check_params: networkState[Sk.dualGovernanceConfig].dual_governance.sanity_check_params,
     },
+    dual_governance_config_provider: networkState[Sk.dualGovernanceConfig].dual_governance_config_provider,
     timelock: {
       after_submit_delay: networkState[Sk.dualGovernanceConfig].timelock.after_submit_delay,
       after_schedule_delay: networkState[Sk.dualGovernanceConfig].timelock.after_schedule_delay,
-      sanity_check_params: {
-        min_execution_delay: networkState[Sk.dualGovernanceConfig].timelock.sanity_check_params.min_execution_delay,
-        max_after_submit_delay:
-          networkState[Sk.dualGovernanceConfig].timelock.sanity_check_params.max_after_submit_delay,
-        max_after_schedule_delay:
-          networkState[Sk.dualGovernanceConfig].timelock.sanity_check_params.max_after_schedule_delay,
-        max_emergency_mode_duration:
-          networkState[Sk.dualGovernanceConfig].timelock.sanity_check_params.max_emergency_mode_duration,
-        max_emergency_protection_duration:
-          networkState[Sk.dualGovernanceConfig].timelock.sanity_check_params.max_emergency_protection_duration,
-      },
+      sanity_check_params: networkState[Sk.dualGovernanceConfig].timelock.sanity_check_params,
       emergency_protection: {
         emergency_activation_committee: daoVoting,
         emergency_execution_committee: daoVoting,
diff --git a/scripts/utils/scratch.ts b/scripts/utils/scratch.ts
@@ -121,5 +121,6 @@ export function scratchParametersToDeploymentState(params: ScratchParameters): R
     operatorGrid: {
       deployParameters: params.operatorGrid,
     },
+    dualGovernanceConfig: params.dualGovernanceConfig,
   };
 }

Original file line number	Diff line number	Diff line change
`@@ -121,5 +121,6 @@ export function scratchParametersToDeploymentState(params: ScratchParameters): R`
`121`	`121`	`operatorGrid: {`
`122`	`122`	`deployParameters: params.operatorGrid,`
`123`	`123`	`},`
	`124`	`+ dualGovernanceConfig: params.dualGovernanceConfig,`
`124`	`125`	`};`
`125`	`126`	`}`