refactor: implement BeaconEngine

packages/beacon-node/src/api/impl/beacon/blocks/utils.ts

@@ -1,8 +1,8 @@
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
-import {IForkChoice} from "@lodestar/fork-choice";
 import {blockToHeader} from "@lodestar/state-transition";
 import {RootHex, SignedBeaconBlock, Slot} from "@lodestar/types";
+import {IBeaconEngine} from "../../../../chain/beaconEngine/index.js";
 import {IBeaconChain} from "../../../../chain/interface.js";
 import {GENESIS_SLOT} from "../../../../constants/index.js";
 import {rootHexRegex} from "../../../../execution/engine/utils.js";
@@ -23,22 +23,22 @@ export function toBeaconHeaderResponse(
   };
 }
 
-export function resolveBlockId(forkChoice: IForkChoice, blockId: routes.beacon.BlockId): RootHex | Slot {
+export function resolveBlockId(beaconEngine: IBeaconEngine, blockId: routes.beacon.BlockId): RootHex | Slot {
   blockId = String(blockId).toLowerCase();
   if (blockId === "head") {
-    return forkChoice.getHead().blockRoot;
+    return beaconEngine.getHead().blockRoot;
   }
 
   if (blockId === "genesis") {
     return GENESIS_SLOT;
   }
 
   if (blockId === "finalized") {
-    return forkChoice.getFinalizedBlock().blockRoot;
+    return beaconEngine.getFinalizedBlock().blockRoot;
   }
 
   if (blockId === "justified") {
-    return forkChoice.getJustifiedBlock().blockRoot;
+    return beaconEngine.getJustifiedBlock().blockRoot;
   }
 
   if (blockId.startsWith("0x")) {
@@ -60,7 +60,7 @@ export async function getBlockResponse(
   chain: IBeaconChain,
   blockId: routes.beacon.BlockId
 ): Promise<{block: SignedBeaconBlock; executionOptimistic: boolean; finalized: boolean}> {
-  const rootOrSlot = resolveBlockId(chain.forkChoice, blockId);
+  const rootOrSlot = resolveBlockId(chain.beaconEngine, blockId);
 
   const res =
     typeof rootOrSlot === "string"

packages/beacon-node/src/api/impl/beacon/rewards/index.ts

@@ -10,20 +10,23 @@ export function getBeaconRewardsApi({
   return {
     async getBlockRewards({blockId}) {
       const {block, executionOptimistic, finalized} = await getBlockResponse(chain, blockId);
-      const data = await chain.getBlockRewards(block.message);
+      const data = await chain.beaconEngine.getBlockRewards(block.message);
       return {data, meta: {executionOptimistic, finalized}};
     },
     async getAttestationsRewards({epoch, validatorIds}) {
       assertUniqueItems(validatorIds, "Duplicate validator IDs provided");
 
-      const {rewards, executionOptimistic, finalized} = await chain.getAttestationsRewards(epoch, validatorIds);
+      const {rewards, executionOptimistic, finalized} = await chain.beaconEngine.getAttestationsRewards(
+        epoch,
+        validatorIds
+      );
       return {data: rewards, meta: {executionOptimistic, finalized}};
     },
     async getSyncCommitteeRewards({blockId, validatorIds}) {
       assertUniqueItems(validatorIds, "Duplicate validator IDs provided");
 
       const {block, executionOptimistic, finalized} = await getBlockResponse(chain, blockId);
-      const data = await chain.getSyncCommitteeRewards(block.message, validatorIds);
+      const data = await chain.beaconEngine.getSyncCommitteeRewards(block.message, validatorIds);
       return {data, meta: {executionOptimistic, finalized}};
     },
   };