feat(dashmate): check for DKG before stopping node

packages/dashmate/README.md

@@ -177,6 +177,8 @@ USAGE
   $ dashmate start [-v] [--config <value>] [-w]
 
 FLAGS
+  -f, --force               force start even if any services are already running
+  -p, --platform            start only platform
   -v, --verbose             use verbose mode for output
   -w, --wait-for-readiness  wait for nodes to be ready
   --config=<value>          configuration name to use
@@ -193,12 +195,15 @@ The `stop` command is used to stop a running node.
 
 ```
 USAGE
-  $ dashmate stop [-v] [--config <value>] [-f]
+  $ dashmate stop [--config <value>] [-v] [-f] [-p] [-s]
 
 FLAGS
-  -f, --force       force stop even if any is running
+  -f, --force       force stop even if any service is running
+  -p, --platform    stop only platform
+  -s, --safe        wait for dkg before stop
   -v, --verbose     use verbose mode for output
   --config=<value>  configuration name to use
+
 ```
 
 To stop a node:
@@ -212,11 +217,13 @@ The `restart` command is used to restart a node with the default or specified co
 
 ```
 USAGE
-  $ dashmate restart [-v] [--config <value>]
+  $ dashmate restart [--config <value>] [-v] [-p] [-s]
 
 FLAGS
-  -v, --verbose     use verbose mode for output
-  --config=<value>  configuration name to use
+  -p, --platform        restart only platform
+  -s, --safe            wait for dkg before stop
+  -v, --verbose         use verbose mode for output
+      --config=<value>  configuration name to use
 ```
 
 ### Show node status
@@ -391,7 +398,8 @@ USAGE
   $ dashmate group stop [-v] [--group <value>] [-f]
 
 FLAGS
-  -f, --force      force stop even if any service is running
+  -f, --force      force stop even if any is running
+  -s, --safe       wait for dkg before stop
   -v, --verbose    use verbose mode for output
   --group=<value>  group name to use
 ```
@@ -402,11 +410,15 @@ The `group restart` command is used to restart group nodes belonging to the defa
 
 ```
 USAGE
-  $ dashmate group restart [-v] [--group <value>]
+  $ dashmate group restart [--group <value>] [-v] [-s]
 
 FLAGS
