feat: auto initial epoch detection for oracles

eddort · tamtamchik · commit a5940fa08eb7 · 2025-02-28T16:42:40.000Z
diff --git a/packages/cl-client/src/index.ts b/packages/cl-client/src/index.ts
@@ -44,6 +44,22 @@ export const BeaconConfigSchema = z.object({
 
 export type BeaconConfigResponse = z.infer<typeof BeaconConfigSchema>;
 
+export const BeaconFinalizedCheckpointSchema = z.object({
+  data: z.object({
+    finalized: z.object({
+      epoch: z.string(),
+    }),
+  }),
+});
+
+export const BeaconHeadCheckpointSchema = z.object({
+  data: z.object({
+    current_justified: z.object({
+      epoch: z.string(),
+    }),
+  }),
+});
+
 export class BeaconClient {
   private baseUrl: string;
 
@@ -54,39 +70,57 @@ export class BeaconClient {
   public async getBlock(blockId: string): Promise<BeaconBlockResponse> {
     return this.fetchAndValidate(
       `${this.baseUrl}/eth/v1/beacon/blocks/${blockId}`,
-      BeaconBlockSchema
+      BeaconBlockSchema,
     );
   }
 
   public async getConfig(): Promise<BeaconConfigResponse> {
     return this.fetchAndValidate(
       `${this.baseUrl}/eth/v1/config/spec`,
-      BeaconConfigSchema
+      BeaconConfigSchema,
+    );
+  }
+
+  public async getFinalizedEpoch(): Promise<number> {
+    const response = await this.fetchAndValidate(
+      `${this.baseUrl}/eth/v1/beacon/states/finalized/finality_checkpoints`,
+      BeaconFinalizedCheckpointSchema,
     );
+    return Number.parseInt(response.data.finalized.epoch, 10);
   }
 
   public async getGenesis(): Promise<BeaconGenesisResponse> {
     return this.fetchAndValidate(
       `${this.baseUrl}/eth/v1/beacon/genesis`,
-      BeaconGenesisSchema
+      BeaconGenesisSchema,
+    );
+  }
+
+  public async getHeadEpoch(): Promise<number> {
+    const response = await this.fetchAndValidate(
+      `${this.baseUrl}/eth/v1/beacon/states/head/finality_checkpoints`,
+      BeaconHeadCheckpointSchema,
     );
+    return Number.parseInt(response.data.current_justified.epoch, 10);
   }
 
-  public async getValidators(stateId: string): Promise<BeaconValidatorsResponse> {
+  public async getValidators(
+    stateId: string,
+  ): Promise<BeaconValidatorsResponse> {
     return this.fetchAndValidate(
       `${this.baseUrl}/eth/v1/beacon/states/${stateId}/validators`,
-      BeaconValidatorsSchema
+      BeaconValidatorsSchema,
     );
   }
 
   private async fetchAndValidate<T>(
     url: string,
-    schema: z.Schema<T>
+    schema: z.Schema<T>,
   ): Promise<T> {
     const response = await fetch(url);
     if (!response.ok) {
       throw new Error(
-        `Error fetching ${url}: ${response.status} ${response.statusText}`
+        `Error fetching ${url}: ${response.status} ${response.statusText}`,
       );
     }
 
diff --git a/packages/services/src/index.ts b/packages/services/src/index.ts
@@ -115,7 +115,10 @@ const oracle = new DevNetServiceConfig({
   },
   workspace: "workspaces/oracle-v5",
   name: "oracle" as const,
-  constants: {},
+  constants: {
+    HASH_CONSENSUS_AO_EPOCHS_PER_FRAME: 8,
+    HASH_CONSENSUS_VEBO_EPOCHS_PER_FRAME: 8
+  },
   labels: {},
 });
 
diff --git a/src/commands/csm/activate.ts b/src/commands/csm/activate.ts
@@ -14,20 +14,34 @@ export const ActivateCSM = command.cli({
   description:
     "Activates the csm by deploying smart contracts and configuring the environment based on the current network state.",
   params: {},
-  async handler({ dre, dre: { logger } }) {
-    const { lidoCLI } = dre.services;
+  async handler({ dre, dre: { logger, network } }) {
+    const { lidoCLI, oracle } = dre.services;
 
     const { elPublic } = await dre.state.getChain();
     const csmState = await dre.state.getCSM();
+    const clClient = await network.getCLClient();
 
     await dre.network.waitEL();
 
+    const {
+      HASH_CONSENSUS_AO_EPOCHS_PER_FRAME,
+      HASH_CONSENSUS_VEBO_EPOCHS_PER_FRAME,
+    } = oracle.config.constants;
+
+    const epochPerFrame = Math.max(
+      HASH_CONSENSUS_AO_EPOCHS_PER_FRAME,
+      HASH_CONSENSUS_VEBO_EPOCHS_PER_FRAME,
+    );
+
+    const currentEpoch = await clClient.getHeadEpoch();
+    const initialEpoch = epochPerFrame + currentEpoch + 2;
+
     const env: CSMActivateENV = {
       CS_ACCOUNTING_ADDRESS: csmState.accounting,
       CS_MODULE_ADDRESS: csmState.module,
       CS_ORACLE_HASH_CONSENSUS_ADDRESS: csmState.hashConsensus,
       // TODO: calculate it
-      CS_ORACLE_INITIAL_EPOCH: "60",
+      CS_ORACLE_INITIAL_EPOCH: initialEpoch.toString(),
       EL_API_PROVIDER: elPublic,
     };
 
diff --git a/src/commands/lido-core/activate.ts b/src/commands/lido-core/activate.ts
@@ -7,11 +7,13 @@ export const ActivateLidoProtocol = command.cli({
   async handler({ dre }) {
     const {
       state,
-      services: { lidoCLI },
+      services: { lidoCLI, oracle },
+      network,
     } = dre;
 
     const { elPublic } = await state.getChain();
     const { deployer, oracles, councils } = await state.getNamedWallet();
+    const clClient = await network.getCLClient();
 
     await dre.network.waitEL();
 
@@ -23,12 +25,25 @@ export const ActivateLidoProtocol = command.cli({
       EL_API_PROVIDER: elPublic,
     };
 
+    const {
+      HASH_CONSENSUS_AO_EPOCHS_PER_FRAME,
+      HASH_CONSENSUS_VEBO_EPOCHS_PER_FRAME,
+    } = oracle.config.constants;
+
+    const epochPerFrame = Math.max(
+      HASH_CONSENSUS_AO_EPOCHS_PER_FRAME,
+      HASH_CONSENSUS_VEBO_EPOCHS_PER_FRAME,
+    );
+
+    const currentEpoch = await clClient.getHeadEpoch();
+    const initialEpoch = epochPerFrame + currentEpoch + 2;
+
     const activateCoreSh = lidoCLI.sh({ env: deployEnv });
-    // TODO: calc oracles-initial-epoch (time voting + 1 epoch for core and +50 for CSM)
-    await activateCoreSh`./run.sh devnet setup 
+
+    await activateCoreSh`./run.sh devnet setup
                           --oracles-members ${oracles.map(({ publicKey }) => publicKey).join(",")}
                           --oracles-quorum ${oracles.length - 1}
-                          --oracles-initial-epoch 60
+                          --oracles-initial-epoch ${initialEpoch}
                           --dsm-guardians ${councils.map(({ publicKey }) => publicKey).join(",")}
                           --dsm-quorum ${councils.length}
                           --roles-beneficiary ${deployer.publicKey}`;
diff --git a/src/commands/lido-core/prepare-repository.ts b/src/commands/lido-core/prepare-repository.ts
@@ -6,34 +6,49 @@ export const PrepareLidoCore = command.cli({
     vesting: Params.string({
       description: "Vesting LDO amount",
       default: "820000000000000000000000",
-      required: false
+      required: false,
     }),
     voteDuration: Params.integer({
       description: "Voting duration",
       default: 60,
-      required: false
+      required: false,
     }),
     objectionPhaseDuration: Params.integer({
       description: "Objection phase duration",
       default: 5,
-      required: false
+      required: false,
     }),
   },
   async handler({
     dre,
     params: { voteDuration, objectionPhaseDuration, vesting },
   }) {
     const { state, services } = dre;
-    const { lidoCore } = services;
+    const { lidoCore, oracle } = services;
     const { constants } = lidoCore.config;
     const { deployer, secondDeployer } = await state.getNamedWallet();
-    
+
     const filePath = constants.NETWORK_STATE_DEFAULTS_FILE;
     const networkStateDefaults = await lidoCore.readJson(filePath);
 
-    const { vestingParams, daoInitialSettings } = networkStateDefaults;
+    const {
+      vestingParams,
+      daoInitialSettings,
+      oracleDaemonConfig,
+      hashConsensusForAccountingOracle,
+      hashConsensusForValidatorsExitBusOracle,
+    } = networkStateDefaults;
     assert(vestingParams?.holders, "Missing vestingParams.holders");
     assert(daoInitialSettings?.voting, "Missing daoInitialSettings.voting");
+    assert(oracleDaemonConfig, "Missing oracleDaemonConfig");
+    assert(
+      hashConsensusForAccountingOracle,
+      "Missing hashConsensusForAccountingOracle",
+    );
+    assert(
+      hashConsensusForValidatorsExitBusOracle,
+      "Missing hashConsensusForValidatorsExitBusOracle",
+    );
 
     Object.assign(vestingParams.holders, {
       [deployer.publicKey]: vesting,
@@ -45,6 +60,39 @@ export const PrepareLidoCore = command.cli({
       objectionPhaseDuration,
     });
 
+    Object.assign(oracleDaemonConfig, {
+      deployParameters: {
+        NORMALIZED_CL_REWARD_PER_EPOCH: 64,
+        NORMALIZED_CL_REWARD_MISTAKE_RATE_BP: 1000,
+        REBASE_CHECK_NEAREST_EPOCH_DISTANCE: 1,
+        REBASE_CHECK_DISTANT_EPOCH_DISTANCE: 2,
+        VALIDATOR_DELAYED_TIMEOUT_IN_SLOTS: 7200,
+        VALIDATOR_DELINQUENT_TIMEOUT_IN_SLOTS: 28_800,
+        NODE_OPERATOR_NETWORK_PENETRATION_THRESHOLD_BP: 100,
+        PREDICTION_DURATION_IN_SLOTS: 50_400,
+        FINALIZATION_MAX_NEGATIVE_REBASE_EPOCH_SHIFT: 1350,
+      },
+    });
+
+    const {
+      HASH_CONSENSUS_AO_EPOCHS_PER_FRAME,
+      HASH_CONSENSUS_VEBO_EPOCHS_PER_FRAME,
+    } = oracle.config.constants;
+
+    Object.assign(hashConsensusForAccountingOracle, {
+      deployParameters: {
+        fastLaneLengthSlots: 10,
+        epochsPerFrame: HASH_CONSENSUS_AO_EPOCHS_PER_FRAME,
+      },
+    });
+
+    Object.assign(hashConsensusForValidatorsExitBusOracle, {
+      deployParameters: {
+        fastLaneLengthSlots: 10,
+        epochsPerFrame: HASH_CONSENSUS_VEBO_EPOCHS_PER_FRAME,
+      },
+    });
+
     await lidoCore.writeJson(filePath, networkStateDefaults, true);
   },
 });
diff --git a/src/commands/stands/pectra-only-contracts.ts b/src/commands/stands/pectra-only-contracts.ts
@@ -0,0 +1,43 @@
+import { Params, command } from "@devnet/command";
+
+import { BlockscoutUp } from "../blockscout/up.js";
+import { KurtosisUp } from "../chain/up.js";
+import { DeployCSMContracts } from "../csm/deploy.js";
+import { GitCheckout } from "../git/checkout.js";
+import { DeployLidoContracts } from "../lido-core/deploy.js";
+
+
+export const PectraDevNetUp = command.cli({
+  description: "Pectra cotracts only with protocol smart contracts.",
+  params: {
+    verify: Params.boolean({
+      description: "Enables verification of smart contracts during deployment.",
+    }),
+    dsm: Params.boolean({
+      description: "Use full DSM setup.",
+      default: false,
+    }),
+  },
+  async handler({ params, dre, dre: { logger } }) {
+    await dre.runCommand(GitCheckout, {
+      service: "lidoCore",
+      ref: "develop",
+    });
+
+    await dre.runCommand(KurtosisUp, { preset: "pectra-devnet6" });
+    logger.log("✅ Network initialized.");
+
+    await dre.runCommand(BlockscoutUp, {});
+    logger.log("✅ BlockScout launched for transaction visualization.");
+
+    const deployArgs = { verify: params.verify };
+
+    logger.log("🚀 Deploying Lido Core contracts...");
+    await dre.runCommand(DeployLidoContracts, deployArgs);
+    logger.log("✅ Lido contracts deployed.");
+
+    logger.log("🚀 Deploying CSM contracts...");
+    await dre.runCommand(DeployCSMContracts, deployArgs);
+    logger.log("✅ CSM contracts deployed.");
+  },
+});
