Merge branch 'get-graffiti' into graffiti-management

# Conflicts:
#	validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/ValidatorRestApi.java

Author: courtneyeh

.circleci/config.yml

@@ -148,7 +148,7 @@ commands:
           name: "Publish Docker Images"
           command: |
             docker login --username "${DOCKER_USER_RW}" --password "${DOCKER_PASSWORD_RW}"
-            ./gradlew --no-daemon --parallel "-Pbranch=${CIRCLE_BRANCH} -PincludeCommitHash=<< pipeline.parameters.include_commit_hash >>" uploadDocker
+            ./gradlew --no-daemon --parallel "-Pbranch=${CIRCLE_BRANCH} -PincludeCommitHashInDockerTag=<< pipeline.parameters.include_commit_hash_in_docker_tag >>" uploadDocker
 
   notify:
     description: "Notify Slack"
@@ -159,7 +159,7 @@ commands:
           only_for_branches: 'master'
 
 parameters:
-  include_commit_hash:
+  include_commit_hash_in_docker_tag:
     type: boolean
     default: false
 
@@ -437,10 +437,6 @@ jobs:
       - notify
 
   publishDockerAmd64:
-    parameters:
-      include_commit_hash:
-        type: boolean
-        default: false
     executor: machine_executor_amd64
     steps:
       - prepare
@@ -451,10 +447,6 @@ jobs:
       - notify
 
   publishDockerArm64:
-    parameters:
-      include_commit_hash:
-        type: boolean
-        default: false
     executor: machine_executor_arm64
     steps:
       - prepare

CHANGELOG.md

