refactor(core-state): split DatabaseInteractions (#4353)

__tests__/functional/transaction-forging/__support__/index.ts

@@ -1,14 +1,11 @@
 import "jest-extended";
 
 import { Container, Contracts } from "@arkecosystem/core-kernel";
-import { Identities, Managers, Utils } from "@arkecosystem/crypto";
-import secrets from "@packages/core-test-framework/src/internal/passphrases.json";
+import { Managers } from "@arkecosystem/crypto";
 import delay from "delay";
 
 jest.setTimeout(1200000);
 
-import { DatabaseService } from "@arkecosystem/core-database";
-import { DatabaseInteraction } from "@arkecosystem/core-state";
 import { StateBuilder } from "@arkecosystem/core-state/src/state-builder";
 import { Sandbox } from "@packages/core-test-framework/src";
 
@@ -27,6 +24,7 @@ export const setUp = async (): Promise<Contracts.Kernel.Application> => {
             list: [{ ip: "127.0.0.1", port: 4000 }],
         },
     });
+
     await sandbox.boot(async ({ app }) => {
         await app.bootstrap({
             flags: {
@@ -62,35 +60,6 @@ export const setUp = async (): Promise<Contracts.Kernel.Application> => {
 
         Managers.configManager.getMilestone().aip11 = true;
         Managers.configManager.getMilestone().htlcEnabled = true;
-
-        const databaseService = app.get<DatabaseService>(Container.Identifiers.DatabaseService);
-        const walletRepository = app.getTagged<Contracts.State.WalletRepository>(
-            Container.Identifiers.WalletRepository,
-            "state",
-            "blockchain",
-        );
-
-        await databaseService.saveRound(
-            secrets.map((secret, i) => {
-                const wallet = walletRepository.findByPublicKey(Identities.PublicKey.fromPassphrase(secret));
-
-                wallet.setAttribute("delegate", {
-                    username: `genesis_${i + 1}`,
-                    voteBalance: Utils.BigNumber.make("300000000000000"),
-                    forgedFees: Utils.BigNumber.ZERO,
-                    forgedRewards: Utils.BigNumber.ZERO,
-                    producedBlocks: 0,
-                    round: 1,
-                    rank: undefined,
-                });
-
-                return wallet;
-            }),
-        );
-
-        const databaseInteraction = app.get<DatabaseInteraction>(Container.Identifiers.DatabaseInteraction);
-
-        await (databaseInteraction as any).initializeActiveDelegates(1);
     });
 
     return sandbox.app;
@@ -116,18 +85,27 @@ export const tearDown = async (): Promise<void> => {
             balance: wallet.balance,
             nonce: wallet.nonce,
             attributes: walletAttributes,
-        }
+        };
     };
-    const sortWallets = (a: Contracts.State.Wallet, b: Contracts.State.Wallet) => a.publicKey!.localeCompare(b.publicKey!);
+    const sortWallets = (a: Contracts.State.Wallet, b: Contracts.State.Wallet) =>
+        a.publicKey!.localeCompare(b.publicKey!);
 
-    const allByPublicKey = walletRepository.allByPublicKey().map(w => w.clone()).sort(sortWallets).map(mapWallets);
+    const allByPublicKey = walletRepository
+        .allByPublicKey()
+        .map((w) => w.clone())
+        .sort(sortWallets)
+        .map(mapWallets);
 
     walletRepository.reset();
 
     await sandbox.app.resolve<StateBuilder>(StateBuilder).run();
     await delay(2000); // if there is an issue with state builder, we wait a bit to be sure to catch it in the logs
 
-    const allByPublicKeyBootstrapped = walletRepository.allByPublicKey().map(w => w.clone()).sort(sortWallets).map(mapWallets);
+    const allByPublicKeyBootstrapped = walletRepository
+        .allByPublicKey()
+        .map((w) => w.clone())
+        .sort(sortWallets)
+        .map(mapWallets);
     expect(allByPublicKeyBootstrapped).toEqual(allByPublicKey);
 };
 

__tests__/integration/core-api/handlers/rounds.test.ts

@@ -1,9 +1,7 @@
 import "@packages/core-test-framework/src/matchers";
 
-import { DatabaseService } from "@arkecosystem/core-database";
-import { Container, Contracts } from "@arkecosystem/core-kernel";
-import { DatabaseInteraction } from "@arkecosystem/core-state";
-import { ApiHelpers, Factories } from "@packages/core-test-framework/src";
+import { Contracts } from "@arkecosystem/core-kernel";
+import { ApiHelpers } from "@packages/core-test-framework/src";
 
 import { calculateRanks, setUp, tearDown } from "../__support__/setup";
 
@@ -13,12 +11,6 @@ beforeAll(async () => {
     app = await setUp();
     api = new ApiHelpers(app);
 
-    const databaseService = app.get<DatabaseService>(Container.Identifiers.DatabaseService);
-    await databaseService.saveRound(Factories.factory("Round").make());
-    const databaseInteraction = app.get<DatabaseInteraction>(Container.Identifiers.DatabaseInteraction);
-
-    await (databaseInteraction as any).initializeActiveDelegates(1);
-
     await calculateRanks();
 });
 

__tests__/unit/core-blockchain/blockchain.test.ts

@@ -99,7 +99,7 @@ describe("Blockchain", () => {
 
         databaseInteractions.getTopBlocks = jest.fn();
         databaseInteractions.getLastBlock = jest.fn();
-        databaseInteractions.loadBlocksFromCurrentRound = jest.fn();
+        databaseInteractions.restoreCurrentRound = jest.fn();
         databaseInteractions.revertBlock = jest.fn();
         databaseInteractions.deleteRound = jest.fn();
         databaseInteractions.getActiveDelegates = jest.fn().mockReturnValue([]);
@@ -707,7 +707,7 @@ describe("Blockchain", () => {
                 await blockchain.removeTopBlocks(numberOfBlocks);
 
                 expect(blockRepository.deleteTopBlocks).toHaveBeenLastCalledWith(numberOfBlocks);
-                expect(databaseInteractions.loadBlocksFromCurrentRound).toHaveBeenCalled();
+                expect(databaseInteractions.restoreCurrentRound).toHaveBeenCalled();
             },
         );
     });

__tests__/unit/core-blockchain/process-blocks-job.test.ts

@@ -1,9 +1,9 @@
 import { ProcessBlockAction } from "@packages/core-blockchain/src/actions";
-import { Container, Services } from "@packages/core-kernel";
-import { Crypto, Interfaces, Networks } from "@packages/crypto";
 import { ProcessBlocksJob } from "@packages/core-blockchain/src/process-blocks-job";
 import { BlockProcessorResult } from "@packages/core-blockchain/src/processor";
+import { Container, Services } from "@packages/core-kernel";
 import { Sandbox } from "@packages/core-test-framework";
+import { Crypto, Interfaces, Networks } from "@packages/crypto";
 
 import { Blocks } from "./__fixtures__";
 
@@ -200,7 +200,7 @@ describe("Blockchain", () => {
 
             blockchainService.clearQueue = jest.fn();
             blockchainService.resetLastDownloadedBlock = jest.fn();
-            databaseInteraction.loadBlocksFromCurrentRound = jest.fn();
+            databaseInteraction.restoreCurrentRound = jest.fn();
             databaseService.deleteRound = jest.fn();
 
             stateStore.setLastBlock = jest.fn();
@@ -210,7 +210,7 @@ describe("Blockchain", () => {
 
             expect(blockchainService.clearQueue).toBeCalledTimes(1);
             expect(blockchainService.resetLastDownloadedBlock).toBeCalledTimes(1);
-            expect(databaseInteraction.loadBlocksFromCurrentRound).toBeCalledTimes(1);
+            expect(databaseInteraction.restoreCurrentRound).toBeCalledTimes(1);
             expect(databaseService.deleteRound).toBeCalledTimes(1);
         });
 
@@ -229,7 +229,7 @@ describe("Blockchain", () => {
 
             blockchainService.clearQueue = jest.fn();
             blockchainService.resetLastDownloadedBlock = jest.fn();
-            databaseInteraction.loadBlocksFromCurrentRound = jest.fn();
+            databaseInteraction.restoreCurrentRound = jest.fn();
             databaseService.deleteRound = jest.fn();
 
             stateStore.setLastBlock = jest.fn();
@@ -239,7 +239,7 @@ describe("Blockchain", () => {
 
             expect(blockchainService.clearQueue).toBeCalledTimes(1);
             expect(blockchainService.resetLastDownloadedBlock).toBeCalledTimes(1);
-            expect(databaseInteraction.loadBlocksFromCurrentRound).toBeCalledTimes(1);
+            expect(databaseInteraction.restoreCurrentRound).toBeCalledTimes(1);
             expect(databaseService.deleteRound).toBeCalledTimes(1);
 
             expect(process.exit).toHaveBeenCalled();

__tests__/unit/core-blockchain/processor/block-processor.test.ts

@@ -45,9 +45,11 @@ describe("BlockProcessor", () => {
         },
         getTopBlocks: jest.fn(),
         getLastBlock: jest.fn(),
-        loadBlocksFromCurrentRound: jest.fn(),
+        restoreCurrentRound: jest.fn(),
         revertBlock: jest.fn(),
         deleteRound: jest.fn(),
+    };
+    const roundState = {
         getActiveDelegates: jest.fn().mockReturnValue([]),
     };
 
@@ -58,6 +60,7 @@ describe("BlockProcessor", () => {
         sandbox.app.bind(Container.Identifiers.WalletRepository).toConstantValue(walletRepository);
         sandbox.app.bind(Container.Identifiers.DatabaseService).toConstantValue(databaseService);
         sandbox.app.bind(Container.Identifiers.DatabaseInteraction).toConstantValue(databaseInteractions);
+        sandbox.app.bind(Container.Identifiers.RoundState).toConstantValue(roundState);
         sandbox.app.bind(Container.Identifiers.TransactionHandlerRegistry).toConstantValue(transactionHandlerRegistry);
         sandbox.app.bind(Container.Identifiers.StateStore).toConstantValue({});
         sandbox.app.bind(Container.Identifiers.TransactionPoolService).toConstantValue({});
@@ -229,7 +232,7 @@ describe("BlockProcessor", () => {
             };
 
             walletRepository.getNonce = jest.fn().mockReturnValueOnce(Utils.BigNumber.ONE);
-            databaseInteractions.getActiveDelegates = jest.fn().mockReturnValueOnce([]);
+            roundState.getActiveDelegates = jest.fn().mockReturnValueOnce([]);
             blockchain.getLastBlock = jest.fn().mockReturnValueOnce(baseBlock);
             const generatorWallet = {
                 getAttribute: jest.fn().mockReturnValue("generatorusername"),
@@ -255,7 +258,7 @@ describe("BlockProcessor", () => {
         };
         walletRepository.findByPublicKey = jest.fn().mockReturnValueOnce(generatorWallet);
         UnchainedHandler.prototype.initialize = jest.fn().mockReturnValueOnce(new UnchainedHandler());
-        databaseInteractions.getActiveDelegates = jest.fn().mockReturnValueOnce([]);
+        roundState.getActiveDelegates = jest.fn().mockReturnValueOnce([]);
 
         const blockProcessor = sandbox.app.resolve<BlockProcessor>(BlockProcessor);
 
@@ -311,7 +314,7 @@ describe("BlockProcessor", () => {
             activeDelegatesWithoutGenerator.length = 51;
             activeDelegatesWithoutGenerator.fill(notBlockGenerator, 0);
 
-            databaseInteractions.getActiveDelegates = jest.fn().mockReturnValueOnce(activeDelegatesWithoutGenerator);
+            roundState.getActiveDelegates = jest.fn().mockReturnValueOnce(activeDelegatesWithoutGenerator);
 
             const blockProcessor = sandbox.app.resolve<BlockProcessor>(BlockProcessor);
 
@@ -338,7 +341,7 @@ describe("BlockProcessor", () => {
                 publicKey: "02ff171adaef486b7db9fc160b28433d20cf43163d56fd28fee72145f0d5219a4b",
             };
 
-            databaseInteractions.getActiveDelegates = jest.fn().mockReturnValueOnce([notBlockGenerator]);
+            roundState.getActiveDelegates = jest.fn().mockReturnValueOnce([notBlockGenerator]);
 
             const blockProcessor = sandbox.app.resolve<BlockProcessor>(BlockProcessor);
 
@@ -359,7 +362,7 @@ describe("BlockProcessor", () => {
             ...chainedBlock,
             transactions: [{ data: transactionData, id: transactionData.id } as Interfaces.ITransaction],
         };
-        databaseInteractions.getActiveDelegates = jest.fn().mockReturnValueOnce([]);
+        roundState.getActiveDelegates = jest.fn().mockReturnValueOnce([]);
         blockchain.getLastBlock = jest.fn().mockReturnValueOnce(baseBlock);
         transactionRepository.getForgedTransactionsIds = jest.fn().mockReturnValueOnce([transactionData.id]);
         walletRepository.getNonce = jest.fn().mockReturnValueOnce(Utils.BigNumber.ONE);
@@ -379,7 +382,7 @@ describe("BlockProcessor", () => {
         const block = {
             ...chainedBlock,
         };
-        databaseInteractions.getActiveDelegates = jest.fn().mockReturnValueOnce([]);
+        roundState.getActiveDelegates = jest.fn().mockReturnValueOnce([]);
         blockchain.getLastBlock = jest.fn().mockReturnValueOnce(baseBlock);
         transactionRepository.getForgedTransactionsIds = jest.fn().mockReturnValueOnce([]);
         const generatorWallet = {

__tests__/unit/core-blockchain/processor/handlers/unchained-handler.test.ts

@@ -28,6 +28,9 @@ const databaseInteractions = {
     loadBlocksFromCurrentRound: jest.fn(),
     revertBlock: jest.fn(),
     deleteRound: jest.fn(),
+};
+
+const roundState = {
     getActiveDelegates: jest.fn().mockReturnValue([]),
 };
 
@@ -39,6 +42,7 @@ beforeEach(() => {
     sandbox.app.bind(Container.Identifiers.LogService).toConstantValue(logger);
     sandbox.app.bind(Container.Identifiers.DatabaseService).toConstantValue(database);
     sandbox.app.bind(Container.Identifiers.DatabaseInteraction).toConstantValue(databaseInteractions);
+    sandbox.app.bind(Container.Identifiers.RoundState).toConstantValue(roundState);
 
     sandbox.app.bind(Container.Identifiers.TriggerService).to(Services.Triggers.Triggers).inSingletonScope();
     sandbox.app
@@ -67,7 +71,7 @@ describe("UnchainedHandler", () => {
                     },
                 };
                 blockchain.getLastBlock = jest.fn().mockReturnValueOnce(lastBlock);
-                databaseInteractions.getActiveDelegates = jest
+                roundState.getActiveDelegates = jest
                     .fn()
                     .mockResolvedValueOnce(
                         [
@@ -96,7 +100,7 @@ describe("UnchainedHandler", () => {
                     },
                 };
                 blockchain.getLastBlock = jest.fn().mockReturnValueOnce(lastBlock);
-                databaseInteractions.getActiveDelegates = jest
+                roundState.getActiveDelegates = jest
                     .fn()
                     .mockResolvedValueOnce(
                         [

__tests__/unit/core-blockchain/state-machine/actions/initialize.test.ts

@@ -198,7 +198,7 @@ describe("Initialize", () => {
 
                 expect(stateStore.setLastBlock).toHaveBeenCalledTimes(1);
                 expect(databaseService.deleteRound).toHaveBeenCalledTimes(1);
-                expect(databaseInteractions.restoreCurrentRound).toHaveBeenCalledTimes(0);
+                expect(databaseInteractions.restoreCurrentRound).toHaveBeenCalledTimes(1);
                 expect(transactionPool.readdTransactions).toHaveBeenCalledTimes(0);
                 expect(peerNetworkMonitor.boot).toHaveBeenCalledTimes(1);
                 expect(stateBuilder.run).toHaveBeenCalledTimes(1);

__tests__/unit/core-forger/setup.ts

@@ -34,7 +34,7 @@ export const setup = async (activeDelegates) => {
     }
 
     @Container.injectable()
-    class MockDatabaseInteraction {
+    class MockRoundState {
         public async getActiveDelegates(): Promise<Wallet[]> {
             return activeDelegates;
         }
@@ -58,7 +58,7 @@ export const setup = async (activeDelegates) => {
 
     sandbox.app.bind(Container.Identifiers.DatabaseService).to(MockDatabaseService);
 
-    sandbox.app.bind(Container.Identifiers.DatabaseInteraction).to(MockDatabaseInteraction);
+    sandbox.app.bind(Container.Identifiers.RoundState).to(MockRoundState);
 
     sandbox.app.bind(Container.Identifiers.BlockchainService).to(MockBlockchainService);