Add validator:status command to check if a validator signer is online and producing blocks

packages/cli/src/commands/election/current.ts

@@ -4,14 +4,12 @@ import { validatorTable } from '../validator/list'
 
 export default class ElectionCurrent extends BaseCommand {
   static description =
-    'Outputs the set of validators currently participating in BFT to create blocks. The validator set is re-elected at the end of every epoch.'
+    'Outputs the set of validators currently participating in BFT to create blocks. An election is run to select the validator set at the end of every epoch.'
 
   static flags = {
     ...BaseCommand.flags,
   }
 
-  static examples = ['current']
-
   async run() {
     cli.action.start('Fetching currently elected Validators')
     const election = await this.kit.contracts.getElection()

packages/cli/src/commands/election/run.ts

@@ -10,13 +10,11 @@ export default class ElectionRun extends BaseCommand {
     ...BaseCommand.flags,
   }
 
-  static examples = ['run']
-
   async run() {
     cli.action.start('Running mock election')
     const election = await this.kit.contracts.getElection()
     const validators = await this.kit.contracts.getValidators()
-    const signers = await election.getCurrentValidatorSigners()
+    const signers = await election.electValidatorSigners()
     const validatorList = await Promise.all(
       signers.map((addr) => validators.getValidatorFromSigner(addr))
     )

packages/cli/src/commands/validator/status.ts

@@ -0,0 +1,113 @@
+import { Address } from '@celo/contractkit'
+import { eqAddress } from '@celo/utils/lib/address'
+import { concurrentMap } from '@celo/utils/lib/async'
+import { bitIsSet, parseBlockExtraData } from '@celo/utils/lib/istanbul'
+import { flags } from '@oclif/command'
+import { cli } from 'cli-ux'
+import { BaseCommand } from '../../base'
+import { newCheckBuilder } from '../../utils/checks'
+import { Flags } from '../../utils/command'
+
+export default class ValidatorStatus extends BaseCommand {
+  static description =
+    'Show information about whether the validator signer is elected and validating. This command will check that the validator meets the registration requirements, and its signer is currently elected and actively signing blocks.'
+
+  static flags = {
+    ...BaseCommand.flags,
+    signer: Flags.address({
+      description: 'address of the validator to check if elected and validating',
+    }),
+    validator: Flags.address({
+      description: 'address of the signer to check if elected and validating',
+    }),
+    lookback: flags.integer({
+      description: 'how many blocks to look back for signer activity',
+      default: 100,
+    }),
+  }
+
+  static examples = [
+    'status --validator 0x5409ED021D9299bf6814279A6A1411A7e866A631',
+    'status --signer 0x738337030fAeb1E805253228881d844b5332fB4c',
+    'status --signer 0x738337030fAeb1E805253228881d844b5332fB4c --lookback 100',
+  ]
+
+  requireSynced = true
+
+  async run() {
+    const res = this.parse(ValidatorStatus)
+
+    // Check that the specified validator or signer meets the validator requirements.
+    const checker = newCheckBuilder(this, res.flags.signer)
+    if (res.flags.validator) {
+      const account = res.flags.validator
+      checker.isValidator(account).meetsValidatorBalanceRequirements(account)
+    } else if (res.flags.signer) {
+      checker.signerMeetsValidatorBalanceRequirements().signerAccountIsValidator()
+    } else {
+      this.error('Either validator or signer must be specified')
+    }
+    await checker.runChecks()
+
+    // Assign and verify the signer.
+    let signer: Address
+    if (res.flags.signer) {
+      signer = res.flags.signer
+      if (res.flags.validator) {
+        const accounts = await this.kit.contracts.getAccounts()
+        if ((await accounts.signerToAccount(signer)) !== res.flags.validator) {
+          this.error(
+            `Signer ${signer} has never been authorized for account ${res.flags.validator}`
+          )
+        }
+      }
+    } else {
+      const accounts = await this.kit.contracts.getAccounts()
+      signer = await accounts.getValidatorSigner(res.flags.validator!)
+      console.info(`Identified ${signer} as the authorized validator signer`)
+    }
+
+    // Determine if the signer is elected, and get their index in the validator set.
+    const election = await this.kit.contracts.getElection()
+    const signers = await election.getCurrentValidatorSigners()
+    const signerIndex = signers.map((a) => eqAddress(a, signer)).indexOf(true)
+    if (signerIndex < 0) {
+      // Determine whether the signer will be elected at the next epoch to provide a helpful error.
+      const frontrunners = await election.electValidatorSigners()
+      if (frontrunners.some((a) => eqAddress(a, signer))) {
+        this.error(
+          `Signer ${signer} is not elected for this epoch, but is currently winning in the upcoming election. Wait for the next epoch.`
+        )
+      } else {
+        this.error(
+          `Signer ${signer} is not elected for this epoch, and is not currently winning the upcoming election.`
+        )
+      }
+    }
+    console.info('Signer has been elected for this epoch')
+
+    if (((res.flags && res.flags.lookback) || 0) <= 0) {
+      return
+    }
+
+    // Retrieve blocks to examine for the singers signature.
+    cli.action.start(`Retreiving the last ${res.flags.lookback} blocks`)
+    const latest = await this.web3.eth.getBlock('latest')
+    const blocks = await concurrentMap(10, [...Array(res.flags.lookback).keys()].slice(1), (i) =>
+      this.web3.eth.getBlock(latest.number - i)
+    )
+    blocks.splice(0, 0, latest)
+    cli.action.stop()
+
+    const signedCount = blocks.filter((b) =>
+      bitIsSet(parseBlockExtraData(b.extraData).parentAggregatedSeal.bitmap, signerIndex)
+    ).length
+    if (signedCount === 0) {
+      this.error(`Signer has not signed any of the last ${res.flags.lookback} blocks`)
+    }
+    console.info(`Signer has signed ${signedCount} of the last ${res.flags.lookback} blocks`)
+
+    const proposedCount = blocks.filter((b) => b.miner === signer).length
+    console.info(`Signer has proposed ${proposedCount} of the last ${res.flags.lookback} blocks`)
+  }
+}

packages/cli/src/utils/checks.ts

@@ -70,7 +70,7 @@ class CheckBuilder {
     }
   }
 
-  withAccounts<A>(f: (lockedGold: AccountsWrapper) => A): () => Promise<Resolve<A>> {
+  withAccounts<A>(f: (accounts: AccountsWrapper) => A): () => Promise<Resolve<A>> {
     return async () => {
       const accounts = await this.kit.contracts.getAccounts()
       return f(accounts) as Resolve<A>
@@ -122,12 +122,24 @@ class CheckBuilder {
 
   signerMeetsValidatorGroupBalanceRequirements = () =>
     this.addCheck(
-      `Signer's account has enough locked gold for registration`,
+      `Signer's account has enough locked gold for group registration`,
       this.withValidators((v, _signer, account) =>
         v.meetsValidatorGroupBalanceRequirements(account)
       )
     )
 
+  meetsValidatorBalanceRequirements = (account: Address) =>
+    this.addCheck(
+      `${account} has enough locked gold for registration`,
+      this.withValidators((v) => v.meetsValidatorBalanceRequirements(account))
+    )
+
+  meetsValidatorGroupBalanceRequirements = (account: Address) =>
+    this.addCheck(
+      `${account} has enough locked gold for group registration`,
+      this.withValidators((v) => v.meetsValidatorGroupBalanceRequirements(account))
+    )
+
   isNotAccount = (address: Address) =>
     this.addCheck(
       `${address} is not an Account`,

packages/docs/command-line-interface/account.md

@@ -191,20 +191,6 @@ EXAMPLE
 
 _See code: [packages/cli/src/commands/account/get-metadata.ts](https://github.com/celo-org/celo-monorepo/tree/master/packages/cli/src/commands/account/get-metadata.ts)_
 
-### Isvalidator
-
-Check whether a given address is elected to be validating in the current epoch
-
-```
-USAGE
-  $ celocli account:isvalidator ADDRESS
-
-EXAMPLE
-  isvalidator 0x5409ed021d9299bf6814279a6a1411a7e866a631
-```
-
-_See code: [packages/cli/src/commands/account/isvalidator.ts](https://github.com/celo-org/celo-monorepo/tree/master/packages/cli/src/commands/account/isvalidator.ts)_
-
 ### New
 
 Creates a new account locally and print out the key information. Save this information for local transaction signing or import into a Celo node.

packages/docs/command-line-interface/election.md

@@ -25,14 +25,11 @@ _See code: [packages/cli/src/commands/election/activate.ts](https://github.com/c
 
 ### Current
 
-Outputs the set of validators currently participating in BFT to create blocks. The validator set is re-elected at the end of every epoch.
+Outputs the set of validators currently participating in BFT to create blocks. An election is run to select the validator set at the end of every epoch.
 
 ```
 USAGE
   $ celocli election:current
-
-EXAMPLE
-  current
 ```
 
 _See code: [packages/cli/src/commands/election/current.ts](https://github.com/celo-org/celo-monorepo/tree/master/packages/cli/src/commands/election/current.ts)_
@@ -78,9 +75,6 @@ Runs a "mock" election and prints out the validators that would be elected if th
 ```
 USAGE
   $ celocli election:run
-
-EXAMPLE
-  run
 ```
 
 _See code: [packages/cli/src/commands/election/run.ts](https://github.com/celo-org/celo-monorepo/tree/master/packages/cli/src/commands/election/run.ts)_

packages/docs/command-line-interface/validator.md

@@ -131,6 +131,30 @@ EXAMPLE
 
 _See code: [packages/cli/src/commands/validator/show.ts](https://github.com/celo-org/celo-monorepo/tree/master/packages/cli/src/commands/validator/show.ts)_
 
+### Status
+
+Show information about whether the validator signer is elected and validating. This command will check that the validator meets the registration requirements, and its signer is currently elected and actively signing blocks.
+
+```
+USAGE
+  $ celocli validator:status
+
+OPTIONS
+  --lookback=lookback                                     [default: 100] how many blocks to look back for signer
+                                                          activity
+
+  --signer=0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232d     address of the validator to check if elected and validating
+
+  --validator=0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232d  address of the signer to check if elected and validating
+
+EXAMPLES
+  status --validator 0x5409ED021D9299bf6814279A6A1411A7e866A631
+  status --signer 0x738337030fAeb1E805253228881d844b5332fB4c
+  status --signer 0x738337030fAeb1E805253228881d844b5332fB4c --lookback 100
+```
+
+_See code: [packages/cli/src/commands/validator/status.ts](https://github.com/celo-org/celo-monorepo/tree/master/packages/cli/src/commands/validator/status.ts)_
+
 ### Update-bls-public-key
 
 Update the BLS public key for a Validator to be used in consensus. Regular (ECDSA and BLS) key rotation is recommended for Validator operational security.

packages/docs/getting-started/running-a-validator.md

@@ -442,11 +442,11 @@ celocli election:list
 
 If you find your Validator still not getting elected you may need to faucet yourself more funds and lock more gold in order to be able to cast more votes for your Validator Group!
 
-At any moment you can check the currently elected validators by running the following command:
+You can check the status of your validator, including whether it is elected and signing blocks, by running:
 
 ```bash
 # On your local machine
-celocli election:current
+celocli validator:status --validator $CELO_VALIDATOR_ADDRESS
 ```
 
 ### Running the Attestation Service

packages/utils/src/index.ts

@@ -7,3 +7,4 @@ export * from './dappkit'
 export { ECIES } from './ecies'
 export { PhoneNumberUtils } from './phoneNumbers'
 export { SignatureUtils } from './signatureUtils'
+export { IstanbulUtils } from './istanbul'

packages/utils/src/istanbul.test.ts

@@ -0,0 +1,64 @@
+import BigNumber from 'bignumber.js'
+import { bitIsSet, Bitmap, IstanbulExtra, parseBlockExtraData } from './istanbul'
+
+describe('Istanbul utilities', () => {
+  describe('parseBlockExtraData', () => {
+    const testExtraData =
+      '0xd983010817846765746888676f312e31312e358664617277696e000000000000f90127d594fd0893e334' +
+      'c6401188ae77072546979b94d91813f862b8604fa3f67fc913878b068d1fa1cdddc54913d3bf988dbe5a36' +
+      'a20fa888f20d4894c408a6773f3d7bde11154f2a3076b700d345a42fd25a0e5e83f4db5586ac7979ac2053' +
+      'cd95d8f2efd3e959571ceccaa743e02cf4be3f5d7aaddb0b06fc9aff0001b84188022a71c12a801a4318e2' +
+      '7eeb5c82aa923160632c63b0eae4457ed120356ddb549fb7c4e4865728478aa61c19b9abe10ec7db34c866' +
+      '2b003b139188e99edcd400f30db040c083f6b6e29a6a2cab4498f50d37d458a2458b5438c9faeae8598cd4' +
+      '7f4ed6e17ca10e1f87c6faa14d5e3e393f0e0080f30db06107252c187052f8212ef5cfc9052fe59c7af040' +
+      'e77a09b762fd51060220511e93d1c681be8883043f8a93ea637492818080'
+
+    const expected: IstanbulExtra = {
+      addedValidators: ['0xFd0893E334C6401188Ae77072546979B94d91813'],
+      addedValidatorsPublicKeys: [
+        '0x4fa3f67fc913878b068d1fa1cdddc54913d3bf988dbe5a36a20fa888f20d4894c408a6773f3d7bde11154f2a3076b700d345a42fd25a0e5e83f4db5586ac7979ac2053cd95d8f2efd3e959571ceccaa743e02cf4be3f5d7aaddb0b06fc9aff00',
+      ],
+      removedValidators: new BigNumber(1),
+      seal:
+        '0x88022a71c12a801a4318e27eeb5c82aa923160632c63b0eae4457ed120356ddb549fb7c4e4865728478aa61c19b9abe10ec7db34c8662b003b139188e99edcd400',
+      aggregatedSeal: {
+        bitmap: new BigNumber(13),
+        signature:
+          '0x40c083f6b6e29a6a2cab4498f50d37d458a2458b5438c9faeae8598cd47f4ed6e17ca10e1f87c6faa14d5e3e393f0e00',
+        round: new BigNumber(0),
+      },
+      parentAggregatedSeal: {
+        bitmap: new BigNumber(13),
+        signature:
+          '0x6107252c187052f8212ef5cfc9052fe59c7af040e77a09b762fd51060220511e93d1c681be8883043f8a93ea63749281',
+        round: new BigNumber(0),
+      },
+    }
+
+    it('should decode the Istanbul extra data correctly', () => {
+      expect(parseBlockExtraData(testExtraData)).toEqual(expected)
+    })
+  })
+
+  describe('bitIsSet', () => {
+    const testBitmap: Bitmap = new BigNumber('0x40d1', 16)
+    const testBitmapAsBinary = ('0100' + '0000' + '1101' + '0001')
+      .split('')
+      .map((b) => b === '1')
+      .reverse()
+
+    it('should correctly identify set bits within expected index', () => {
+      for (let i = 0; i < testBitmapAsBinary.length; i++) {
+        expect(bitIsSet(testBitmap, i)).toBe(testBitmapAsBinary[i])
+      }
+    })
+
+    it('should return false when the index is too large', () => {
+      expect(bitIsSet(testBitmap, 1000)).toBe(false)
+    })
+
+    it('should throw an error when the index is negative', () => {
+      expect(() => bitIsSet(testBitmap, -1)).toThrow()
+    })
+  })
+})