Merge pull request #577 from NodeFactoryIo/develop

Metrics and multiclient

Author: mpetrunic

.env.dist

@@ -3,4 +3,8 @@ SENTRY_DSN=https://[email protected]/yyyyyyy
 SENTRY_ORG=nodefactory
 SENTRY_PROJECT=chainguardian
 SENTRY_AUTH_TOKEN=xxx
-DOCKER_LIGHTHOUSE_IMAGE=sigp/lighthouse:v1.1.1
+DOCKER_LIGHTHOUSE_IMAGE=sigp/lighthouse:v1.3.0
+DOCKER_TEKU_IMAGE=consensys/teku:21.5
+DOCKER_PRYSM_IMAGE=gcr.io/prysmaticlabs/prysm/beacon-chain:v1.4.2
+DOCKER_PRYSM_VALIDATOR_IMAGE=gcr.io/prysmaticlabs/prysm/validator:v1.4.2
+DOCKER_NIMBUS_IMAGE=statusim/nimbus-eth2:amd64-v1.4.0

.gitignore

@@ -9,6 +9,5 @@ coverage
 *.log
 package-lock.json
 *.db
-/eth2_testnet/genesis.ssz
 .tmp
 *.sqlite*

testnet/lighthouse/data/validators/0xaec922bd7a9b7b1dc21993133b586b0c3041c1e2e04b513e862227b9d7aecaf9444222f7e78282a449622ffc6278915d/voting-keystore.json renamed to integration/lighthouse-keystore.json

@@ -1 +1 @@
-{"crypto":{"kdf":{"function":"scrypt","params":{"dklen":32,"n":2,"r":8,"p":1,"salt":"0101010101010101010101010101010101010101010101010101010101010101"},"message":""},"checksum":{"function":"sha256","params":{},"message":"49d259b9bb69eb767a2600f8e47847f53a9fa7aac7831dd0484deebad23460a1"},"cipher":{"function":"aes-128-ctr","params":{"iv":"073025af5ec5337d071f51908da1fcae"},"message":"604e18583806140b5ee3926d3aefa0d7b018a2dc37d0b02d32318228f8b03dd3"}},"uuid":"de9d7b36-83f1-4cc4-a0c7-6ab207a84619","path":"","pubkey":"aec922bd7a9b7b1dc21993133b586b0c3041c1e2e04b513e862227b9d7aecaf9444222f7e78282a449622ffc6278915d","version":4,"description":"","name":null}
+{"crypto":{"kdf":{"function":"scrypt","params":{"dklen":32,"n":2,"r":8,"p":1,"salt":"0101010101010101010101010101010101010101010101010101010101010101"},"message":""},"checksum":{"function":"sha256","params":{},"message":"41bfec3aaf2f15424f8e5171c789a55e5a12148c250bdee8fcaa798a0ceda2ba"},"cipher":{"function":"aes-128-ctr","params":{"iv":"90791e5760637b9c60944ad159f65c3f"},"message":"7769a7d09b77bf8991e1c0dc0d1aa20f742fbe1520e12a7eee8d08d12f494cb1"}},"uuid":"2bcc4bc3-cbc6-49f4-ab86-ad8bc84f78bb","path":"","pubkey":"aec922bd7a9b7b1dc21993133b586b0c3041c1e2e04b513e862227b9d7aecaf9444222f7e78282a449622ffc6278915d","version":4,"description":"","name":null}

integration/lighthouse.ts

@@ -0,0 +1,38 @@
+import {SecretKey} from "@chainsafe/bls";
+import {Keystore} from "@chainsafe/bls-keystore";
+import {config} from "@chainsafe/lodestar-config/lib/presets/mainnet";
+import assert from "assert";
+
+import {restValidation} from "./restValidation";
+import keystore from "./lighthouse-keystore.json";
+import {CgLighthouseEth2Api} from "../src/renderer/services/eth2/client/module";
+const keystorePassword = "222222222222222222222222222222222222222222222222222";
+
+(async function (): Promise<void> {
+    const {proposer, attestation} = await restValidation({
+        baseUrl: "http://localhost:5052",
+        getValidatorPrivateKey: async () =>
+            SecretKey.fromBytes(await Keystore.fromObject(keystore).decrypt(keystorePassword)),
+        limit: 2,
+        config,
+        ApiClient: CgLighthouseEth2Api,
+    });
+
+    console.log("\n\n\n");
+    let isFailed = false;
+    try {
+        assert.equal(proposer.proposed, proposer.delegated);
+        console.info(`Successfully proposed all ${proposer.delegated} blocks`);
+    } catch (e) {
+        console.error("Proposals", e.message);
+        isFailed = true;
+    }
+    try {
+        assert.equal(attestation.attestations, attestation.delegated);
+        console.info(`Successfully provide all ${proposer.delegated} attestations`);
+    } catch (e) {
+        console.error("Attestations", e.message);
+        isFailed = true;
+    }
+    process.exit(Number(isFailed));
+})();

