Add test cases for double proposal

Author: Joonmo Yang

test/src/e2e.dynval/doubleVote.test.ts

@@ -52,6 +52,28 @@ describe("Double vote detection", function() {
         mock = new Mock("0.0.0.0", aliceNode.port, aliceNode.sdk.networkId);
     });
 
+    it("Should report if double proposal is detected", async function() {
+        const termWaiter = setTermTestTimeout(this, { terms: 1 });
+
+        const aliceNode = nodes[0];
+
+        // Start sending double votes for all the votes
+        await mock.establishWithoutSync();
+        mock.startDoubleProposal(betty.privateKey);
+        await termWaiter.waitForTermPeriods(0.5, 0);
+
+        // Stop double voting and check if alice is banned
+        mock.stopDoubleProposal();
+        await termWaiter.waitNodeUntilTerm(aliceNode, {
+            target: 2,
+            termPeriods: 1
+        });
+        const banned = await stake.getBanned(aliceNode.sdk);
+        expect(banned.map(b => b.toString())).to.include(
+            betty.platformAddress.toString()
+        );
+    });
+
     it("Should report if double vote for prevote is detected", async function() {
         const termWaiter = setTermTestTimeout(this, { terms: 1 });
 

test/src/helper/mock/index.ts

@@ -16,10 +16,18 @@
 import { blake256, getPublicFromPrivate, H160, H256, recoverSchnorr, SchnorrSignature, signSchnorr, U256, U64 } from "codechain-primitives";
 import { SignedTransaction } from "codechain-sdk/lib/core/SignedTransaction";
 import * as RLP from "rlp";
+import { readUIntRLP } from "../rlp";
 import { BlockSyncMessage, Emitter, IBodiesq, IHeadersq, MessageType, ResponseMessage } from "./blockSyncMessage";
 import { Header } from "./cHeader";
 import { P2pLayer } from "./p2pLayer";
-import { ConsensusMessage, Emitter as TendermintEmitter, Step as TendermintStep, StepState, TendermintMessage } from "./tendermintMessage";
+import {
+    ConsensusMessage,
+    Emitter as TendermintEmitter,
+    ProposalBlock,
+    Step as TendermintStep,
+    StepState,
+    TendermintMessage
+} from "./tendermintMessage";
 import { TransactionSyncMessage } from "./transactionSyncMessage";
 
 
@@ -438,6 +446,74 @@ export class Mock {
         TendermintEmitter.removeAllListeners("stepstate");
     }
 
+    public startDoubleProposal(priv: string) {
+        const pub = getPublicFromPrivate(priv);
+        TendermintEmitter.on("proposalblock", (message: ProposalBlock) => {
+            const digest = (on: ConsensusMessage["messages"][number]["on"]) =>
+                blake256(
+                    RLP.encode([
+                        [
+                            new U64(on.step.height).toEncodeObject(),
+                            new U64(on.step.view).toEncodeObject(),
+                            new U64(on.step.step).toEncodeObject(),
+                        ],
+                        on.blockHash == null ? [] : [on.blockHash.toEncodeObject()],
+                    ])
+                );
+
+            const signature: SchnorrSignature = {
+                r: message.signature.slice(0, 64),
+                s: message.signature.slice(64),
+            };
+
+            const block: any = RLP.decode(message.message);
+            const oldOn: Parameters<typeof digest>[0] = {
+                step: {
+                    height: readUIntRLP(block[0][5]),
+                    view: message.view,
+                    step: TendermintStep.Propose,
+                },
+                blockHash: new H256(blake256(RLP.encode(block[0]))),
+            };
+            const recovered = recoverSchnorr(digest(oldOn), signature);
+            if (recovered === pub) {
+                const newHeader = [
+                    ...block[0].slice(0, 6),
+                    new U64(readUIntRLP(block[0][6]) + 1).toEncodeObject(), // timestamp
+                    ...block[0].slice(7),
+                ];
+                const newDigest = digest({
+                    ...oldOn,
+                    blockHash: new H256(blake256(RLP.encode(newHeader))),
+                });
+                const newSignature = signSchnorr(newDigest, priv);
+
+                this.sendTendermintMessage(new TendermintMessage({
+                    type: "proposalblock",
+                    view: message.view,
+                    message: RLP.encode([newHeader, block[1]]),
+                    signature: newSignature.r + newSignature.s,
+                }));
+            }
+        });
+        TendermintEmitter.on("stepstate", (message: StepState) => {
+            if (message.voteStep.step === TendermintStep.Propose) {
+                setTimeout(() => {
+                    this.sendTendermintMessage(new TendermintMessage({
+                        type: "requestproposal",
+                        height: message.voteStep.height,
+                        view: message.voteStep.view,
+                    }));
+                }, 200)
+            }
+        });
+    }
+
+    public stopDoubleProposal() {
+        TendermintEmitter.removeAllListeners("proposalblock");
+        TendermintEmitter.removeAllListeners("stepstate");
+    }
+
     private async waitForBlockSyncMessage(type: MessageType): Promise<{}> {
         return new Promise((resolve, reject) => {
             switch (type) {

test/src/helper/mock/tendermintMessage.ts

@@ -17,6 +17,8 @@ import { H256, U64 } from "codechain-primitives";
 import { EventEmitter } from "events";
 import { compressSync, uncompressSync } from "snappy";
 
+import { readOptionalRlp, readUIntRLP } from "../rlp";
+
 const RLP = require("rlp");
 
 export const Emitter = new EventEmitter();
@@ -83,22 +85,6 @@ export interface RequestProposal {
 
 type MessageBody = ConsensusMessage | ProposalBlock | StepState | RequestMessage | RequestProposal;
 
-function readOptionalRlp<T>(bytes: [] | [Buffer], decoder: (b: Buffer) => T) {
-    if (bytes.length === 0) {
-        return null;
-    } else {
-        return decoder(bytes[0]);
-    }
-}
-
-function readUIntRLP(bytes: Buffer) {
-    if (bytes.length === 0) {
-        return 0;
-    } else {
-        return bytes.readUIntBE(0, bytes.length);
-    }
-}
-
 export class TendermintMessage {
 
     public static fromBytes(bytes: Buffer): TendermintMessage {

test/src/helper/rlp.ts

@@ -0,0 +1,18 @@
+export function readOptionalRlp<T>(
+    bytes: [] | [Buffer],
+    decoder: (b: Buffer) => T
+) {
+    if (bytes.length === 0) {
+        return null;
+    } else {
+        return decoder(bytes[0]);
+    }
+}
+
+export function readUIntRLP(bytes: Buffer) {
+    if (bytes.length === 0) {
+        return 0;
+    } else {
+        return bytes.readUIntBE(0, bytes.length);
+    }
+}