refactor(core-p2p): only fetch block headers when verifying peers

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

@@ -59,7 +59,7 @@ export class StateStoreStub implements State.IStateStore {
         return [];
     }
 
-    public getLastBlocksByHeight(start: number, end?: number): Interfaces.IBlockData[] {
+    public getLastBlocksByHeight(start: number, end?: number, headersOnly?: boolean): Interfaces.IBlockData[] {
         return [];
     }
 

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

@@ -57,7 +57,7 @@ export class StateStoreStub implements State.IStateStore {
         return [];
     }
 
-    public getLastBlocksByHeight(start: number, end?: number): Interfaces.IBlockData[] {
+    public getLastBlocksByHeight(start: number, end?: number, headersOnly?: boolean): Interfaces.IBlockData[] {
         return [];
     }
 

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

@@ -160,7 +160,7 @@ describe("NetworkMonitor", () => {
         it("should download blocks in parallel from 25 peers max", async () => {
             communicator.getPeerBlocks = jest
                 .fn()
-                .mockImplementation((peer, afterBlockHeight) => [{ id: `11${afterBlockHeight}` }]);
+                .mockImplementation((peer, { fromBlockHeight }) => [{ id: `11${fromBlockHeight}` }]);
 
             for (let i = 0; i < 30; i++) {
                 storage.setPeer(
@@ -187,7 +187,7 @@ describe("NetworkMonitor", () => {
         it("should download blocks in parallel from all peers if less than 25 peers", async () => {
             communicator.getPeerBlocks = jest
                 .fn()
-                .mockImplementation((peer, afterBlockHeight) => [{ id: `11${afterBlockHeight}` }]);
+                .mockImplementation((peer, { fromBlockHeight }) => [{ id: `11${fromBlockHeight}` }]);
 
             for (let i = 0; i < 18; i++) {
                 storage.setPeer(
@@ -214,7 +214,7 @@ describe("NetworkMonitor", () => {
         it("should download blocks in parallel until median network height and no more", async () => {
             communicator.getPeerBlocks = jest
                 .fn()
-                .mockImplementation((peer, afterBlockHeight) => [{ id: `11${afterBlockHeight}` }]);
+                .mockImplementation((peer, { fromBlockHeight }) => [{ id: `11${fromBlockHeight}` }]);
 
             for (let i = 0; i < 30; i++) {
                 storage.setPeer(
@@ -242,7 +242,7 @@ describe("NetworkMonitor", () => {
             communicator.getPeerBlocks = jest
                 .fn()
                 .mockRejectedValueOnce("peer mock error")
-                .mockImplementation((peer, afterBlockHeight) => [{ id: `11${afterBlockHeight}` }]);
+                .mockImplementation((peer, { fromBlockHeight }) => [{ id: `11${fromBlockHeight}` }]);
 
             for (let i = 0; i < 5; i++) {
                 storage.setPeer(

__tests__/unit/core-p2p/socket-server/versions/peer/index.test.ts

@@ -142,7 +142,7 @@ describe("Peers handler", () => {
         });
     });
 
-    describe("getBlocks", () => {
+    describe.skip("getBlocks", () => {
         // TODO also test with something like {lastBlockHeight: 1}
         it("should return the blocks", async () => {
             const result = await getBlocks({

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

@@ -48,7 +48,7 @@ export class StateStorageStub implements State.IStateStorage {
         return [];
     }
 
-    public getLastBlocksByHeight(start: number, end?: number): Interfaces.IBlockData[] {
+    public getLastBlocksByHeight(start: number, end?: number, headersOnly?: boolean): Interfaces.IBlockData[] {
         return [];
     }
 

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

@@ -2,7 +2,7 @@ import "../mocks/";
 import { container } from "../mocks/container";
 import { logger } from "../mocks/logger";
 
-import { Blocks as cBlocks, Interfaces } from "@arkecosystem/crypto";
+import { Blocks as cBlocks, Interfaces, Managers } from "@arkecosystem/crypto";
 import delay from "delay";
 import { defaults } from "../../../../packages/core-state/src/defaults";
 import { StateStore } from "../../../../packages/core-state/src/stores/state";
@@ -165,6 +165,22 @@ describe("State Storage", () => {
             expect(lastBlocksByHeight).toHaveLength(1);
             expect(lastBlocksByHeight[0].height).toBe(50);
         });
+
+        it("should return full blocks and block headers", () => {
+            const block = BlockFactory.fromJson(Managers.configManager.get("genesisBlock"));
+
+            stateStorage.setLastBlock(block);
+
+            let lastBlocksByHeight = stateStorage.getLastBlocksByHeight(1, 1, true);
+            expect(lastBlocksByHeight).toHaveLength(1);
+            expect(lastBlocksByHeight[0].height).toBe(1);
+            expect(lastBlocksByHeight[0].transactions).toBeUndefined();
+
+            lastBlocksByHeight = stateStorage.getLastBlocksByHeight(1, 1);
+            expect(lastBlocksByHeight).toHaveLength(1);
+            expect(lastBlocksByHeight[0].height).toBe(1);
+            expect(lastBlocksByHeight[0].transactions).not.toBeEmpty();
+        });
     });
 
     describe("getCommonBlocks", () => {

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

@@ -215,20 +215,22 @@ export class DatabaseService implements Database.IDatabaseService {
         return Blocks.BlockFactory.fromData(block);
     }
 
-    public async getBlocks(offset: number, limit: number): Promise<Interfaces.IBlockData[]> {
+    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 blocks: Interfaces.IBlockData[] = app
             .resolvePlugin<State.IStateService>("state")
             .getStore()
-            .getLastBlocksByHeight(start, end);
+            .getLastBlocksByHeight(start, end, headersOnly);
 
         if (blocks.length !== limit) {
             blocks = await this.connection.blocksRepository.heightRange(start, end);
 
-            await this.loadTransactionsForBlocks(blocks);
+            if (!headersOnly) {
+                await this.loadTransactionsForBlocks(blocks);
+            }
         }
 
         return blocks;
@@ -266,7 +268,7 @@ export class DatabaseService implements Database.IDatabaseService {
             const stateBlocks = app
                 .resolvePlugin<State.IStateService>("state")
                 .getStore()
-                .getLastBlocksByHeight(height, height);
+                .getLastBlocksByHeight(height, height, true);
 
             if (Array.isArray(stateBlocks) && stateBlocks.length > 0) {
                 blocks[i] = stateBlocks[0];

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

@@ -55,7 +55,7 @@ export interface IDatabaseService {
 
     getLastBlock(): Promise<Interfaces.IBlock>;
 
-    getBlocks(offset: number, limit: number): Promise<Interfaces.IBlockData[]>;
+    getBlocks(offset: number, limit: number, headersOnly?: boolean): Promise<Interfaces.IBlockData[]>;
 
     /**
      * Get the blocks at the given heights.

packages/core-interfaces/src/core-p2p/peer-communicator.ts

@@ -7,6 +7,14 @@ export interface IPeerCommunicator {
     postBlock(peer: IPeer, block: Interfaces.IBlockJson);
     postTransactions(peer: IPeer, transactions: Interfaces.ITransactionJson[]): Promise<any>;
     getPeers(peer: IPeer): Promise<any>;
-    getPeerBlocks(peer: IPeer, afterBlockHeight: number, timeoutMsec?: number): Promise<any>;
+    getPeerBlocks(
+        peer: IPeer,
+        {
+            fromBlockHeight,
+            blockLimit,
+            timeoutMsec,
+            headersOnly,
+        }: { fromBlockHeight: number; blockLimit?: number; timeoutMsec?: number; headersOnly?: boolean },
+    ): Promise<any>;
     hasCommonBlocks(peer: IPeer, ids: string[], timeoutMsec?: number): Promise<any>;
 }

packages/core-interfaces/src/core-state/state-store.ts

@@ -68,7 +68,7 @@ export interface IStateStore {
      * @param {Number} start
      * @param {Number} end
      */
-    getLastBlocksByHeight(start: number, end?: number): Interfaces.IBlockData[];
+    getLastBlocksByHeight(start: number, end?: number, headersOnly?: boolean): Interfaces.IBlockData[];
 
     /**
      * Get common blocks for the given IDs.

packages/core-p2p/src/network-monitor.ts

@@ -131,8 +131,8 @@ export class NetworkMonitor implements P2P.INetworkMonitor {
         const pingDelay = fast ? 1500 : app.resolveOptions("p2p").globalTimeout;
 
         if (peerCount) {
-            max = peerCount;
             peers = shuffle(peers).slice(0, peerCount);
+            max = Math.min(peers.length, peerCount);
         }
 
         this.logger.info(`Checking ${max} peers`);

packages/core-p2p/src/peer-communicator.ts

@@ -22,7 +22,7 @@ export class PeerCommunicator implements P2P.IPeerCommunicator {
         try {
             this.logger.debug(`Downloading blocks from height ${fromBlockHeight.toLocaleString()} via ${peer.ip}`);
 
-            return await this.getPeerBlocks(peer, fromBlockHeight);
+            return await this.getPeerBlocks(peer, { fromBlockHeight });
         } catch (error) {
             this.logger.error(`Could not download blocks from ${peer.url}: ${error.message}`);
 
@@ -134,11 +134,17 @@ export class PeerCommunicator implements P2P.IPeerCommunicator {
 
     public async getPeerBlocks(
         peer: P2P.IPeer,
-        afterBlockHeight: number,
-        timeoutMsec?: number,
+        {
+            fromBlockHeight,
+            blockLimit,
+            timeoutMsec,
+            headersOnly,
+        }: { fromBlockHeight: number; blockLimit?: number; timeoutMsec?: number; headersOnly?: boolean },
     ): Promise<Interfaces.IBlockData[]> {
         return this.emit(peer, "p2p.peer.getBlocks", {
-            lastBlockHeight: afterBlockHeight,
+            lastBlockHeight: fromBlockHeight,
+            blockLimit,
+            headersOnly,
             headers: {
                 "Content-Type": "application/json",
             },

packages/core-p2p/src/peer-verifier.ts

@@ -344,7 +344,14 @@ export class PeerVerifier {
 
         for (let height = startHeight; height <= endHeight; height++) {
             if (hisBlocksByHeight[height] === undefined) {
-                if (!(await this.fetchBlocksFromHeight(height, hisBlocksByHeight, deadline))) {
+                if (
+                    !(await this.fetchBlocksFromHeight({
+                        height,
+                        endHeight,
+                        blocksByHeight: hisBlocksByHeight,
+                        deadline,
+                    }))
+                ) {
                     return false;
                 }
             }
@@ -398,14 +405,28 @@ export class PeerVerifier {
      * @return {Boolean} true if fetched successfully
      * @throws {Error} if the state verification could not complete before the deadline
      */
-    private async fetchBlocksFromHeight(height: number, blocksByHeight: object, deadline: number): Promise<boolean> {
+    private async fetchBlocksFromHeight({
+        height,
+        endHeight,
+        blocksByHeight,
+        deadline,
+    }: {
+        height: number;
+        endHeight: number;
+        blocksByHeight: object;
+        deadline: number;
+    }): Promise<boolean> {
         let response;
 
         try {
             this.throwIfPastDeadline(deadline);
 
             // returns blocks from the next one, thus we do -1
-            response = await this.communicator.getPeerBlocks(this.peer, height - 1);
+            response = await this.communicator.getPeerBlocks(this.peer, {
+                fromBlockHeight: height - 1,
+                blockLimit: endHeight - height,
+                headersOnly: true,
+            });
         } catch (err) {
             this.log(
                 Severity.DEBUG_EXTRA,
@@ -453,8 +474,7 @@ export class PeerVerifier {
         }
 
         const block = Blocks.BlockFactory.fromData(blockData);
-
-        if (!block.verification.verified) {
+        if (!block.verifySignature()) {
             this.log(
                 Severity.DEBUG_EXTRA,
                 `failure: peer's block at height ${expectedHeight} does not pass crypto-validation`,

packages/core-p2p/src/schemas.ts

@@ -10,6 +10,16 @@ export const requestSchemas = {
                 ids: { type: "array", additionalItems: false, minItems: 1, items: { blockId: {} } },
             },
         },
+        getBlocks: {
+            type: "object",
+            required: ["lastBlockHeight"],
+            additionalProperties: false,
+            properties: {
+                lastBlockHeight: { type: "integer", minimum: 1 },
+                blockLimit: { type: "integer", minimum: 1, maximum: 400 },
+                headersOnly: { type: "boolean" },
+            },
+        },
         postBlock: {
             type: "object",
             required: ["block"],

packages/core-p2p/src/socket-server/versions/peer.ts

@@ -104,20 +104,12 @@ export const postTransactions = async ({ service, req }: { service: P2P.IPeerSer
 
 export const getBlocks = async ({ req }): Promise<Interfaces.IBlockData[]> => {
     const database: Database.IDatabaseService = app.resolvePlugin<Database.IDatabaseService>("database");
-    const blockchain: Blockchain.IBlockchain = app.resolvePlugin<Blockchain.IBlockchain>("blockchain");
 
     const reqBlockHeight: number = +req.data.lastBlockHeight + 1;
-    let blocks: Interfaces.IBlockData[] = [];
-
-    if (!req.data.lastBlockHeight || isNaN(reqBlockHeight)) {
-        const lastBlock: Interfaces.IBlock = blockchain.getLastBlock();
+    const reqBlockLimit: number = +req.data.blockLimit || 400;
+    const reqHeadersOnly: boolean = !!req.data.headersOnly;
 
-        if (lastBlock) {
-            blocks.push(lastBlock.data);
-        }
-    } else {
-        blocks = await database.getBlocks(reqBlockHeight, 400);
-    }
+    const blocks: Interfaces.IBlockData[] = await database.getBlocks(reqBlockHeight, reqBlockLimit, reqHeadersOnly);
 
     app.resolvePlugin<Logger.ILogger>("logger").info(
         `${mapAddr(req.headers.remoteAddress)} has downloaded ${pluralize(

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

@@ -123,8 +123,8 @@ export class StateStore implements State.IStateStore {
     /**
      * Get the last blocks data.
      */
-    public getLastBlocksData(): Seq<number, Interfaces.IBlockData> {
-        return this.mapToBlockData(this.lastBlocks.valueSeq().reverse());
+    public getLastBlocksData(headersOnly?: boolean): Seq<number, Interfaces.IBlockData> {
+        return this.mapToBlockData(this.lastBlocks.valueSeq().reverse(), headersOnly);
     }
 
     /**
@@ -143,14 +143,14 @@ export class StateStore implements State.IStateStore {
      * @param {Number} start
      * @param {Number} end
      */
-    public getLastBlocksByHeight(start: number, end?: number): Interfaces.IBlockData[] {
+    public getLastBlocksByHeight(start: number, end?: number, headersOnly?: boolean): Interfaces.IBlockData[] {
         end = end || start;
 
         const blocks = this.lastBlocks
             .valueSeq()
             .filter(block => block.data.height >= start && block.data.height <= end);
 
-        return this.mapToBlockData(blocks).toArray() as Interfaces.IBlockData[];
+        return this.mapToBlockData(blocks, headersOnly).toArray() as Interfaces.IBlockData[];
     }
 
     /**
@@ -163,7 +163,7 @@ export class StateStore implements State.IStateStore {
             idsHash[id] = true;
         }
 
-        return this.getLastBlocksData()
+        return this.getLastBlocksData(true)
             .filter(block => idsHash[block.id])
             .toArray() as Interfaces.IBlockData[];
     }
@@ -249,7 +249,13 @@ export class StateStore implements State.IStateStore {
     }
 
     // Map Block instances to block data.
-    private mapToBlockData(blocks: Seq<number, Interfaces.IBlock>): Seq<number, Interfaces.IBlockData> {
-        return blocks.map(block => ({ ...block.data, transactions: block.transactions.map(tx => tx.data) }));
+    private mapToBlockData(
+        blocks: Seq<number, Interfaces.IBlock>,
+        headersOnly?: boolean,
+    ): Seq<number, Interfaces.IBlockData> {
+        return blocks.map(block => ({
+            ...block.data,
+            transactions: headersOnly ? undefined : block.transactions.map(tx => tx.data),
+        }));
     }
 }