integration/nimbus-keystore.json

@@ -0,0 +1 @@
+{"crypto":{"kdf":{"function":"pbkdf2","params":{"dklen":32,"c":262144,"prf":"hmac-sha256","salt":"394aa7bf7b8543bec9328678fabbb82b1d88b651a1629992c596011c87035ee0"},"message":""},"checksum":{"function":"sha256","params":{},"message":"4e1093d856e9cfa77b2ef37e49d96e248aa2b88be51c542a1a5c295f97eb30c2"},"cipher":{"function":"aes-128-ctr","params":{"iv":"8fa9958ef656695f12e3999d869d291e"},"message":"5869a4b6f5bab27676d6212737afbdedf5823ecb522ea88a72322c50a2f4c392"}},"description":"","pubkey":"8309a5281dd43297a3eccc1e70553831ec4dbf6a0b5b38fc910b49fb4eecf37075c90269443fd5fc6b8cad701e3eec53","path":"m/12381/3600/29/0/0","uuid":"97ee5497-09d8-489b-af81-e060358f5d5c","version":4}

integration/nimbus.ts

@@ -0,0 +1,38 @@
+import assert from "assert";
+import {restValidation} from "./restValidation";
+import {config} from "@chainsafe/lodestar-config/lib/presets/mainnet";
+import {CgNimbusEth2Api} from "../src/renderer/services/eth2/client/module";
+import {SecretKey} from "@chainsafe/bls";
+import {Keystore} from "@chainsafe/bls-keystore";
+
+import keystore from "./nimbus-keystore.json";
+const keystorePassword = "4E015C5AF6C9610B0230DBC4FD9714B786F24A28414E49C52D85950E1ED23AD8";
+
+(async function (): Promise<void> {
+    const {proposer, attestation} = await restValidation({
+        baseUrl: "http://localhost:5052",
+        getValidatorPrivateKey: async () =>
+            SecretKey.fromBytes(await Keystore.fromObject(keystore).decrypt(keystorePassword)),
+        limit: 5,
+        config,
+        ApiClient: CgNimbusEth2Api,
+    });
+
+    console.log("\n\n\n");
+    let isFailed = false;
+    try {
+        assert.equal(proposer.proposed, proposer.delegated);
+        console.info(`Successfully proposed all ${proposer.delegated} blocks`);
+    } catch (e) {
+        console.error("Proposals", e.message);
+        isFailed = true;
+    }
+    try {
+        assert.equal(attestation.attestations, attestation.delegated);
+        console.info(`Successfully provide all ${proposer.delegated} attestations`);
+    } catch (e) {
+        console.error("Attestations", e.message);
+        isFailed = true;
+    }
+    process.exit(Number(isFailed));
+})();

integration/prysm.ts

@@ -0,0 +1,33 @@
+import {getInteropKey} from "../src/renderer/services/validator/interop_keys";
+import assert from "assert";
+import {restValidation} from "./restValidation";
+import {config} from "@chainsafe/lodestar-config/lib/presets/mainnet";
+import {CgPrysmEth2Api} from "../src/renderer/services/eth2/client/module";
+
+(async function (): Promise<void> {
+    const {proposer, attestation} = await restValidation({
+        baseUrl: "http://localhost:5050",
+        getValidatorPrivateKey: async () => getInteropKey(15),
+        limit: 2,
+        config,
+        ApiClient: CgPrysmEth2Api,
+    });
+
+    console.log("\n\n\n");
+    let isFailed = false;
+    try {
+        assert.equal(proposer.proposed, proposer.delegated);
+        console.info(`Successfully proposed all ${proposer.delegated} blocks`);
+    } catch (e) {
+        console.error("Proposals", e.message);
+        isFailed = true;
+    }
+    try {
+        assert.equal(attestation.attestations, attestation.delegated);
+        console.info(`Successfully provide all ${proposer.delegated} attestations`);
+    } catch (e) {
+        console.error("Attestations", e.message);
+        isFailed = true;
+    }
+    process.exit(Number(isFailed));
+})();

integration/restValidation.ts

