Allow voluntary exit command to write to file rather than publish (Consensys#8168)

* Allow voluntary exit command to write to file rather than publish

The advantage of this is that the message can avoid epoch validation, and also it can separate the submission of the exit from creation, so if something fails, it can have further investigation.

The format saved to json will allow it to be posted directly to the voluntary exits beacon-api POST endpoint.

Assists with Consensys#8158 but only as a potential workaround, allowing us to avoid setting up the keymanager-api to generate an exit.

Signed-off-by: Paul Harris <[email protected]>

Author: rolfyone

teku/src/integration-test/java/tech/pegasys/teku/cli/subcommand/VoluntaryExitCommandTest.java

@@ -30,17 +30,23 @@
 import java.io.PrintStream;
 import java.io.PrintWriter;
 import java.io.StringWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.function.Supplier;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.tuweni.bytes.Bytes;
 import org.apache.tuweni.bytes.Bytes32;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledOnOs;
+import org.junit.jupiter.api.condition.OS;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.io.TempDir;
 import org.mockserver.integration.ClientAndServer;
 import org.mockserver.junit.jupiter.MockServerExtension;
 import org.mockserver.model.Parameter;
@@ -281,6 +287,72 @@ void shouldNotWarn_NotWithdrawableIfCapellaEnabled() throws JsonProcessingExcept
         validatorPubKey1, validatorPubKey2, keyManagerPubKey1, keyManagerPubKey2, nonExistingKey);
   }
 