@@ -18,5 +18,6 @@ the [releases page](https://github.com/Consensys/teku/releases).
 - Added hidden option `--Xdeposit-contract-logs-syncing-enabled` to allow disabling the syncing of the deposit contract logs from the EL. This is useful when running a non-validating node. It is advisable to be used alongside with `--Xeth1-missing-deposits-event-logging-enabled=false` to avoid unnecessary logging of missing deposits.
 - Updated the bootnodes for Chiado and Gnosis networks.
 - Added hidden option `--Xp2p-dumps-to-file-enabled` to enable saving p2p dumps to file.
+- Added GET `/eth/v1/validator/{pubkey}/graffiti` validator API.
 
 ### Bug Fixes

build.gradle

@@ -532,24 +532,16 @@ def executableAndArg = System.getProperty('os.name').toLowerCase().contains('win
 task distDocker  {
   dependsOn dockerDistUntar
   def dockerBuildVersion = 'develop'
-
-  if (project.hasProperty('includeCommitHash') && project.property('includeCommitHash').toBoolean()) {
-    def commitHash = new ByteArrayOutputStream()
-    exec {
-      commandLine 'git', 'rev-parse', '--short', 'HEAD'
-      standardOutput = commitHash
-    }
-    dockerBuildVersion += '-' + commitHash
-  }
-
   doLast {
+    def includeCommitHashInDockerTag = project.hasProperty('includeCommitHashInDockerTag') && project.property('includeCommitHashInDockerTag').toBoolean()
+    def commitHashTag = includeCommitHashInDockerTag ? '-' + grgit.head().getAbbreviatedId() : ''
     for (def variant in dockerJdkVariants) {
       copy {
         from file("${projectDir}/docker/${variant}/Dockerfile")
         into(dockerBuildDir)
       }
       exec {
-        def image = "${dockerImage}:${dockerBuildVersion}-${variant}"
+        def image = "${dockerImage}:${dockerBuildVersion}-${variant}${commitHashTag}"
         workingDir dockerBuildDir
         executable executableAndArg[0]
         args executableAndArg[1], "docker build --pull --build-arg BUILD_DATE=${buildTime()} --build-arg VERSION=${dockerBuildVersion} --build-arg VCS_REF=${getCheckedOutGitCommitHash()} -t ${image} ."
@@ -558,7 +550,7 @@ task distDocker  {
     // tag the "default" (which is the variant in the zero position)
     exec {
       executable executableAndArg[0]
-      args executableAndArg[1], "docker tag ${dockerImage}:${dockerBuildVersion}-${dockerJdkVariants[0]} ${dockerImage}:${dockerBuildVersion}"
+      args executableAndArg[1], "docker tag ${dockerImage}:${dockerBuildVersion}-${dockerJdkVariants[0]}${commitHashTag} ${dockerImage}:${dockerBuildVersion}${commitHashTag}"
     }
   }
 }
@@ -580,12 +572,14 @@ task uploadDocker {
   }
 
   doLast {
+    def includeCommitHashInDockerTag = project.hasProperty('includeCommitHashInDockerTag') && project.property('includeCommitHashInDockerTag').toBoolean()
+    def commitHashTag = includeCommitHashInDockerTag ? '-' + grgit.head().getAbbreviatedId() : ''
     for (def variant in dockerJdkVariants) {
       def tags = ""
-      versionPrefixes.forEach { prefix -> tags += "-t ${dockerImage}:${prefix.trim()}-${variant}-${architecture} "}
+      versionPrefixes.forEach { prefix -> tags += "-t ${dockerImage}:${prefix.trim()}-${variant}-${architecture}${commitHashTag} "}
 
       if (variant == dockerJdkVariants[0]) {
-        versionPrefixes.forEach { prefix -> tags += "-t ${dockerImage}:${prefix.trim()}-${architecture} "}
+        versionPrefixes.forEach { prefix -> tags += "-t ${dockerImage}:${prefix.trim()}-${architecture}${commitHashTag} "}
       }
 
       copy {

storage/src/main/java/tech/pegasys/teku/storage/server/kvstore/dataaccess/CombinedKvStoreDao.java

@@ -336,16 +336,12 @@ public Optional<UInt64> getOptimisticTransitionBlockSlot() {
 
   @Override
   public Optional<Bytes> getBlobSidecar(final SlotAndBlockRootAndBlobIndex key) {
-    return db.get(
-        schema.getColumnBlobSidecarBySlotRootBlobIndex(),
-        new SlotAndBlockRootAndBlobIndex(key.getSlot(), key.getBlockRoot(), key.getBlobIndex()));
+    return db.get(schema.getColumnBlobSidecarBySlotRootBlobIndex(), key);
   }
 
   @Override
   public Optional<Bytes> getNonCanonicalBlobSidecar(final SlotAndBlockRootAndBlobIndex key) {
-    return db.get(
-        schema.getColumnNonCanonicalBlobSidecarBySlotRootBlobIndex(),
-        new SlotAndBlockRootAndBlobIndex(key.getSlot(), key.getBlockRoot(), key.getBlobIndex()));
+    return db.get(schema.getColumnNonCanonicalBlobSidecarBySlotRootBlobIndex(), key);
   }
 
   @MustBeClosed

validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/ValidatorRestApi.java

@@ -134,7 +134,7 @@ public static RestApi create(
         .endpoint(new DeleteFeeRecipient(proposerConfigManager))
         .endpoint(new DeleteGasLimit(proposerConfigManager))
         .endpoint(new PostVoluntaryExit(voluntaryExitDataProvider))
-        .endpoint(new GetGraffiti())
+        .endpoint(new GetGraffiti(keyManager))
         .endpoint(new SetGraffiti(keyManager, graffitiManager))
         .endpoint(new DeleteGraffiti(keyManager, graffitiManager))
         .sslCertificate(config.getRestApiKeystoreFile(), config.getRestApiKeystorePasswordFile())

validator/client/src/main/java/tech/pegasys/teku/validator/client/restapi/apis/GetGraffiti.java

@@ -14,38 +14,51 @@
 package tech.pegasys.teku.validator.client.restapi.apis;
 
 import static tech.pegasys.teku.ethereum.json.types.SharedApiTypes.PUBKEY_API_TYPE;
+import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND;
 import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK;
-import static tech.pegasys.teku.infrastructure.json.types.CoreTypes.STRING_TYPE;
 import static tech.pegasys.teku.validator.client.restapi.ValidatorRestApi.TAG_GRAFFITI;
 import static tech.pegasys.teku.validator.client.restapi.ValidatorTypes.PARAM_PUBKEY_TYPE;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
+import java.nio.charset.StandardCharsets;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
-import org.apache.commons.lang3.NotImplementedException;
+import org.apache.tuweni.bytes.Bytes;
+import org.apache.tuweni.bytes.Bytes32;
 import tech.pegasys.teku.bls.BLSPublicKey;
+import tech.pegasys.teku.infrastructure.json.types.DeserializableTypeDefinition;
 import tech.pegasys.teku.infrastructure.json.types.SerializableTypeDefinition;
 import tech.pegasys.teku.infrastructure.restapi.endpoints.EndpointMetadata;
 import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiEndpoint;
 import tech.pegasys.teku.infrastructure.restapi.endpoints.RestApiRequest;
+import tech.pegasys.teku.validator.api.Bytes32Parser;
+import tech.pegasys.teku.validator.client.KeyManager;
+import tech.pegasys.teku.validator.client.Validator;
 
 public class GetGraffiti extends RestApiEndpoint {
-  public static final String ROUTE = "/eth/v1/validator/{pubkey}/graffiti";
+  static final String ROUTE = "/eth/v1/validator/{pubkey}/graffiti";
+  private final KeyManager keyManager;
 
-  private static final SerializableTypeDefinition<GraffitiResponse> GRAFFITI_TYPE =
+  public static final DeserializableTypeDefinition<Bytes32> GRAFFITI_TYPE =
+      DeserializableTypeDefinition.string(Bytes32.class)
+          .formatter(GetGraffiti::processGraffitiString)
+          .parser(Bytes32Parser::toBytes32)
+          .build();
+
+  private static final SerializableTypeDefinition<GraffitiResponse> GRAFFITI_RESPONSE_TYPE =
       SerializableTypeDefinition.object(GraffitiResponse.class)
           .withOptionalField("pubkey", PUBKEY_API_TYPE, GraffitiResponse::getPublicKey)
-          .withField("graffiti", STRING_TYPE, GraffitiResponse::getGraffiti)
+          .withField("graffiti", GRAFFITI_TYPE, GraffitiResponse::getGraffiti)
           .build();
 
   private static final SerializableTypeDefinition<GraffitiResponse> RESPONSE_TYPE =
       SerializableTypeDefinition.object(GraffitiResponse.class)
           .name("GraffitiResponse")
-          .withField("data", GRAFFITI_TYPE, Function.identity())
+          .withField("data", GRAFFITI_RESPONSE_TYPE, Function.identity())
           .build();
 
-  public GetGraffiti() {
+  public GetGraffiti(final KeyManager keyManager) {
     super(
         EndpointMetadata.get(ROUTE)
             .operationId("getGraffiti")
@@ -58,20 +71,36 @@ public GetGraffiti() {
             .response(SC_OK, "Success response", RESPONSE_TYPE)
             .withAuthenticationResponses()
             .withNotFoundResponse()
-            .withNotImplementedResponse()
             .build());
+    this.keyManager = keyManager;
   }
 
   @Override
-  public void handleRequest(RestApiRequest request) throws JsonProcessingException {
-    throw new NotImplementedException("Not implemented");
+  public void handleRequest(final RestApiRequest request) throws JsonProcessingException {
+    final BLSPublicKey publicKey = request.getPathParameter(PARAM_PUBKEY_TYPE);
+
+    final Optional<Validator> maybeValidator = keyManager.getValidatorByPublicKey(publicKey);
+    if (maybeValidator.isEmpty()) {
+      request.respondError(SC_NOT_FOUND, "Validator not found");
+      return;
+    }
+
+    request.respondOk(new GraffitiResponse(publicKey, maybeValidator.get().getGraffiti()));
+  }
+
+  private static String processGraffitiString(final Bytes32 graffiti) {
+    return new String(graffiti.toArrayUnsafe(), StandardCharsets.UTF_8).strip().replace("\0", "");
   }
 
   static class GraffitiResponse {
     private final Optional<BLSPublicKey> publicKey;
-    private final String graffiti;
+    private final Bytes32 graffiti;
+
+    GraffitiResponse(final BLSPublicKey publicKey, final Optional<Bytes32> graffiti) {
+      this(publicKey, graffiti.orElse(Bytes32Parser.toBytes32(Bytes.EMPTY.toArray())));
+    }
 
-    GraffitiResponse(final BLSPublicKey publicKey, final String graffiti) {
+    GraffitiResponse(final BLSPublicKey publicKey, final Bytes32 graffiti) {
       this.publicKey = Optional.of(publicKey);
       this.graffiti = graffiti;
     }
@@ -80,19 +109,19 @@ Optional<BLSPublicKey> getPublicKey() {
       return publicKey;
     }
 
-    String getGraffiti() {
+    Bytes32 getGraffiti() {
       return graffiti;
     }
 
     @Override
-    public boolean equals(Object o) {
+    public boolean equals(final Object o) {
       if (this == o) {
         return true;
       }
       if (o == null || getClass() != o.getClass()) {
         return false;
       }
-      GraffitiResponse that = (GraffitiResponse) o;
+      final GraffitiResponse that = (GraffitiResponse) o;
       return Objects.equals(publicKey, that.publicKey) && Objects.equals(graffiti, that.graffiti);
     }
 

validator/client/src/test/java/tech/pegasys/teku/validator/client/restapi/apis/GetGraffitiTest.java

@@ -14,30 +14,76 @@
 package tech.pegasys.teku.validator.client.restapi.apis;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_BAD_REQUEST;
 import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_FORBIDDEN;
 import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_INTERNAL_SERVER_ERROR;
-import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_IMPLEMENTED;
+import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_NOT_FOUND;
 import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_OK;
 import static tech.pegasys.teku.infrastructure.http.HttpStatusCodes.SC_UNAUTHORIZED;
 import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.getResponseStringFromMetadata;
 import static tech.pegasys.teku.infrastructure.restapi.MetadataTestUtil.verifyMetadataErrorResponse;
+import static tech.pegasys.teku.spec.generator.signatures.NoOpLocalSigner.NO_OP_SIGNER;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
+import java.io.IOException;
+import java.util.Optional;
+import org.apache.tuweni.bytes.Bytes32;
 import org.junit.jupiter.api.Test;
+import tech.pegasys.teku.bls.BLSPublicKey;
+import tech.pegasys.teku.infrastructure.http.HttpErrorResponse;
+import tech.pegasys.teku.infrastructure.restapi.StubRestApiRequest;
 import tech.pegasys.teku.spec.TestSpecFactory;
 import tech.pegasys.teku.spec.util.DataStructureUtil;
+import tech.pegasys.teku.validator.api.Bytes32Parser;
+import tech.pegasys.teku.validator.api.GraffitiProvider;
+import tech.pegasys.teku.validator.client.OwnedKeyManager;
+import tech.pegasys.teku.validator.client.Validator;
 
 class GetGraffitiTest {
-  private final GetGraffiti handler = new GetGraffiti();
+  private final OwnedKeyManager keyManager = mock(OwnedKeyManager.class);
+  private final GetGraffiti handler = new GetGraffiti(keyManager);
+  private StubRestApiRequest request;
+
+  final String stringGraffiti = "Test graffiti";
+  final Bytes32 bytesGraffiti = Bytes32Parser.toBytes32(stringGraffiti);
 
   private final DataStructureUtil dataStructureUtil =
       new DataStructureUtil(TestSpecFactory.createDefault());
 
+  @Test
+  void shouldGetGraffiti() throws JsonProcessingException {
+    checkGraffiti(Optional.of(bytesGraffiti));
+  }
+
+  @Test
+  void shouldGetEmptyGraffiti() throws JsonProcessingException {
+    checkGraffiti(Optional.empty());
+  }
+
+  @Test
+  void shouldHandleValidatorNotFound() throws IOException {
+    request =
+        StubRestApiRequest.builder()
+            .metadata(handler.getMetadata())
+            .pathParameter("pubkey", dataStructureUtil.randomPublicKey().toHexString())
+            .build();
+
+    when(keyManager.getValidatorByPublicKey(any())).thenReturn(Optional.empty());
+
+    handler.handleRequest(request);
+    assertThat(request.getResponseCode()).isEqualTo(SC_NOT_FOUND);
+    assertThat(request.getResponseBody())
+        .isEqualTo(new HttpErrorResponse(SC_NOT_FOUND, "Validator not found"));
+  }
+
   @Test
   void metadata_shouldHandle200() throws JsonProcessingException {
     final GetGraffiti.GraffitiResponse response =
-        new GetGraffiti.GraffitiResponse(dataStructureUtil.randomPublicKey(), "Test graffiti");
+        new GetGraffiti.GraffitiResponse(dataStructureUtil.randomPublicKey(), bytesGraffiti);
     final String responseData = getResponseStringFromMetadata(handler, SC_OK, response);
     assertThat(responseData)
         .isEqualTo(
@@ -66,8 +112,23 @@ void metadata_shouldHandle500() throws JsonProcessingException {
     verifyMetadataErrorResponse(handler, SC_INTERNAL_SERVER_ERROR);
   }
 
-  @Test
-  void metadata_shouldHandle501() throws JsonProcessingException {
-    verifyMetadataErrorResponse(handler, SC_NOT_IMPLEMENTED);
+  private void checkGraffiti(final Optional<Bytes32> graffiti) throws JsonProcessingException {
+    final GraffitiProvider provider = () -> graffiti;
+    final BLSPublicKey publicKey = dataStructureUtil.randomPublicKey();
+    request =
+        StubRestApiRequest.builder()
+            .metadata(handler.getMetadata())
+            .pathParameter("pubkey", publicKey.toHexString())
+            .build();
+
+    final Validator validator = new Validator(publicKey, NO_OP_SIGNER, provider);
+    when(keyManager.getValidatorByPublicKey(eq(publicKey))).thenReturn(Optional.of(validator));
+
+    handler.handleRequest(request);
+
+    final GetGraffiti.GraffitiResponse expectedResponse =
+        new GetGraffiti.GraffitiResponse(publicKey, graffiti);
+    assertThat(request.getResponseCode()).isEqualTo(SC_OK);
+    assertThat(request.getResponseBody()).isEqualTo(expectedResponse);
   }
 }

validator/client/src/test/resources/tech/pegasys/teku/validator/client/restapi/paths/_eth_v1_validator_{pubkey}_graffiti.json

@@ -58,16 +58,6 @@
           }
         }
       },
-      "501" : {
-        "description" : "Not implemented",
-        "content" : {
-          "application/json" : {
-            "schema" : {
-              "$ref" : "#/components/schemas/HttpErrorResponse"
-            }
-          }
-        }
-      },
       "400" : {
         "description" : "The request could not be processed, check the response for more information.",
         "content" : {