feat(core-forger): implements forger.nextSlot process actions (#3735)

__tests__/unit/core-forger/forger-service.test.ts

@@ -127,7 +127,19 @@ describe("ForgerService", () => {
         });
     });
 
-    describe("GetLastForgedBlock", () => {
+    describe("GetRemainingSlotTime", () => {
+        it("should return undefined", async () => {
+            forgerService.register({ hosts: [mockHost] });
+
+            // @ts-ignore
+            const spyGetNetworkState = jest.spyOn(forgerService.client, "getNetworkState");
+            spyGetNetworkState.mockResolvedValue(mockNetworkState);
+
+            await expect(forgerService.getRemainingSlotTime()).resolves.toBeNumber();
+        });
+    });
+
+  describe("GetLastForgedBlock", () => {
         it("should return undefined", async () => {
             forgerService.register({ hosts: [mockHost] });
 

__tests__/unit/core-forger/process-actions/next-slot.test.ts

@@ -0,0 +1,28 @@
+import "jest-extended";
+
+import { Container } from "@arkecosystem/core-kernel";
+import { Sandbox } from "@arkecosystem/core-test-framework/src";
+import { NextSlotProcessAction } from "@packages/core-forger/src/process-actions/next-slot";
+
+let sandbox: Sandbox;
+let action: NextSlotProcessAction;
+
+const mockForgerService = {
+    getRemainingSlotTime: jest.fn().mockReturnValue(1000),
+};
+
+beforeEach(() => {
+    sandbox = new Sandbox();
+
+    sandbox.app.bind(Container.Identifiers.ForgerService).toConstantValue(mockForgerService);
+
+    action = sandbox.app.resolve(NextSlotProcessAction);
+});
+
+describe("NextSlotProcessAction", () => {
+    it("should return remaining time", async () => {
+        await expect(action.handler()).resolves.toEqual({
+            remainingTime: 1000,
+        });
+    });
+});

packages/core-forger/src/forger-service.ts

@@ -78,6 +78,17 @@ export class ForgerService {
         return this.round;
     }
 
+    public async getRemainingSlotTime(): Promise<number> {
+        const networkState: Contracts.P2P.NetworkState = await this.client.getNetworkState();
+
+        const blockTimeLookup = await AppUtils.forgingInfoCalculator.getBlockTimeLookup(
+            this.app,
+            networkState.nodeHeight!,
+        );
+
+        return Crypto.Slots.getTimeInMsUntilNextSlot(blockTimeLookup);
+    }
+
     public getLastForgedBlock(): Interfaces.IBlock | undefined {
         return this.lastForgedBlock;
     }

packages/core-forger/src/process-actions/index.ts

@@ -1,2 +1,3 @@
 export * from "./current-delegate";
+export * from "./next-slot";
 export * from "./last-forged-block";

packages/core-forger/src/process-actions/next-slot.ts

@@ -0,0 +1,17 @@
+import { Container, Contracts } from "@arkecosystem/core-kernel";
+
+import { ForgerService } from "../forger-service";
+
+@Container.injectable()
+export class NextSlotProcessAction implements Contracts.Kernel.ProcessAction {
+    public name = "forger.nextSlot";
+
+    @Container.inject(Container.Identifiers.ForgerService)
+    private readonly forger!: ForgerService;
+
+    public async handler() {
+        return {
+            remainingTime: await this.forger.getRemainingSlotTime(),
+        };
+    }
+}

packages/core-forger/src/service-provider.ts

@@ -5,7 +5,7 @@ import { DelegateFactory } from "./delegate-factory";
 import { DelegateTracker } from "./delegate-tracker";
 import { ForgerService } from "./forger-service";
 import { Delegate } from "./interfaces";
-import { CurrentDelegateProcessAction, LastForgedBlockRemoteAction } from "./process-actions";
+import { CurrentDelegateProcessAction, NextSlotProcessAction, LastForgedBlockRemoteAction } from "./process-actions";
 
 /**
  * @export
@@ -81,6 +81,10 @@ export class ServiceProvider extends Providers.ServiceProvider {
             .register(this.app.resolve(CurrentDelegateProcessAction));
 
         this.app
+            .get<Contracts.Kernel.ProcessActionsService>(Container.Identifiers.ProcessActionsService)
+            .register(this.app.resolve(NextSlotProcessAction));
+
+      this.app
             .get<Contracts.Kernel.ProcessActionsService>(Container.Identifiers.ProcessActionsService)
             .register(this.app.resolve(LastForgedBlockRemoteAction));
     }