fix(core-database): revertBlock (#3948)

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

@@ -61,6 +61,7 @@ describe("Blockchain", () => {
         logService.debug = jest.fn();
 
         stateStore.started = false;
+        stateStore.getMaxLastBlocks = jest.fn().mockReturnValue(200);
         stateStore.clearWakeUpTimeout = jest.fn();
         stateStore.wakeUpTimeout = undefined;
         stateStore.lastDownloadedBlock = undefined;
@@ -379,7 +380,7 @@ describe("Blockchain", () => {
                 const spyDispatch = jest.spyOn(blockchain, "dispatch");
                 stateStore.started = true;
                 stateStore.getLastBlock = jest.fn().mockReturnValue({ data: blockData });
-                
+
                 jest.spyOn(Crypto.Slots, "getSlotNumber").mockReturnValueOnce(1).mockReturnValueOnce(2);
                 jest.spyOn(Crypto.Slots, "getTimeInMsUntilNextSlot").mockReturnValueOnce(5000);
 
@@ -500,15 +501,15 @@ describe("Blockchain", () => {
             expect(spyQueuePush).toHaveBeenCalledWith({ blocks: [blockData] });
         });
 
-        it("should push a chunk to the queue when currentBlocksChunk.length > 100", async () => {
+        it("should push a chunk to the queue when currentBlocksChunk.length >= 100", async () => {
             const blockchain = sandbox.app.resolve<Blockchain>(Blockchain);
             blockchain.initialize({});
             stateStore.lastDownloadedBlock = { height: 23111 };
 
             const spyQueuePush = jest.spyOn(blockchain.queue, "push");
 
             const blocksToEnqueue = [];
-            for (let i = 0; i <= 101; i++) {
+            for (let i = 0; i < 101; i++) {
                 // @ts-ignore
                 blocksToEnqueue.push(blockData);
             }

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

@@ -666,12 +666,12 @@ describe("DatabaseService.getBlocks", () => {
         const block102 = { height: 102, transactions: [] };
 
         stateStore.getLastBlocksByHeight.mockReturnValueOnce([block101, block102]);
-        blockRepository.findByHeightRangeWithTransactions.mockResolvedValueOnce([block100, block101, block102]);
+        blockRepository.findByHeightRangeWithTransactions.mockResolvedValueOnce([block100]);
 
         const result = await databaseService.getBlocks(100, 3);
 
         expect(stateStore.getLastBlocksByHeight).toBeCalledWith(100, 102, undefined);
-        expect(blockRepository.findByHeightRangeWithTransactions).toBeCalledWith(100, 102);
+        expect(blockRepository.findByHeightRangeWithTransactions).toBeCalledWith(100, 100);
         expect(result).toEqual([block100, block101, block102]);
     });
 
@@ -683,12 +683,12 @@ describe("DatabaseService.getBlocks", () => {
         const block102 = { height: 102 };
 
         stateStore.getLastBlocksByHeight.mockReturnValueOnce([block101, block102]);
-        blockRepository.findByHeightRange.mockResolvedValueOnce([block100, block101, block102]);
+        blockRepository.findByHeightRange.mockResolvedValueOnce([block100]);
 
         const result = await databaseService.getBlocks(100, 3, true);
 
         expect(stateStore.getLastBlocksByHeight).toBeCalledWith(100, 102, true);
-        expect(blockRepository.findByHeightRange).toBeCalledWith(100, 102);
+        expect(blockRepository.findByHeightRange).toBeCalledWith(100, 100);
         expect(result).toEqual([block100, block101, block102]);
     });
 });

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

@@ -31,6 +31,12 @@ beforeEach(() => {
 afterAll(() => jest.clearAllMocks());
 
 describe("State Storage", () => {
+    describe("getMaxLastBlocks", () => {
+        it("should return max last blocks limit", () => {
+            expect(stateStorage.getMaxLastBlocks()).toBe(100);
+        });
+    });
+
     describe("getLastHeight", () => {
         it("should return the last block height", () => {
             stateStorage.setLastBlock(blocks[0]);

packages/core-blockchain/src/blockchain.ts

@@ -246,7 +246,8 @@ export class Blockchain implements Contracts.Blockchain.Blockchain {
             currentTransactionsCount += block.numberOfTransactions;
 
             const nextMilestone = milestoneHeights[0] && milestoneHeights[0] === block.height;
-            if (currentTransactionsCount >= 150 || currentBlocksChunk.length > 100 || nextMilestone) {
+
+            if (currentTransactionsCount >= 150 || currentBlocksChunk.length >= Math.min(this.state.getMaxLastBlocks(), 100) || nextMilestone) {
                 this.queue.push({ blocks: currentBlocksChunk });
                 currentBlocksChunk = [];
                 currentTransactionsCount = 0;

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

@@ -266,16 +266,23 @@ export class DatabaseService {
     public async getBlocks(offset: number, limit: number, headersOnly?: boolean): Promise<Interfaces.IBlockData[]> {
         // The functions below return matches in the range [start, end], including both ends.
         const start: number = offset;
-        const end: number = offset + limit - 1;
+        let end: number = offset + limit - 1;
 
         let blocks: Interfaces.IBlockData[] = this.stateStore.getLastBlocksByHeight(start, end, headersOnly);
 
         if (blocks.length !== limit) {
             // ! assumes that earlier blocks may be missing
             // ! but querying database is unnecessary when later blocks are missing too (aren't forged yet)
-            blocks = headersOnly
+
+            if (blocks.length) {
+                end = blocks[0].height - 1;
+            }
+
+            const blocksFromDB = headersOnly
                 ? await this.blockRepository.findByHeightRange(start, end)
                 : await this.blockRepository.findByHeightRangeWithTransactions(start, end);
+
+            blocks = [...blocksFromDB, ...blocks];
         }
 
         return blocks;

packages/core-kernel/src/contracts/state/state-store.ts

@@ -24,6 +24,11 @@ export interface StateStore {
      */
     clearWakeUpTimeout(): void;
 
+    /**
+     * Get block storage limit.
+     */
+    getMaxLastBlocks(): number;
+
     /**
      * Get the last block height.
      */

packages/core-state/src/stores/state.ts

@@ -34,7 +34,7 @@ export class StateStore implements Contracts.State.StateStore {
     // can be configured with the option `state.maxLastBlocks`.
     private lastBlocks: OrderedMap<number, Interfaces.IBlock> = OrderedMap<number, Interfaces.IBlock>();
     // Stores the last n incoming transaction ids. The amount of transaction ids
-    // can be configred with the option `state.maxLastTransactionIds`.
+    // can be configured with the option `state.maxLastTransactionIds`.
     private cachedTransactionIds: OrderedSet<string> = OrderedSet();
 
     /**
@@ -63,6 +63,10 @@ export class StateStore implements Contracts.State.StateStore {
         }
     }
 
+    public getMaxLastBlocks(): number {
+        return this.configuration.getRequired<number>("storage.maxLastBlocks");
+    }
+
     /**
      * Get the last block height.
      */
@@ -119,9 +123,7 @@ export class StateStore implements Contracts.State.StateStore {
         }
 
         // Delete oldest block if size exceeds the maximum
-        const maxLastBlocks = this.configuration.getRequired<number>("storage.maxLastBlocks");
-
-        if (this.lastBlocks.size > maxLastBlocks) {
+        if (this.lastBlocks.size > this.getMaxLastBlocks()) {
             this.lastBlocks = this.lastBlocks.delete(this.lastBlocks.first<Interfaces.IBlock>().data.height);
         }
 

packages/core-transactions/src/handlers/two/ipfs.ts

@@ -97,6 +97,8 @@ export class IpfsTransactionHandler extends TransactionHandler {
             sender.forgetAttribute("ipfs");
         }
 
+        this.walletRepository.getIndex(Contracts.State.WalletIndexes.Ipfs).forget(transaction.data.asset.ipfs);
+
         this.walletRepository.index(sender);
     }