-  -v, --verbose    use verbose mode for output
-  --group=<value>  group name to use
+  -s, --safe           wait for dkg before stop
+  -v, --verbose        use verbose mode for output
+      --group=<value>  group name to use
+
+DESCRIPTION
+  Restart group nodes
 ```
 
 #### Show group status

packages/dashmate/src/commands/group/restart.js

@@ -7,6 +7,11 @@ export default class GroupRestartCommand extends GroupBaseCommand {
 
   static flags = {
     ...GroupBaseCommand.flags,
+    safe: {
+      char: 's',
+      description: 'wait for dkg before stop',
+      default: false,
+    },
   };
 
   /**
@@ -21,6 +26,7 @@ export default class GroupRestartCommand extends GroupBaseCommand {
   async runWithDependencies(
     args,
     {
+      safe: isSafe,
       verbose: isVerbose,
     },
     dockerCompose,
@@ -38,8 +44,8 @@ export default class GroupRestartCommand extends GroupBaseCommand {
             {
               title: 'Stop nodes',
               task: () => (
-              // So we stop the miner first, as there's a chance that MNs will get banned
-              // if the miner is still running when stopping them
+                // So we stop the miner first, as there's a chance that MNs will get banned
+                // if the miner is still running when stopping them
                 new Listr(configGroup.reverse().map((config) => ({
                   task: () => stopNodeTask(config),
                 })))
@@ -66,6 +72,7 @@ export default class GroupRestartCommand extends GroupBaseCommand {
     try {
       await tasks.run({
         isVerbose,
+        isSafe,
       });
     } catch (e) {
       throw new MuteOneLineError(e);

packages/dashmate/src/commands/group/stop.js

@@ -13,6 +13,11 @@ export default class GroupStopCommand extends GroupBaseCommand {
       description: 'force stop even if any is running',
       default: false,
     }),
+    safe: Flags.boolean({
+      char: 's',
+      description: 'wait for dkg before stop',
+      default: false,
+    }),
   };
 
   /**
@@ -27,6 +32,7 @@ export default class GroupStopCommand extends GroupBaseCommand {
     args,
     {
       force: isForce,
+      safe: isSafe,
       verbose: isVerbose,
     },
     dockerCompose,
@@ -63,6 +69,7 @@ export default class GroupStopCommand extends GroupBaseCommand {
       await tasks.run({
         isVerbose,
         isForce,
+        isSafe,
       });
     } catch (e) {
       throw new MuteOneLineError(e);

packages/dashmate/src/commands/restart.js

@@ -10,6 +10,7 @@ export default class RestartCommand extends ConfigBaseCommand {
   static flags = {
     ...ConfigBaseCommand.flags,
     platform: Flags.boolean({ char: 'p', description: 'restart only platform', default: false }),
+    safe: Flags.boolean({ char: 's', description: 'wait for dkg before stop', default: false }),
   };
 
   /**
@@ -25,6 +26,7 @@ export default class RestartCommand extends ConfigBaseCommand {
     {
       verbose: isVerbose,
       platform: platformOnly,
+      safe: isSafe,
     },
     dockerCompose,
     restartNodeTask,
@@ -51,6 +53,7 @@ export default class RestartCommand extends ConfigBaseCommand {
     try {
       await tasks.run({
         isVerbose,
+        isSafe,
         platformOnly: platformOnly === true,
       });
     } catch (e) {

packages/dashmate/src/commands/stop.js

@@ -19,6 +19,11 @@ export default class StopCommand extends ConfigBaseCommand {
       description: 'stop only platform',
       default: false,
     }),
+    safe: Flags.boolean({
+      char: 's',
+      description: 'wait for dkg before stop',
+      default: false,
+    }),
   };
 
   /**
@@ -32,6 +37,7 @@ export default class StopCommand extends ConfigBaseCommand {
     args,
     {
       force: isForce,
+      safe: isSafe,
       verbose: isVerbose,
       platform: platformOnly,
     },
@@ -59,6 +65,7 @@ export default class StopCommand extends ConfigBaseCommand {
       await tasks.run({
         isForce,
         isVerbose,
+        isSafe,
         platformOnly: platformOnly === true,
       });
     } catch (e) {

packages/dashmate/src/constants.js

@@ -38,6 +38,9 @@ export const QUORUM_TYPES = {
 export const MASTERNODE_COLLATERAL_AMOUNT = 1000;
 export const HPMN_COLLATERAL_AMOUNT = 4000;
 
+// number of blocks to wait before core DKG exchange session
+export const MIN_BLOCKS_BEFORE_DKG = 6;
+
 export const PACKAGE_ROOT_DIR = path.join(url.fileURLToPath(import.meta.url), '../..');
 export const TEMPLATES_DIR = path.join(PACKAGE_ROOT_DIR, 'templates');
 

packages/dashmate/src/core/quorum/waitForDKGWindowPass.js

@@ -0,0 +1,40 @@
+import { MIN_BLOCKS_BEFORE_DKG } from '../../constants.js';
+import wait from '../../util/wait.js';
+
+/**
+ * @param {RpcClient} rpcClient
+ * @return {Promise<void>}
+ */
+export default async function waitForDKGWindowPass(rpcClient) {
+  let startBlockCount;
+  let startNextDkg;
+
+  let isInDKG = true;
+
+  do {
+    const [currentBlockCount, currentDkgInfo] = await Promise
+      .all([rpcClient.getBlockCount(), rpcClient.quorum('dkginfo')]);
+
+    const { result: blockCount } = currentBlockCount;
+    const { result: dkgInfo } = currentDkgInfo;
+
+    const { next_dkg: nextDkg } = dkgInfo;
+
+    if (!startBlockCount) {
+      startBlockCount = blockCount;
+    }
+
+    if (!startNextDkg) {
+      startNextDkg = nextDkg;
+    }
+
+    isInDKG = nextDkg <= MIN_BLOCKS_BEFORE_DKG;
+
+    if (isInDKG && blockCount > startBlockCount + startNextDkg + 1) {
+      throw new Error(`waitForDKGWindowPass deadline exceeded: dkg did not happen for ${startBlockCount + nextDkg + 1} ${startNextDkg + 1} blocks`);
+    }
+
+    await wait(10000);
+  }
+  while (isInDKG);
+}

packages/dashmate/src/listr/tasks/stopNodeTaskFactory.js

@@ -1,4 +1,7 @@
+/* eslint-disable no-console */
 import { Listr } from 'listr2';
+import { MIN_BLOCKS_BEFORE_DKG } from '../../constants.js';
+import waitForDKGWindowPass from '../../core/quorum/waitForDKGWindowPass.js';
 
 /**
  * @param {DockerCompose} dockerCompose
@@ -34,6 +37,36 @@ export default function stopNodeTaskFactory(
           }
         },
       },
+      {
+        title: 'Check node is participating in DKG',
+        enabled: (ctx) => config.get('core.masternode.enable') && !ctx.isForce && !ctx.isSafe,
+        task: async () => {
+          const rpcClient = createRpcClient({
+            port: config.get('core.rpc.port'),
+            user: config.get('core.rpc.user'),
+            pass: config.get('core.rpc.password'),
+            host: await getConnectionHost(config, 'core', 'core.rpc.host'),
+          });
+
+          const { result: dkgInfo } = await rpcClient.quorum('dkginfo');
+          const { next_dkg: nextDkg } = dkgInfo;
+
+          if (nextDkg <= MIN_BLOCKS_BEFORE_DKG) {
+            throw new Error('Your node is currently participating in DKG exchange session and '
+              + 'stopping it right now may result in PoSE ban. Try again later, or continue with --force or --safe flags');
+          }
+        },
+      },
+      {
+        title: 'Wait for DKG window to pass',
+        enabled: (ctx) => config.get('core.masternode.enable') && !ctx.isForce && ctx.isSafe,
+        task: async () => waitForDKGWindowPass(createRpcClient({
+          port: config.get('core.rpc.port'),
+          user: config.get('core.rpc.user'),
+          pass: config.get('core.rpc.password'),
+          host: await getConnectionHost(config, 'core', 'core.rpc.host'),
+        })),
+      },
       {
         title: 'Save core node time',
         enabled: () => config.get('group') === 'local',
@@ -58,7 +91,6 @@ export default function stopNodeTaskFactory(
           if (ctx.platformOnly) {
             profiles.push('platform');
           }
-
           await dockerCompose.stop(config, { profiles });
         },
       },

packages/dashmate/test/e2e/testnetEvonode.spec.js

@@ -147,6 +147,7 @@ describe('Testnet Evonode', function main() {
 
       await task.run({
         isVerbose: true,
+        isSafe: true,
       });
 
       // TODO: Assert all services are running
@@ -230,6 +231,7 @@ describe('Testnet Evonode', function main() {
 
       await task.run({
         isVerbose: true,
+        isSafe: true,
       });
 
       // TODO: Assert all services are running