@@ -0,0 +1,207 @@
+import {init as initBLS, SecretKey} from "@chainsafe/bls";
+import {LogLevel, WinstonLogger} from "@chainsafe/lodestar-utils";
+import {Validator} from "@chainsafe/lodestar-validator";
+import {CGSlashingProtection} from "../src/renderer/services/eth2/client/slashingProtection";
+import sinon from "sinon";
+import {computeEpochAtSlot} from "@chainsafe/lodestar-beacon-state-transition";
+import {BeaconCommitteeResponse, BLSPubkey, ProposerDuty} from "@chainsafe/lodestar-types";
+import {AttestationEvent, CGBeaconEventType, ICgEth2ApiClient} from "../src/renderer/services/eth2/client/interface";
+import {BeaconBlockEvent, BeaconEventType} from "@chainsafe/lodestar-validator/lib/api/interface/events";
+import {IBeaconConfig} from "@chainsafe/lodestar-config";
+import {CgEth2ApiClient} from "../src/renderer/services/eth2/client/module";
+
+const getCommitteesFactory = (apiClient: ICgEth2ApiClient) => async (
+    validatorIndex: number,
+    blockSlot: number,
+    ignoreBefore?: number,
+): Promise<BeaconCommitteeResponse[]> => {
+    const response = await apiClient.beacon.state.getCommittees(blockSlot);
+    return response.filter(({validators, slot}: BeaconCommitteeResponse) =>
+        [...validators].some(
+            (index) => index === validatorIndex && (slot > ignoreBefore || ignoreBefore === undefined),
+        ),
+    );
+};
+
+const getProposerFactory = (apiClient: ICgEth2ApiClient) => async (
+    pubKey: BLSPubkey,
+    epoch: number,
+    index: number,
+    ignoreBefore?: number,
+): Promise<ProposerDuty[]> => {
+    const result = await apiClient.validator.getProposerDuties(epoch, [pubKey]);
+    return [...result].filter(
+        ({validatorIndex, slot}) => validatorIndex === index && (slot > ignoreBefore || ignoreBefore === undefined),
+    );
+};
+
+const processAttestation = (
+    {data}: AttestationEvent["message"],
+    committees: BeaconCommitteeResponse[],
+    attestations: Map<number, boolean>,
+): void => {
+    const committee = committees.find(({slot, index}) => slot === data.slot && index === data.index);
+    if (committee) {
+        attestations.set(committee.slot, true);
+    }
+};
+
+const processBlock = async (
+    {slot}: BeaconBlockEvent["message"],
+    lastEpoch: number,
+    firstSlot: number,
+    validatorPublicKeyBytes: Uint8Array,
+    validatorIndex: number,
+    proposers: Map<number, boolean>,
+    attestations: Map<number, boolean>,
+    committees: BeaconCommitteeResponse[],
+    getProposer: ReturnType<typeof getProposerFactory>,
+    getCommittees: ReturnType<typeof getCommitteesFactory>,
+    limit: number,
+    config: IBeaconConfig,
+): Promise<{
+    epoch: number;
+    lastEpoch: number;
+    committees: BeaconCommitteeResponse[];
+}> => {
+    if (proposers.has(slot)) proposers.set(slot, true);
+
+    const epoch = computeEpochAtSlot(config, slot);
+    if (lastEpoch !== epoch && limit !== epoch) {
+        // eslint-disable-next-line no-param-reassign
+        lastEpoch = epoch;
+
+        const proposerResponse = await getProposer(validatorPublicKeyBytes, epoch, validatorIndex, firstSlot);
+        proposerResponse.forEach(({slot: s}) => {
+            proposers.set(s, false);
+        });
+
+        // eslint-disable-next-line no-param-reassign
+        committees = await getCommittees(validatorIndex, slot, firstSlot);
+        committees.forEach(({slot: s}) => {
+            attestations.set(s, false);
+        });
+    }
+
+    return {epoch, lastEpoch, committees};
+};
+
+export const restValidation = ({
+    baseUrl,
+    getValidatorPrivateKey,
+    limit,
+    config,
+    ApiClient,
+}: {
+    baseUrl: string;
+    getValidatorPrivateKey: () => Promise<SecretKey>;
+    limit: number;
+    ApiClient: typeof CgEth2ApiClient;
+    config: IBeaconConfig;
+}): Promise<{
+    proposer: {
+        proposed: number;
+        delegated: number;
+    };
+    attestation: {
+        attestations: number;
+        delegated: number;
+    };
+}> =>
+    new Promise((resolve) => {
+        (async (): Promise<void> => {
+            process.env.NODE_ENV = "validator-test";
+            await initBLS("blst-native");
+            const validatorPrivateKey = await getValidatorPrivateKey();
+            const validatorPublicKey = validatorPrivateKey.toPublicKey();
+            const validatorPublicKeyBytes = validatorPublicKey.toBytes();
+            console.log("Starting validator " + validatorPublicKey.toHex());
+
+            const logger = new WinstonLogger({module: "ChainGuardian", level: LogLevel.verbose});
+            const slashingProtection = sinon.createStubInstance(CGSlashingProtection);
+
+            const eth2API = new ApiClient(config, baseUrl);
+            const validatorService = new Validator({
+                slashingProtection,
+                api: eth2API,
+                config,
+                secretKeys: [validatorPrivateKey],
+                logger,
+                graffiti: "ChainGuardian",
+            });
+            const validator = await eth2API.beacon.state.getStateValidator("head", validatorPublicKeyBytes);
+            await validatorService.start();
+
+            let firstSlot: number | undefined;
+
+            let startEpoch = 1;
+            let lastEpoch = 1;
+
+            const onFirstBlock = ({slot}: BeaconBlockEvent["message"]): void => {
+                const epoch = computeEpochAtSlot(config, slot);
+                if (!firstSlot) {
+                    firstSlot = slot;
+                    startEpoch = epoch;
+                }
+            };
+
+            const getCommittees = getCommitteesFactory(eth2API);
+            let committees: BeaconCommitteeResponse[] = [];
+            const attestations = new Map<number, boolean>();
+
+            const getProposer = getProposerFactory(eth2API);
+            const proposers = new Map<number, boolean>();
+
+            const stream = await eth2API.events.getEventStream(([
+                CGBeaconEventType.BLOCK,
+                CGBeaconEventType.ATTESTATION,
+            ] as unknown) as BeaconEventType[]);
+            for await (const {type, message} of stream) {
+                switch ((type as unknown) as CGBeaconEventType) {
+                    case CGBeaconEventType.ATTESTATION: {
+                        processAttestation(
+                            (message as unknown) as AttestationEvent["message"],
+                            committees,
+                            attestations,
+                        );
+                        break;
+                    }
+                    case CGBeaconEventType.BLOCK: {
+                        onFirstBlock((message as unknown) as BeaconBlockEvent["message"]);
+                        const {epoch, ...rest} = await processBlock(
+                            (message as unknown) as BeaconBlockEvent["message"],
+                            lastEpoch,
+                            firstSlot,
+                            validatorPublicKeyBytes,
+                            validator.index,
+                            proposers,
+                            attestations,
+                            committees,
+                            getProposer,
+                            getCommittees,
+                            startEpoch + limit,
+                            config,
+                        );
+
+                        lastEpoch = rest.lastEpoch;
+                        committees = rest.committees;
+
+                        if (startEpoch + limit === epoch) {
+                            await validatorService.stop();
+                            resolve({
+                                proposer: {
+                                    proposed: [...proposers.values()].reduce((p, c) => p + Number(c), 0),
+                                    delegated: proposers.size,
+                                },
+                                attestation: {
+                                    attestations: [...attestations.values()].reduce((p, c) => p + Number(c), 0),
+                                    delegated: attestations.size,
+                                },
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+        })();
+    });

integration/teku.ts

@@ -0,0 +1,33 @@
+import {getInteropKey} from "../src/renderer/services/validator/interop_keys";
+import assert from "assert";
+import {restValidation} from "./restValidation";
+import {config} from "@chainsafe/lodestar-config/lib/presets/minimal";
+import {CgTekuEth2Api} from "../src/renderer/services/eth2/client/module";
+
+(async function (): Promise<void> {
+    const {proposer, attestation} = await restValidation({
+        baseUrl: "http://localhost:5051",
+        getValidatorPrivateKey: async () => getInteropKey(7),
+        limit: 5,
+        config,
+        ApiClient: CgTekuEth2Api,
+    });
+
+    console.log("\n\n\n");
+    let isFailed = false;
+    try {
+        assert.equal(proposer.proposed, proposer.delegated);
+        console.info(`Successfully proposed all ${proposer.delegated} blocks`);
+    } catch (e) {
+        console.error("Proposals", e.message);
+        isFailed = true;
+    }
+    try {
+        assert.equal(attestation.attestations, attestation.delegated);
+        console.info(`Successfully provide all ${proposer.delegated} attestations`);
+    } catch (e) {
+        console.error("Attestations", e.message);
+        isFailed = true;
+    }
+    process.exit(Number(isFailed));
+})();