+  @Test
+  void shouldGenerateExitWithoutSendingToNode(@TempDir final Path tempDir) throws IOException {
+    configureSuccessfulSpecResponse(mockBeaconServer, TestSpecFactory.createMinimalCapella());
+    final Path outputFolder = tempDir.resolve("out");
+    final List<String> args = new ArrayList<>();
+    args.addAll(commandArgs);
+    args.addAll(
+        List.of(
+            "--validator-public-keys",
+            validatorPubKey1,
+            "--save-exits-path",
+            outputFolder.toAbsolutePath().toString()));
+    int parseResult = beaconNodeCommand.parse(args.toArray(new String[0]));
+    assertThat(parseResult).isEqualTo(0);
+    assertThat(stdErr.toString(UTF_8)).isEmpty();
+
+    final String outString = stdOut.toString(UTF_8);
+    assertThat(outString).contains("Saving exits to folder " + outputFolder);
+    // specifically we wrote validator 1's exit message
+    assertThat(outString).contains("Writing signed exit for a756543");
+    // generically, we only wrote 1 signed exit to file
+    assertThat(StringUtils.countMatches(outString, "Writing signed exit for")).isEqualTo(1);
+    // we succeeded in writing a file
+    assertThat(outputFolder.resolve("a756543_exit.json").toFile().exists()).isTrue();
+    assertValidatorsNotExited(validatorPubKey1);
+  }
+
+  @Test
+  void shouldFailIfSaveFolderCannotBeCreated(@TempDir final Path tempDir) throws IOException {
+    configureSuccessfulSpecResponse(mockBeaconServer, TestSpecFactory.createMinimalCapella());
+    final Path invalidOutputDestination = tempDir.resolve("testFile");
+    Files.writeString(invalidOutputDestination, "test");
+    final List<String> args = new ArrayList<>();
+    args.addAll(commandArgs);
+    args.addAll(
+        List.of(
+            "--validator-public-keys",
+            validatorPubKey1,
+            "--save-exits-path",
+            invalidOutputDestination.toAbsolutePath().toString()));
+    int parseResult = beaconNodeCommand.parse(args.toArray(new String[0]));
+    assertThat(parseResult).isEqualTo(1);
+    assertThat(stdErr.toString(UTF_8))
+        .contains("exists and is not a directory, cannot export to this path.");
+  }
+
+  @Test
+  @DisabledOnOs(OS.WINDOWS) // can't set permissions on windows
+  void shouldFailIfSaveFolderHasInsufficientAccess(@TempDir final Path tempDir) throws IOException {
+    configureSuccessfulSpecResponse(mockBeaconServer, TestSpecFactory.createMinimalCapella());
+    final Path invalidOutputDestination = tempDir.resolve("testFile");
+    tempDir.toFile().mkdir();
+    tempDir.toFile().setWritable(false);
+    final List<String> args = new ArrayList<>();
+    args.addAll(commandArgs);
+    args.addAll(
+        List.of(
+            "--validator-public-keys",
+            validatorPubKey1,
+            "--save-exits-path",
+            invalidOutputDestination.toAbsolutePath().toString()));
+    int parseResult = beaconNodeCommand.parse(args.toArray(new String[0]));
+    assertThat(parseResult).isEqualTo(1);
+    assertThat(stdErr.toString(UTF_8)).contains("Failed to store exit for a756543");
+  }
+
   @Test
   void shouldExitFailureWithNoValidatorKeysFound() throws JsonProcessingException {
     configureSuccessfulSpecResponse(mockBeaconServer);

teku/src/main/java/tech/pegasys/teku/cli/subcommand/VoluntaryExitCommand.java

@@ -15,19 +15,24 @@
 
 import static tech.pegasys.teku.cli.subcommand.RemoteSpecLoader.getSpec;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
+import java.io.File;
+import java.io.IOException;
 import java.net.ConnectException;
 import java.net.URI;
 import java.net.http.HttpClient;
 import java.nio.charset.Charset;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Scanner;
 import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import org.apache.tuweni.bytes.Bytes32;
@@ -44,12 +49,14 @@
 import tech.pegasys.teku.cli.options.ValidatorClientDataOptions;
 import tech.pegasys.teku.cli.options.ValidatorClientOptions;
 import tech.pegasys.teku.cli.options.ValidatorKeysOptions;
+import tech.pegasys.teku.cli.subcommand.debug.PrettyPrintCommand;
 import tech.pegasys.teku.config.TekuConfiguration;
 import tech.pegasys.teku.infrastructure.async.AsyncRunner;
 import tech.pegasys.teku.infrastructure.async.AsyncRunnerFactory;
 import tech.pegasys.teku.infrastructure.async.MetricTrackingExecutorFactory;
 import tech.pegasys.teku.infrastructure.exceptions.ExceptionUtil;
 import tech.pegasys.teku.infrastructure.exceptions.InvalidConfigurationException;
+import tech.pegasys.teku.infrastructure.json.JsonUtil;
 import tech.pegasys.teku.infrastructure.logging.SubCommandLogger;
 import tech.pegasys.teku.infrastructure.logging.ValidatorLogger;
 import tech.pegasys.teku.infrastructure.unsigned.UInt64;
@@ -82,6 +89,7 @@
     footerHeading = "%n",
     footer = "Teku is licensed under the Apache License 2.0")
 public class VoluntaryExitCommand implements Callable<Integer> {
+
   public static final SubCommandLogger SUB_COMMAND_LOG = new SubCommandLogger();
   private static final int MAX_PUBLIC_KEY_BATCH_SIZE = 50;
   private OkHttpValidatorRestApiClient apiClient;
@@ -150,19 +158,38 @@ public class VoluntaryExitCommand implements Callable<Integer> {
       arity = "0..1")
   private boolean includeKeyManagerKeys = false;
 
+  @CommandLine.Option(
+      names = {"--save-exits-path"},
+      description =
+          "Save the generated exit messages to the specified path, don't validate exit epoch, and skip publishing them.",
+      paramLabel = "<FOLDER>",
+      arity = "1")
+  public File voluntaryExitsFolder;
+
   private AsyncRunnerFactory asyncRunnerFactory;
 
   @Override
   public Integer call() {
     SUB_COMMAND_LOG.display("Loading configuration...");
     try {
       initialise();
-      if (confirmationEnabled) {
-        if (!confirmExits()) {
+
+      if (voluntaryExitsFolder != null) {
+        SUB_COMMAND_LOG.display(
+            "Saving exits to folder "
+                + voluntaryExitsFolder
+                + ", and not submitting to beacon-node.");
+        if (!saveExitsToFolder()) {
           return 1;
         }
+      } else {
+        if (confirmationEnabled) {
+          if (!confirmExits()) {
+            return 1;
+          }
+        }
+        getValidatorIndices(validatorsMap).forEach(this::submitExitForValidator);
       }
-      getValidatorIndices(validatorsMap).forEach(this::submitExitForValidator);
     } catch (Exception ex) {
       if (ExceptionUtil.hasCause(ex, ConnectException.class)) {
         SUB_COMMAND_LOG.error(getFailedToConnectMessage());
@@ -180,6 +207,30 @@ public Integer call() {
     return 0;
   }
 
+  private boolean saveExitsToFolder() {
+    if (voluntaryExitsFolder.exists() && !voluntaryExitsFolder.isDirectory()) {
+      SUB_COMMAND_LOG.error(
+          String.format(
+              "%s exists and is not a directory, cannot export to this path.",
+              voluntaryExitsFolder));
+      return false;
+    } else if (!voluntaryExitsFolder.exists()) {
+      voluntaryExitsFolder.mkdirs();
+    }
+    final AtomicInteger failures = new AtomicInteger();
+    getValidatorIndices(validatorsMap)
+        .forEach(
+            (publicKey, validatorIndex) -> {
+              if (!storeExitForValidator(publicKey, validatorIndex)) {
+                failures.incrementAndGet();
+              }
+            });
+    if (failures.get() > 0) {
+      return false;
+    }
+    return true;
+  }
+
   private boolean confirmExits() {
     SUB_COMMAND_LOG.display("Exits are going to be generated for validators: ");
     SUB_COMMAND_LOG.display(getValidatorAbbreviatedKeys());
@@ -207,7 +258,7 @@ private String getValidatorAbbreviatedKeys() {
   }
 
   private Object2IntMap<BLSPublicKey> getValidatorIndices(
-      Map<BLSPublicKey, Validator> validatorsMap) {
+      final Map<BLSPublicKey, Validator> validatorsMap) {
     final Object2IntMap<BLSPublicKey> validatorIndices = new Object2IntOpenHashMap<>();
     final List<String> publicKeys =
         validatorsMap.keySet().stream().map(BLSPublicKey::toString).toList();
@@ -237,16 +288,10 @@ private Object2IntMap<BLSPublicKey> getValidatorIndices(
 
   private void submitExitForValidator(final BLSPublicKey publicKey, final int validatorIndex) {
     try {
-      final ForkInfo forkInfo = new ForkInfo(fork, genesisRoot);
-      final VoluntaryExit message = new VoluntaryExit(epoch, UInt64.valueOf(validatorIndex));
-      final BLSSignature signature =
-          Optional.ofNullable(validatorsMap.get(publicKey))
-              .orElseThrow()
-              .getSigner()
-              .signVoluntaryExit(message, forkInfo)
-              .join();
-      Optional<PostDataFailureResponse> response =
-          apiClient.sendVoluntaryExit(new SignedVoluntaryExit(message, signature));
+      final tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit exit =
+          generateSignedExit(publicKey, validatorIndex);
+      final Optional<PostDataFailureResponse> response =
+          apiClient.sendVoluntaryExit(new SignedVoluntaryExit(exit));
       if (response.isPresent()) {
         SUB_COMMAND_LOG.error(response.get().message);
       } else {
@@ -261,6 +306,52 @@ private void submitExitForValidator(final BLSPublicKey publicKey, final int vali
     }
   }
 
+  private tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit generateSignedExit(
+      final BLSPublicKey publicKey, final int validatorIndex) {
+    final ForkInfo forkInfo = new ForkInfo(fork, genesisRoot);
+    final VoluntaryExit message = new VoluntaryExit(epoch, UInt64.valueOf(validatorIndex));
+    final BLSSignature signature =
+        Optional.ofNullable(validatorsMap.get(publicKey))
+            .orElseThrow()
+            .getSigner()
+            .signVoluntaryExit(message, forkInfo)
+            .join();
+    return new tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit(
+        message, signature);
+  }
+
+  private boolean storeExitForValidator(
+      final BLSPublicKey blsPublicKey, final Integer validatorIndex) {
+    final tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit exit =
+        generateSignedExit(blsPublicKey, validatorIndex);
+    try {
+      SUB_COMMAND_LOG.display("Writing signed exit for " + blsPublicKey.toAbbreviatedString());
+      Files.writeString(
+          voluntaryExitsFolder.toPath().resolve(blsPublicKey.toAbbreviatedString() + "_exit.json"),
+          prettyExitMessage(exit));
+      return true;
+    } catch (IOException e) {
+      SUB_COMMAND_LOG.error("Failed to store exit for " + blsPublicKey.toAbbreviatedString());
+      return false;
+    }
+  }
+
+  private String prettyExitMessage(
+      final tech.pegasys.teku.spec.datastructures.operations.SignedVoluntaryExit
+          signedVoluntaryExit)
+      throws JsonProcessingException {
+    final PrettyPrintCommand.OutputFormat json = PrettyPrintCommand.OutputFormat.JSON;
+    return JsonUtil.serialize(
+        json.createFactory(),
+        gen -> {
+          gen.useDefaultPrettyPrinter();
+          signedVoluntaryExit
+              .getSchema()
+              .getJsonTypeDefinition()
+              .serialize(signedVoluntaryExit, gen);
+        });
+  }
+
   private Optional<UInt64> getEpoch() {
     return apiClient
         .getBlockHeader("head")
@@ -367,7 +458,9 @@ private void validateOrDefaultEpoch() {
             "Could not calculate epoch from latest block header, please specify --epoch");
       }
       epoch = maybeEpoch.orElseThrow();
-    } else if (maybeEpoch.isPresent() && epoch.isGreaterThan(maybeEpoch.get())) {
+    } else if (maybeEpoch.isPresent()
+        && epoch.isGreaterThan(maybeEpoch.get())
+        && voluntaryExitsFolder == null) {
       throw new InvalidConfigurationException(
           String.format(
               "The specified epoch %s is greater than current epoch %s, cannot continue.",

teku/src/main/java/tech/pegasys/teku/cli/subcommand/debug/PrettyPrintCommand.java

@@ -133,7 +133,7 @@ private InputStream openStream() throws IOException {
     }
   }
 
-  private enum OutputFormat {
+  public enum OutputFormat {
     JSON(JsonFactory::new),
     YAML(YAMLFactory::new);