exchangeTransitionConfiguration heartbeat implementation

packages/lodestar/src/executionEngine/http.ts

@@ -21,6 +21,9 @@ import {
   PayloadId,
   PayloadAttributes,
   ApiPayloadAttributes,
+  TransitionConfigOpts,
+  ApiTransitionConfig,
+  TransitionConfig,
 } from "./interface";
 
 export type ExecutionEngineHttpOpts = {
@@ -44,14 +47,65 @@ export const defaultExecutionEngineHttpOpts: ExecutionEngineHttpOpts = {
  */
 export class ExecutionEngineHttp implements IExecutionEngine {
   private readonly rpc: IJsonRpcHttpClient;
+  private readonly transitionConfig: ApiTransitionConfig;
+  private readonly heartBeatInSec?: number;
+  private lastHeartBeatAt = 0;
 
-  constructor(opts: ExecutionEngineHttpOpts, signal: AbortSignal, rpc?: IJsonRpcHttpClient) {
+  constructor(opts: ExecutionEngineHttpOpts & TransitionConfigOpts, signal: AbortSignal, rpc?: IJsonRpcHttpClient) {
+    this.transitionConfig = serializeTransitionConfig(opts.transitionConfig);
+    this.heartBeatInSec = opts.heartBeatInSec;
     this.rpc =
       rpc ??
       new JsonRpcHttpClient(opts.urls, {
         signal,
         timeout: opts.timeout,
       });
+    void this.exchangeTransitionConfiguration();
+  }
+
+  /**
+   * `engine_exchangeTransitionConfigurationV1`
+   * From: https://github.com/ethereum/execution-apis/blob/v1.0.0-alpha.7/src/engine/specification.md#engine_exchangetransitionconfigurationv1
+   *
+   * 1. Execution Layer client software MUST respond with configurable setting values that
+   *    are set according to the Client software configuration section of EIP-3675.
+   *
+   * 2. Execution Layer client software SHOULD surface an error to the user if local
+   *   configuration settings mismatch corresponding values received in the call of this
+   *   method, with exception for terminalBlockNumber value.
+   *
+   * 3. Consensus Layer client software SHOULD surface an error to the user if local
+   *    configuration settings mismatch corresponding values obtained from the response
+   *    to the call of this method.
+   */
+  async exchangeTransitionConfiguration(): Promise<ApiTransitionConfig> {
+    const method = "engine_exchangeTransitionConfigurationV1";
+    const transitionConfig = await this.rpc.fetch<
+      EngineApiRpcReturnTypes[typeof method],
+      EngineApiRpcParamTypes[typeof method]
+    >({
+      method,
+      params: [this.transitionConfig],
+    });
+    // TODO: determine the throw condition, also identify how to update terminal blocktracker hash
+    // and the terminal number depending upon
+    // 1. eth1 tracker 2. the terminal block received
+    // as per spec, this must not be dynamic
+    if (
+      transitionConfig.terminalTotalDifficulty !== this.transitionConfig.terminalTotalDifficulty ||
+      transitionConfig.terminalBlockHash !== this.transitionConfig.terminalBlockHash ||
+      transitionConfig.terminalBlockNumber !== this.transitionConfig.terminalBlockNumber
+    ) {
+      throw Error(
+        `Transition config mismatch, actual=${JSON.stringify(transitionConfig)}, expected=${JSON.stringify(
+          this.transitionConfig
+        )}`
+      );
+    }
+    // Use this lastHeartBeatAt in the actual engine api calls to identify if this needs to
+    // be called again
+    this.lastHeartBeatAt = Math.floor(new Date().getTime() / 1000);
+    return transitionConfig;
   }
 
   /**
@@ -262,6 +316,9 @@ export class ExecutionEngineHttp implements IExecutionEngine {
 /* eslint-disable @typescript-eslint/naming-convention */
 
 type EngineApiRpcParamTypes = {
+  /**
+   */
+  engine_exchangeTransitionConfigurationV1: [ApiTransitionConfig];
   /**
    * 1. Object - Instance of ExecutionPayload
    */
@@ -282,6 +339,10 @@ type EngineApiRpcParamTypes = {
 };
 
 type EngineApiRpcReturnTypes = {
+  /**
+   *
+   */
+  engine_exchangeTransitionConfigurationV1: ApiTransitionConfig;
   /**
    * Object - Response object:
    * - status: String - the result of the payload execution:
@@ -355,3 +416,11 @@ export function parseExecutionPayload(data: ExecutionPayloadRpc): bellatrix.Exec
     transactions: data.transactions.map((tran) => dataToBytes(tran)),
   };
 }
+
+export function serializeTransitionConfig(transitionConfig: TransitionConfig): ApiTransitionConfig {
+  return {
+    terminalTotalDifficulty: numToQuantity(transitionConfig.terminalTotalDifficulty),
+    terminalBlockHash: bytesToData(transitionConfig.terminalBlockHash),
+    terminalBlockNumber: numToQuantity(transitionConfig.terminalBlockNumber),
+  };
+}

packages/lodestar/src/executionEngine/index.ts

@@ -1,5 +1,5 @@
 import {AbortSignal} from "@chainsafe/abort-controller";
-import {IExecutionEngine} from "./interface";
+import {IExecutionEngine, TransitionConfigOpts} from "./interface";
 import {ExecutionEngineDisabled} from "./disabled";
 import {ExecutionEngineHttp, ExecutionEngineHttpOpts, defaultExecutionEngineHttpOpts} from "./http";
 import {ExecutionEngineMock, ExecutionEngineMockOpts} from "./mock";
@@ -13,7 +13,10 @@ export type ExecutionEngineOpts =
 
 export const defaultExecutionEngineOpts: ExecutionEngineOpts = defaultExecutionEngineHttpOpts;
 
-export function initializeExecutionEngine(opts: ExecutionEngineOpts, signal: AbortSignal): IExecutionEngine {
+export function initializeExecutionEngine(
+  opts: ExecutionEngineOpts & TransitionConfigOpts,
+  signal: AbortSignal
+): IExecutionEngine {
   switch (opts.mode) {
     case "mock":
       return new ExecutionEngineMock(opts);

packages/lodestar/src/executionEngine/interface.ts

@@ -56,6 +56,20 @@ export type PayloadAttributes = {
   suggestedFeeRecipient: Uint8Array | ByteVector;
 };
 
+export type TransitionConfig = {
+  terminalTotalDifficulty: bigint;
+  terminalBlockHash: Uint8Array | ByteVector;
+  terminalBlockNumber: number;
+};
+
+export type TransitionConfigOpts = {transitionConfig: TransitionConfig; heartBeatInSec?: number};
+
+export type ApiTransitionConfig = {
+  terminalTotalDifficulty: QUANTITY;
+  terminalBlockHash: DATA;
+  terminalBlockNumber: QUANTITY;
+};
+
 export type ApiPayloadAttributes = {
   /** QUANTITY, 64 Bits - value for the timestamp field of the new payload */
   timestamp: QUANTITY;

packages/lodestar/src/node/nodejs.ts

@@ -133,6 +133,13 @@ export class BeaconNode {
       initBeaconMetrics(metrics, anchorState);
     }
 
+    const transitionConfig = {
+      terminalTotalDifficulty: config.TERMINAL_TOTAL_DIFFICULTY,
+      terminalBlockHash: config.TERMINAL_BLOCK_HASH,
+      /** terminalBlockNumber has to be set to zero for now as per specs */
+      terminalBlockNumber: 0,
+    };
+
     const chain = new BeaconChain(opts.chain, {
       config,
       db,
@@ -144,7 +151,13 @@ export class BeaconNode {
         {config, db, logger: logger.child(opts.logger.eth1), signal},
         anchorState
       ),
-      executionEngine: initializeExecutionEngine(opts.executionEngine, signal),
+      executionEngine: initializeExecutionEngine(
+        {
+          ...opts.executionEngine,
+          transitionConfig,
+        },
+        signal
+      ),
     });
 
     // Load persisted data from disk to in-memory caches

packages/lodestar/test/unit/executionEngine/http.test.ts

@@ -2,7 +2,14 @@ import chai, {expect} from "chai";
 import chaiAsPromised from "chai-as-promised";
 import {fastify} from "fastify";
 import {AbortController} from "@chainsafe/abort-controller";
-import {ExecutionEngineHttp, parseExecutionPayload, serializeExecutionPayload} from "../../../src/executionEngine/http";
+import {
+  ExecutionEngineHttp,
+  parseExecutionPayload,
+  serializeExecutionPayload,
+  serializeTransitionConfig,
+} from "../../../src/executionEngine/http";
+import {TransitionConfig} from "../../../src/executionEngine/interface";
+import {ZERO_HASH} from "../../../src/constants";
 
 chai.use(chaiAsPromised);
 
@@ -18,6 +25,7 @@ describe("ExecutionEngine / http", () => {
   let executionEngine: ExecutionEngineHttp;
   let returnValue: unknown = {};
   let reqJsonRpcPayload: unknown = {};
+  let transitionConfig: TransitionConfig;
 
   before("Prepare server", async () => {
     const controller = new AbortController();
@@ -35,8 +43,36 @@ describe("ExecutionEngine / http", () => {
     });
 
     const baseUrl = await server.listen(0);
+    transitionConfig = {terminalTotalDifficulty: BigInt(0), terminalBlockHash: ZERO_HASH, terminalBlockNumber: 0};
 
-    executionEngine = new ExecutionEngineHttp({urls: [baseUrl]}, controller.signal);
+    executionEngine = new ExecutionEngineHttp({urls: [baseUrl], transitionConfig}, controller.signal);
+  });
+
+  it("exchangeTransitionConfiguration", async () => {
+    /**
+     * curl -X POST -H "Content-Type: application/json" --data '{"jsonrpc":"2.0","method":"engine_exchangeTransitionConfigurationV1","params":[{"terminalTotalDifficulty":"0x0","terminalBlockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","terminalBlockNumber":"0x0"}],"id":67}' http://localhost:8550
+     */
+
+    const request = {
+      jsonrpc: "2.0",
+      method: "engine_exchangeTransitionConfigurationV1",
+      params: [serializeTransitionConfig(transitionConfig)],
+    };
+    const response = {
+      jsonrpc: "2.0",
+      id: 67,
+      result: {
+        terminalTotalDifficulty: "0x0",
+        terminalBlockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+        terminalBlockNumber: "0x0",
+      },
+    };
+    returnValue = response;
+
+    const elConfig = await executionEngine.exchangeTransitionConfiguration();
+
+    expect(elConfig).to.deep.equal(response.result, "Transition config mismatch");
+    expect(reqJsonRpcPayload).to.deep.equal(request, "Wrong request JSON RPC payload");
   });
 
   it("getPayload", async () => {