feat(core-state): in-memory storage for last N blocks and transactions

__tests__/integration/core-p2p/mocks/core-container.ts

@@ -104,9 +104,12 @@ jest.mock("@arkecosystem/core-container", () => {
 
                 if (name === "state") {
                     return {
-                        getLastBlock: () => genesisBlock,
-                        cacheTransactions: jest.fn().mockImplementation(txs => ({ notAdded: txs, added: [] })),
-                        removeCachedTransactionIds: jest.fn().mockReturnValue(null),
+                        getStore: () => ({
+                            getLastBlock: () => genesisBlock,
+                            getLastHeight: () => genesisBlock.data.height,
+                            cacheTransactions: jest.fn().mockImplementation(txs => ({ notAdded: txs, added: [] })),
+                            removeCachedTransactionIds: jest.fn().mockReturnValue(null),
+                        }),
                     };
                 }
 

__tests__/unit/core-blockchain/mocks/container.ts

@@ -53,7 +53,7 @@ export const container = {
             if (name === "state") {
                 stateStorageStub.blockchain = blockchainMachine.initialState;
 
-                return stateStorageStub;
+                return { getStore: () => stateStorageStub };
             }
 
             return null;

__tests__/unit/core-blockchain/stubs/state-storage.ts

@@ -2,7 +2,7 @@
 import { State } from "@arkecosystem/core-interfaces";
 import { Blocks, Interfaces } from "@arkecosystem/crypto";
 
-export class StateStorageStub implements State.IStateStorage {
+export class StateStoreStub implements State.IStateStore {
     public blockchain: any;
     public lastDownloadedBlock: Interfaces.IBlock | null;
     public blockPing: any;
@@ -76,4 +76,4 @@ export class StateStorageStub implements State.IStateStorage {
     }
 }
 
-export const stateStorageStub = new StateStorageStub();
+export const stateStorageStub = new StateStoreStub();

__tests__/unit/core-database/__fixtures__/state-storage-stub.ts

@@ -2,7 +2,7 @@
 import { State } from "@arkecosystem/core-interfaces";
 import { Blocks, Interfaces } from "@arkecosystem/crypto";
 
-export class StateStorageStub implements State.IStateStorage {
+export class StateStoreStub implements State.IStateStore {
     public blockchain: any;
     public lastDownloadedBlock: Interfaces.IBlock | null;
     public blockPing: any;
@@ -65,4 +65,4 @@ export class StateStorageStub implements State.IStateStorage {
     public setLastBlock(block: Blocks.Block): void {}
 }
 
-export const stateStorageStub = new StateStorageStub();
+export const stateStorageStub = new StateStoreStub();

__tests__/unit/core-database/mocks/core-container.ts

@@ -30,7 +30,7 @@ jest.mock("@arkecosystem/core-container", () => {
                 }
 
                 if (name === "state") {
-                    return stateStorageStub;
+                    return { getStore: () => stateStorageStub };
                 }
 
                 return {};

__tests__/unit/core-p2p/mocks/state.ts

@@ -1,6 +1,8 @@
 import { genesisBlock } from "../../../utils/fixtures/unitnet/block-model";
 
 export const state = {
-    getLastBlock: () => genesisBlock,
-    forkedBlock: null,
+    getStore: () => ({
+        getLastBlock: () => genesisBlock,
+        forkedBlock: null,
+    }),
 };

__tests__/unit/core-p2p/network-monitor.test.ts

@@ -135,13 +135,18 @@ describe("NetworkMonitor", () => {
 
             const spySuspend = jest.spyOn(processor, "suspend");
 
-            state.forkedBlock = { ip: "1.1.1.1" };
+            const spyStateStore = jest.spyOn(state, "getStore").mockReturnValueOnce({
+                ...state.getStore(),
+                ...{ forkedBlock: { ip: "1.1.1.1" } },
+            });
 
             await monitor.refreshPeersAfterFork();
 
             expect(monitor.resetSuspendedPeers).toHaveBeenCalled();
             expect(spySuspend).toHaveBeenCalledWith("1.1.1.1");
             expect(connector.disconnect).toHaveBeenCalled();
+
+            spyStateStore.mockRestore();
         });
     });
 

__tests__/unit/core-state/mocks/container.ts

@@ -17,13 +17,6 @@ export const container = {
                 }),
             };
         },
-        resolve: name => {
-            if (name === "state") {
-                return {};
-            }
-
-            return {};
-        },
         resolvePlugin: name => {
             if (name === "logger") {
                 return logger;

__tests__/unit/core-state/stores/blocks.test.ts

@@ -0,0 +1,43 @@
+import { Blocks, Interfaces, Managers } from "@arkecosystem/crypto";
+import { BlockStore } from "../../../../packages/core-state/src/stores/blocks";
+import { genesisBlock as GB } from "../../../utils/config/testnet/genesisBlock";
+
+Managers.configManager.setFromPreset("testnet");
+
+describe("BlockStore", () => {
+    it("should push and get a block", () => {
+        const genesisBlock: Interfaces.IBlock = Blocks.BlockFactory.fromData(GB);
+
+        const store = new BlockStore(100);
+        store.set(genesisBlock);
+
+        expect(store.count()).toBe(1);
+        expect(store.get(genesisBlock.data.id)).toEqual(genesisBlock.data);
+        expect(store.get(genesisBlock.data.height)).toEqual(genesisBlock.data);
+    });
+
+    it("should fail to push a block if its height is not 1 and there is no last block", () => {
+        const store = new BlockStore(2);
+
+        expect(() => store.set({ data: { height: 3 } } as Interfaces.IBlock)).toThrow();
+    });
+
+    it("should fail to push a block if it isn't chained", () => {
+        const store = new BlockStore(2);
+        store.set({ data: { height: 1 } } as Interfaces.IBlock);
+
+        expect(() => store.set({ data: { height: 3 } } as Interfaces.IBlock)).toThrow();
+    });
+
+    it("should return all ids and heights in the order they were inserted", () => {
+        const store = new BlockStore(4);
+
+        for (let i = 1; i < 5; i++) {
+            store.set({ data: { id: i.toString(), height: i } } as Interfaces.IBlock);
+        }
+
+        expect(store.count()).toBe(4);
+        expect(store.getIds()).toEqual(["1", "2", "3", "4"]);
+        expect(store.getHeights()).toEqual([1, 2, 3, 4]);
+    });
+});

__tests__/unit/core-state/state-storage.test.ts → __tests__/unit/core-state/stores/state.test.ts

@@ -1,21 +1,21 @@
-import "./mocks/";
-import { container } from "./mocks/container";
-import { logger } from "./mocks/logger";
+import "../mocks/";
+import { container } from "../mocks/container";
+import { logger } from "../mocks/logger";
 
 import { Blocks as cBlocks, Interfaces } from "@arkecosystem/crypto";
 import delay from "delay";
-import { defaults } from "../../../packages/core-state/src/defaults";
-import { StateStorage } from "../../../packages/core-state/src/state-storage";
-import "../../utils";
-import { blocks101to155 } from "../../utils/fixtures/testnet/blocks101to155";
-import { blocks2to100 } from "../../utils/fixtures/testnet/blocks2to100";
+import { defaults } from "../../../../packages/core-state/src/defaults";
+import { StateStore } from "../../../../packages/core-state/src/stores/state";
+import "../../../utils";
+import { blocks101to155 } from "../../../utils/fixtures/testnet/blocks101to155";
+import { blocks2to100 } from "../../../utils/fixtures/testnet/blocks2to100";
 
 const { Block, BlockFactory } = cBlocks;
 const blocks = blocks2to100.concat(blocks101to155).map(block => BlockFactory.fromData(block));
 
 let stateStorage;
 beforeAll(async () => {
-    stateStorage = new StateStorage();
+    stateStorage = new StateStore();
 });
 
 beforeEach(() => {

__tests__/unit/core-state/stores/transactions.test.ts

@@ -0,0 +1,14 @@
+import { TransactionStore } from "../../../../packages/core-state/src/stores/transactions";
+import { genesisBlock } from "../../../utils/config/testnet/genesisBlock";
+
+describe("TransactionStore", () => {
+    it("should push and get a transaction", () => {
+        const transaction = genesisBlock.transactions[0];
+
+        const store = new TransactionStore(100);
+        store.push(transaction);
+
+        expect(store.count()).toBe(1);
+        expect(store.get(transaction.id)).toEqual(transaction);
+    });
+});

__tests__/unit/core-transaction-pool/connection.test.ts

@@ -217,7 +217,10 @@ describe("Connection", () => {
             const heightAtStart = 42;
 
             jest.spyOn(container.app, "has").mockReturnValue(true);
-            jest.spyOn(state, "getLastBlock").mockReturnValue({ data: { height: heightAtStart } });
+            jest.spyOn(state, "getStore").mockReturnValue({
+                ...state.getStore(),
+                ...{ getLastHeight: () => heightAtStart },
+            });
 
             expect(connection.getPoolSize()).toBe(0);
 
@@ -247,11 +250,17 @@ describe("Connection", () => {
 
             expect(connection.getPoolSize()).toBe(4);
 
-            jest.spyOn(state, "getLastBlock").mockReturnValue({ data: { height: expiration - 1 } });
+            jest.spyOn(state, "getStore").mockReturnValue({
+                ...state.getStore(),
+                ...{ getLastHeight: () => expiration - 1 },
+            });
 
             expect(connection.getPoolSize()).toBe(4);
 
-            jest.spyOn(state, "getLastBlock").mockReturnValue({ data: { height: expiration } });
+            jest.spyOn(state, "getStore").mockReturnValue({
+                ...state.getStore(),
+                ...{ getLastHeight: () => expiration },
+            });
 
             expect(connection.getPoolSize()).toBe(2);
 

__tests__/unit/core-transaction-pool/mocks/state.ts

@@ -1,5 +1,8 @@
 export const state = {
-    cacheTransactions: () => null,
-    getLastBlock: () => ({ data: { height: 0 } }),
-    removeCachedTransactionIds: () => null,
+    getStore: () => ({
+        cacheTransactions: () => null,
+        getLastBlock: () => ({ data: { height: 0 } }),
+        getLastHeight: () => 1,
+        removeCachedTransactionIds: () => null,
+    }),
 };