Make error messages to be constants.

2025-02-22 11:18:25 +00:00 · 2021-04-08 13:49:28 +03:00 · 2021-04-08 13:49:28 +03:00 · b3ad573b1f
commit b3ad573b1f
parent 934cc453d9
4 changed files with 218 additions and 156 deletions
--- a/beacon_chain/rpc/beacon_rest_api.nim
+++ b/beacon_chain/rpc/beacon_rest_api.nim
@ -140,16 +140,16 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let bslot =
      block:
        if state_id.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid state_id",
+          return RestApiResponse.jsonError(Http400, InvalidStateIdValueError,
                                           $state_id.error())
        let bres = node.getBlockSlot(state_id.get())
        if bres.isErr():
-          return RestApiResponse.jsonError(Http404, "State not found",
+          return RestApiResponse.jsonError(Http404, StateNotFoundError,
                                           $bres.error())
        bres.get()
    node.withStateForBlockSlot(bslot):
      return RestApiResponse.jsonResponse((root: hashedState().root))
-    return RestApiResponse.jsonError(Http500, "Internal server error")
+    return RestApiResponse.jsonError(Http500, InternalServerError)

  # https://ethereum.github.io/eth2.0-APIs/#/Beacon/getStateFork
  router.api(MethodGet, "/api/eth/v1/beacon/states/{state_id}/fork") do (
@ -157,11 +157,11 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let bslot =
      block:
        if state_id.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid state_id",
+          return RestApiResponse.jsonError(Http400, InvalidStateIdValueError,
                                           $state_id.error())
        let bres = node.getBlockSlot(state_id.get())
        if bres.isErr():
-          return RestApiResponse.jsonError(Http404, "State not found",
+          return RestApiResponse.jsonError(Http404, StateNotFoundError,
                                           $bres.error())
        bres.get()
    node.withStateForBlockSlot(bslot):
@ -172,7 +172,7 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
          epoch: state().fork.epoch
        )
      )
-    return RestApiResponse.jsonError(Http500, "Internal server error")
+    return RestApiResponse.jsonError(Http500, InternalServerError)

  # https://ethereum.github.io/eth2.0-APIs/#/Beacon/getStateFinalityCheckpoints
  router.api(MethodGet,
@ -181,11 +181,11 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let bslot =
      block:
        if state_id.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid state_id",
+          return RestApiResponse.jsonError(Http400, InvalidStateIdValueError,
                                           $state_id.error())
        let bres = node.getBlockSlot(state_id.get())
        if bres.isErr():
-          return RestApiResponse.jsonError(Http404, "State not found",
+          return RestApiResponse.jsonError(Http404, StateNotFoundError,
                                           $bres.error())
        bres.get()
    node.withStateForBlockSlot(bslot):
@ -196,7 +196,7 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
          finalized: state().finalized_checkpoint
        )
      )
-    return RestApiResponse.jsonError(Http500, "Internal server error")
+    return RestApiResponse.jsonError(Http500, InternalServerError)

  # https://ethereum.github.io/eth2.0-APIs/#/Beacon/getStateValidators
  router.api(MethodGet, "/api/eth/v1/beacon/states/{state_id}/validators") do (
@ -205,33 +205,33 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let bslot =
      block:
        if state_id.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid state_id",
+          return RestApiResponse.jsonError(Http400, InvalidStateIdValueError,
                                           $state_id.error())
        let bres = node.getBlockSlot(state_id.get())
        if bres.isErr():
-          return RestApiResponse.jsonError(Http404, "State not found",
+          return RestApiResponse.jsonError(Http404, StateNotFoundError,
                                           $bres.error())
        bres.get()
    let validatorIds =
      block:
        if id.isErr():
          return RestApiResponse.jsonError(Http400,
-                                           "Invalid validator identifier(s)")
+                                           InvalidValidatorIdValueError)
        let ires = id.get()
        if len(ires) > MaximumValidatorIds:
          return RestApiResponse.jsonError(Http400,
-                                         "Maximum number of id values exceeded")
+                                           MaximumNumberOfValidatorIdsError)
        ires

    let validatorsMask =
      block:
        if status.isErr():
          return RestApiResponse.jsonError(Http400,
-                                           "Invalid validator status(es)")
+                                           InvalidValidatorStatusValueError)
        let res = validateFilter(status.get())
        if res.isErr():
          return RestApiResponse.jsonError(Http400,
-                                           "Invalid validator status value",
+                                           InvalidValidatorStatusValueError,
                                           $res.error())
        res.get()

@ -243,8 +243,7 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
          case item.kind
          of ValidatorQueryKind.Key:
            if item.key in res1:
-              return RestApiResponse.jsonError(Http400,
-                                           "Only unique validator keys allowed")
+              return RestApiResponse.jsonError(Http400, UniqueValidatorKeyError)
            res1.incl(item.key)
          of ValidatorQueryKind.Index:
            let vitem =
@ -254,15 +253,15 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
                  case vres.error()
                  of ValidatorIndexError.TooHighValue:
                    return RestApiResponse.jsonError(Http400,
-                                              "Incorrect validator index value")
+                                                TooHighValidatorIndexValueError)
                  of ValidatorIndexError.UnsupportedValue:
                    return RestApiResponse.jsonError(Http500,
-                                            "Unsupported validator index value")
+                                            UnsupportedValidatorIndexValueError)
                vres.get()

            if vitem in res2:
              return RestApiResponse.jsonError(Http400,
-                                        "Only unique validator indexes allowed")
+                                               UniqueValidatorIndexError)
            res2.incl(vitem)
        (res1, res2)

@ -304,7 +303,7 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
            ))
      return RestApiResponse.jsonResponse(res)

-    return RestApiResponse.jsonError(Http500, "Internal server error")
+    return RestApiResponse.jsonError(Http500, InternalServerError)

  # https://ethereum.github.io/eth2.0-APIs/#/Beacon/getStateValidator
  router.api(MethodGet,
@ -313,16 +312,16 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let bslot =
      block:
        if state_id.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid state_id",
+          return RestApiResponse.jsonError(Http400, InvalidStateIdValueError,
                                           $state_id.error())
        let bres = node.getBlockSlot(state_id.get())
        if bres.isErr():
-          return RestApiResponse.jsonError(Http404, "State not found",
+          return RestApiResponse.jsonError(Http404, StateNotFoundError,
                                           $bres.error())
        bres.get()
    if validator_id.isErr():
-      return RestApiResponse.jsonError(Http400, "Invalid validator_id",
-                                                $validator_id.error())
+      return RestApiResponse.jsonError(Http400, InvalidValidatorIdValueError,
+                                       $validator_id.error())
    node.withStateForBlockSlot(bslot):
      let current_epoch = get_current_epoch(node.chainDag.headState.data.data)
      let vid = validator_id.get()
@ -342,8 +341,8 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
              )
            else:
              return RestApiResponse.jsonError(Http400,
-                                          "Could not obtain validator's status")
-        return RestApiResponse.jsonError(Http404, "Could not find validator")
+                                               ValidatorStatusNotFoundError)
+        return RestApiResponse.jsonError(Http404, ValidatorNotFoundError)
      of ValidatorQueryKind.Index:
        let vindex =
          block:
@ -352,14 +351,14 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
              case vres.error()
              of ValidatorIndexError.TooHighValue:
                return RestApiResponse.jsonError(Http400,
-                                              "Incorrect validator index value")
+                                                TooHighValidatorIndexValueError)
              of ValidatorIndexError.UnsupportedValue:
                return RestApiResponse.jsonError(Http500,
-                                            "Unsupported validator index value")
+                                            UnsupportedValidatorIndexValueError)
            vres.get()

        if uint64(vindex) >= uint64(len(state().validators)):
-          return RestApiResponse.jsonError(Http404, "Could not find validator")
+          return RestApiResponse.jsonError(Http404, ValidatorNotFoundError)
        let validator = state().validators[vindex]
        let sres = validator.getStatus(current_epoch)
        if sres.isOk():
@ -373,8 +372,8 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
          )
        else:
          return RestApiResponse.jsonError(Http400,
-                                          "Could not obtain validator's status")
-    return RestApiResponse.jsonError(Http500, "Internal server error")
+                                           ValidatorStatusNotFoundError)
+    return RestApiResponse.jsonError(Http500, InternalServerError)

  # https://ethereum.github.io/eth2.0-APIs/#/Beacon/getStateValidatorBalances
  router.api(MethodGet,
@ -383,22 +382,22 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let bslot =
      block:
        if state_id.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid state_id",
+          return RestApiResponse.jsonError(Http400, InvalidStateIdValueError,
                                           $state_id.error())
        let bres = node.getBlockSlot(state_id.get())
        if bres.isErr():
-          return RestApiResponse.jsonError(Http404, "State not found",
+          return RestApiResponse.jsonError(Http404, StateNotFoundError,
                                           $bres.error())
        bres.get()
    let validatorIds =
      block:
        if id.isErr():
          return RestApiResponse.jsonError(Http400,
-                                           "Invalid validator identifier(s)")
+                                           InvalidValidatorIdValueError)
        let ires = id.get()
        if len(ires) > MaximumValidatorIds:
          return RestApiResponse.jsonError(Http400,
-                                         "Maximum number of id values exceeded")
+                                           MaximumNumberOfValidatorIdsError)
        ires
    let (keySet, indexSet) =
      block:
@ -409,7 +408,7 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
          of ValidatorQueryKind.Key:
            if item.key in res1:
              return RestApiResponse.jsonError(Http400,
-                                           "Only unique validator keys allowed")
+                                               UniqueValidatorKeyError)
            res1.incl(item.key)
          of ValidatorQueryKind.Index:
            let vitem =
@ -419,14 +418,14 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
                  case vres.error()
                  of ValidatorIndexError.TooHighValue:
                    return RestApiResponse.jsonError(Http400,
-                                              "Incorrect validator index value")
+                                                TooHighValidatorIndexValueError)
                  of ValidatorIndexError.UnsupportedValue:
                    return RestApiResponse.jsonError(Http500,
-                                            "Unsupported validator index value")
+                                            UnsupportedValidatorIndexValueError)
                vres.get()
            if vitem in res2:
              return RestApiResponse.jsonError(Http400,
-                                        "Only unique validator indexes allowed")
+                                               UniqueValidatorIndexError)
            res2.incl(vitem)
        (res1, res2)
    node.withStateForBlockSlot(bslot):
@ -464,7 +463,7 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
            ))
      return RestApiResponse.jsonResponse(res)

-    return RestApiResponse.jsonError(Http500, "Internal server error")
+    return RestApiResponse.jsonError(Http500, InternalServerError)

  # https://ethereum.github.io/eth2.0-APIs/#/Beacon/getEpochCommittees
  router.api(MethodGet,
@ -474,23 +473,22 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let bslot =
      block:
        if state_id.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid state_id",
+          return RestApiResponse.jsonError(Http400, InvalidStateIdValueError,
                                           $state_id.error())
        let bres = node.getBlockSlot(state_id.get())
        if bres.isErr():
-          return RestApiResponse.jsonError(Http404, "State not found",
+          return RestApiResponse.jsonError(Http404, StateNotFoundError,
                                           $bres.error())
        bres.get()
    let vepoch =
      if epoch.isSome():
        let repoch = epoch.get()
        if repoch.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid epoch value",
+          return RestApiResponse.jsonError(Http400, InvalidEpochValueError,
                                           $repoch.error())
        let res = repoch.get()
        if res > MaxEpoch:
-          return RestApiResponse.jsonError(Http400, "Requesting epoch for " &
-                                           "which slot would overflow")
+          return RestApiResponse.jsonError(Http400, EpochOverflowValueError)
        some(res)
      else:
        none[Epoch]()
@ -498,7 +496,8 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
      if index.isSome():
        let rindex = index.get()
        if rindex.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid index value",
+          return RestApiResponse.jsonError(Http400,
+                                           InvalidCommitteeIndexValueError,
                                           $rindex.error())
        some(rindex.get())
      else:
@ -507,7 +506,7 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
      if slot.isSome():
        let rslot = slot.get()
        if rslot.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid slot value",
+          return RestApiResponse.jsonError(Http400, InvalidSlotValueError,
                                           $rslot.error())
        some(rslot.get())
      else:
@ -547,7 +546,7 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =

      return RestApiResponse.jsonResponse(res)

-    return RestApiResponse.jsonError(Http500, "Internal server error")
+    return RestApiResponse.jsonError(Http500, InternalServerError)

  # https://ethereum.github.io/eth2.0-APIs/#/Beacon/getBlockHeaders
  router.api(MethodGet, "/api/eth/v1/beacon/headers") do (
@ -558,7 +557,7 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
      if slot.isSome():
        let rslot = slot.get()
        if rslot.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid slot value",
+          return RestApiResponse.jsonError(Http400, InvalidSlotValueError,
                                           $rslot.error())
        rslot.get()
      else:
@ -567,9 +566,9 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    if parent_root.isSome():
      let rroot = parent_root.get()
      if rroot.isErr():
-        return RestApiResponse.jsonError(Http400, "Invalid parent_root value",
+        return RestApiResponse.jsonError(Http400, InvalidParentRootValueError,
                                         $rroot.error())
-      return RestApiResponse.jsonError(Http500, "Not implemented yet")
+      return RestApiResponse.jsonError(Http500, NoImplementationError)

    let bdata =
      block:
@ -577,13 +576,12 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
          block:
            let res = node.getCurrentHead(qslot)
            if res.isErr():
-              return RestApiResponse.jsonError(Http404,
-                                               "Slot number is too far away",
+              return RestApiResponse.jsonError(Http404, SlotNotFoundError,
                                               $res.error())
            res.get()
        let blockSlot = head.atSlot(qslot)
        if isNil(blockSlot.blck):
-          return RestApiResponse.jsonError(Http404, "Block header not found")
+          return RestApiResponse.jsonError(Http404, BlockNotFoundError)
        node.chainDag.get(blockSlot.blck)

    return RestApiResponse.jsonResponse(
@ -609,11 +607,11 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let bdata =
      block:
        if block_id.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid block_id",
+          return RestApiResponse.jsonError(Http400, InvalidBlockIdValueError,
                                           $block_id.error())
        let res = node.getBlockDataFromBlockIdent(block_id.get())
        if res.isErr():
-          return RestApiResponse.jsonError(Http404, "Block not found")
+          return RestApiResponse.jsonError(Http404, BlockNotFoundError)
        res.get()

    return RestApiResponse.jsonResponse(
@ -639,32 +637,26 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let blck =
      block:
        if contentBody.isNone():
-          return RestApiResponse.jsonError(Http400, "Empty request's body")
+          return RestApiResponse.jsonError(Http400, EmptyRequestBodyError)
        let dres = decodeBody(SignedBeaconBlock, contentBody.get())
        if dres.isErr():
-          return RestApiResponse.jsonError(Http400, "Unable to decode block " &
-                                           "object", $dres.error())
+          return RestApiResponse.jsonError(Http400, InvalidBlockObjectError,
+                                           $dres.error())
        dres.get()
    let head = node.chainDag.head
    if not(node.isSynced(head)):
-      return RestApiResponse.jsonError(Http503, "Beacon node is currently " &
-        "syncing and not serving request on that endpoint")
+      return RestApiResponse.jsonError(Http503, BeaconNodeInSyncError)

    if head.slot >= blck.message.slot:
      node.network.broadcast(getBeaconBlocksTopic(node.forkDigest), blck)
-      return RestApiResponse.jsonError(Http202, "The block failed " &
-        "validation, but was successfully broadcast anyway. It was not " &
-        "integrated into the beacon node's database.")
+      return RestApiResponse.jsonError(Http202, BlockValidationError)
    else:
      let res = proposeSignedBlock(node, head, AttachedValidator(), blck)
      if res == head:
        node.network.broadcast(getBeaconBlocksTopic(node.forkDigest), blck)
-        return RestApiResponse.jsonError(Http202, "The block failed " &
-          "validation, but was successfully broadcast anyway. It was not " &
-          "integrated into the beacon node's database.")
+        return RestApiResponse.jsonError(Http202, BlockValidationError)
      else:
-        return RestApiResponse.jsonError(Http200, "The block was validated " &
-          "successfully and has been broadcast")
+        return RestApiResponse.jsonError(Http200, BlockValidationSuccess)

  # https://ethereum.github.io/eth2.0-APIs/#/Beacon/getBlock
  router.api(MethodGet, "/api/eth/v1/beacon/blocks/{block_id}") do (
@ -672,11 +664,11 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let bdata =
      block:
        if block_id.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid block_id",
+          return RestApiResponse.jsonError(Http400, InvalidBlockIdValueError,
                                           $block_id.error())
        let res = node.getBlockDataFromBlockIdent(block_id.get())
        if res.isErr():
-          return RestApiResponse.jsonError(Http404, "Block not found")
+          return RestApiResponse.jsonError(Http404, BlockNotFoundError)
        res.get()
    return RestApiResponse.jsonResponse(bdata.data)

@ -686,11 +678,11 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let bdata =
      block:
        if block_id.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid block_id",
+          return RestApiResponse.jsonError(Http400, InvalidBlockIdValueError,
                                           $block_id.error())
        let res = node.getBlockDataFromBlockIdent(block_id.get())
        if res.isErr():
-          return RestApiResponse.jsonError(Http404, "Block not found")
+          return RestApiResponse.jsonError(Http404, BlockNotFoundError)
        res.get()
    return RestApiResponse.jsonResponse((root: bdata.data.root))

@ -701,11 +693,11 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let bdata =
      block:
        if block_id.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid block_id",
+          return RestApiResponse.jsonError(Http400, InvalidBlockIdValueError,
                                           $block_id.error())
        let res = node.getBlockDataFromBlockIdent(block_id.get())
        if res.isErr():
-          return RestApiResponse.jsonError(Http404, "Block not found")
+          return RestApiResponse.jsonError(Http404, BlockNotFoundError)
        res.get()
    return RestApiResponse.jsonResponse(
      bdata.data.message.body.attestations.asSeq()
@ -720,7 +712,7 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
        let rindex = committee_index.get()
        if rindex.isErr():
          return RestApiResponse.jsonError(Http400,
-                                           "Invalid committee_index value",
+                                           InvalidCommitteeIndexValueError,
                                           $rindex.error())
        some(rindex.get())
      else:
@ -729,7 +721,7 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
      if slot.isSome():
        let rslot = slot.get()
        if rslot.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid slot value",
+          return RestApiResponse.jsonError(Http400, InvalidSlotValueError,
                                           $rslot.error())
        some(rslot.get())
      else:
@ -745,11 +737,11 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let attestations =
      block:
        if contentBody.isNone():
-          return RestApiResponse.jsonError(Http400, "Empty request's body")
+          return RestApiResponse.jsonError(Http400, EmptyRequestBodyError)
        let dres = decodeBody(seq[Attestation], contentBody.get())
        if dres.isErr():
-          return RestApiResponse.jsonError(Http400, "Unable to decode " &
-                                           "attestation object(s)",
+          return RestApiResponse.jsonError(Http400,
+                                           InvalidAttestationObjectError,
                                           $dres.error())
        dres.get()

@ -766,11 +758,10 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
        node.sendAttestation(attestation)

    if len(failures) > 0:
-      return RestApiResponse.jsonErrorList(Http400, "Some failures happened",
+      return RestApiResponse.jsonErrorList(Http400, AttestationValidationError,
                                           failures)
    else:
-      return RestApiResponse.jsonError(Http200,
-                                       "Attestation(s) was broadcasted")
+      return RestApiResponse.jsonError(Http200, AttestationValidationSuccess)

  # https://ethereum.github.io/eth2.0-APIs/#/Beacon/getPoolAttesterSlashings
  router.api(MethodGet, "/api/eth/v1/beacon/pool/attester_slashings") do (
@ -790,21 +781,21 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let slashing =
      block:
        if contentBody.isNone():
-          return RestApiResponse.jsonError(Http400, "Empty request's body")
+          return RestApiResponse.jsonError(Http400, EmptyRequestBodyError)
        let dres = decodeBody(AttesterSlashing, contentBody.get())
        if dres.isErr():
-          return RestApiResponse.jsonError(Http400, "Unable to decode " &
-            "attester slashing object", $dres.error())
+          return RestApiResponse.jsonError(Http400,
+                                           InvalidAttesterSlashingObjectError,
+                                           $dres.error())
        let res = dres.get()
        let vres = node.exitPool[].validateAttesterSlashing(res)
        if vres.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid attester " &
-            "slashing, it will never pass validation so it's rejected",
-            $vres.error())
+          return RestApiResponse.jsonError(Http400,
+                                           AttesterSlashingValidationError,
+                                           $vres.error())
        res
    node.sendAttesterSlashing(slashing)
-    return RestApiResponse.jsonError(Http200,
-                                     "Attester slashing was broadcasted")
+    return RestApiResponse.jsonError(Http200, AttesterSlashingValidationSuccess)

  # https://ethereum.github.io/eth2.0-APIs/#/Beacon/getPoolProposerSlashings
  router.api(MethodGet, "/api/eth/v1/beacon/pool/proposer_slashings") do (
@ -824,21 +815,21 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let slashing =
      block:
        if contentBody.isNone():
-          return RestApiResponse.jsonError(Http400, "Empty request's body")
+          return RestApiResponse.jsonError(Http400, EmptyRequestBodyError)
        let dres = decodeBody(ProposerSlashing, contentBody.get())
        if dres.isErr():
-          return RestApiResponse.jsonError(Http400, "Unable to decode " &
-            "proposer slashing object", $dres.error())
+          return RestApiResponse.jsonError(Http400,
+                                           InvalidProposerSlashingObjectError,
+                                           $dres.error())
        let res = dres.get()
        let vres = node.exitPool[].validateProposerSlashing(res)
        if vres.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid proposer " &
-            "slashing, it will never pass validation so it's rejected",
-            $vres.error())
+          return RestApiResponse.jsonError(Http400,
+                                           ProposerSlashingValidationError,
+                                           $vres.error())
        res
    node.sendProposerSlashing(slashing)
-    return RestApiResponse.jsonError(Http200,
-                                     "Proposer slashing was broadcasted")
+    return RestApiResponse.jsonError(Http200, ProposerSlashingValidationSuccess)

  # https://ethereum.github.io/eth2.0-APIs/#/Beacon/getPoolVoluntaryExits
  router.api(MethodGet, "/api/eth/v1/beacon/pool/voluntary_exits") do (
@ -858,17 +849,18 @@ proc installBeaconApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let exit =
      block:
        if contentBody.isNone():
-          return RestApiResponse.jsonError(Http400, "Empty request's body")
+          return RestApiResponse.jsonError(Http400, EmptyRequestBodyError)
        let dres = decodeBody(SignedVoluntaryExit, contentBody.get())
        if dres.isErr():
-          return RestApiResponse.jsonError(Http400, "Unable to decode " &
-            "voluntary exit object", $dres.error())
+          return RestApiResponse.jsonError(Http400,
+                                           InvalidVoluntaryExitObjectError,
+                                           $dres.error())
        let res = dres.get()
        let vres = node.exitPool[].validateVoluntaryExit(res)
        if vres.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid voluntary exit, " &
-            "it will never pass validation so it's rejected", $vres.error())
+          return RestApiResponse.jsonError(Http400,
+                                           VoluntaryExitValidationError,
+                                           $vres.error())
        res
    node.sendVoluntaryExit(exit)
-    return RestApiResponse.jsonError(Http200,
-                                     "Voluntary exit was broadcasted")
+    return RestApiResponse.jsonError(Http200, VoluntaryExitValidationSuccess)
--- a/beacon_chain/rpc/debug_rest_api.nim
+++ b/beacon_chain/rpc/debug_rest_api.nim
@ -15,16 +15,16 @@ proc installDebugApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let bslot =
      block:
        if state_id.isErr():
-          return RestApiResponse.jsonError(Http400, "Invalid state_id",
+          return RestApiResponse.jsonError(Http400, InvalidStateIdValueError,
                                           $state_id.error())
        let bres = node.getBlockSlot(state_id.get())
        if bres.isErr():
-          return RestApiResponse.jsonError(Http404, "State not found",
+          return RestApiResponse.jsonError(Http404, StateNotFoundError,
                                           $bres.error())
        bres.get()
    node.withStateForBlockSlot(bslot):
      return RestApiResponse.jsonResponse(state())
-    return RestApiResponse.jsonError(Http500, "Internal server error")
+    return RestApiResponse.jsonError(Http500, InternalServerError)

  router.api(MethodGet,
             "/api/eth/v1/debug/beacon/heads") do () -> RestApiResponse:
--- a/beacon_chain/rpc/rest_utils.nim
+++ b/beacon_chain/rpc/rest_utils.nim
@ -29,6 +29,90 @@ const
  FarFutureEpochString* = "18446744073709551615"
  MaxEpoch* = compute_epoch_at_slot(not(0'u64))

+  BlockValidationError* =
+    "The block failed validation, but was successfully broadcast anyway. It " &
+    "was not integrated into the beacon node's database."
+  BlockValidationSuccess* =
+    "The block was validated successfully and has been broadcast"
+  BeaconNodeInSyncError* =
+    "Beacon node is currently syncing and not serving request on that endpoint"
+  BlockNotFoundError* =
+    "Block header/data has not been found"
+  EmptyRequestBodyError* =
+    "Empty request's body"
+  InvalidBlockObjectError* =
+    "Unable to decode block object(s)"
+  InvalidAttestationObjectError* =
+    "Unable to decode attestation object(s)"
+  AttestationValidationError* =
+    "Some errors happened while validating attestation(s)"
+  AttestationValidationSuccess* =
+    "Attestation object(s) was broadcasted"
+  InvalidAttesterSlashingObjectError* =
+    "Unable to decode attester slashing object(s)"
+  AttesterSlashingValidationError* =
+    "Invalid attester slashing, it will never pass validation so it's rejected"
+  AttesterSlashingValidationSuccess* =
+    "Attester slashing object was broadcasted"
+  InvalidProposerSlashingObjectError* =
+    "Unable to decode proposer slashing object(s)"
+  ProposerSlashingValidationError* =
+    "Invalid proposer slashing, it will never pass validation so it's rejected"
+  ProposerSlashingValidationSuccess* =
+    "Proposer slashing object was broadcasted"
+  InvalidVoluntaryExitObjectError* =
+    "Unable to decode voluntary exit object(s)"
+  VoluntaryExitValidationError* =
+    "Invalid voluntary exit, it will never pass validation so it's rejected"
+  VoluntaryExitValidationSuccess* =
+    "Voluntary exit object(s) was broadcasted"
+  InvalidParentRootValueError* =
+    "Invalid parent root value"
+  MissingSlotValueError* =
+    "Missing `slot` value"
+  InvalidSlotValueError* =
+    "Invalid slot value"
+  MissingCommitteeIndexValueError* =
+    "Missing `committee_index` value"
+  InvalidCommitteeIndexValueError* =
+    "Invalid committee index value"
+  InvalidEpochValueError* =
+    "Invalid epoch value"
+  InvalidStateIdValueError* =
+    "Invalid state identifier value"
+  InvalidBlockIdValueError* =
+    "Invalid block identifier value"
+  InvalidValidatorIdValueError* =
+    "Invalid validator's identifier value(s)"
+  MaximumNumberOfValidatorIdsError* =
+    "Maximum number of validator identifier values exceeded"
+  InvalidValidatorStatusValueError* =
+    "Invalid validator's status value error"
+  ValidatorNotFoundError* =
+    "Could not find validator"
+  ValidatorStatusNotFoundError* =
+    "Could not obtain validator's status"
+  UniqueValidatorKeyError* =
+    "Only unique validator's keys are allowed"
+  TooHighValidatorIndexValueError* =
+    "Validator index exceeds maximum number of validators allowed"
+  UnsupportedValidatorIndexValueError* =
+    "Validator index exceeds maximum supported number of validators"
+  UniqueValidatorIndexError* =
+    "Only unique validator's index are allowed"
+  StateNotFoundError* =
+    "State not found"
+  SlotNotFoundError* =
+    "Slot number is too far away"
+  NoHeadForSlotError* =
+    "Cound not find head for slot"
+  EpochOverflowValueError* =
+    "Requesting epoch for which slot would overflow"
+  InternalServerError* =
+    "Internal server error"
+  NoImplementationError* =
+    "Not implemented yet"
+
 type
  ValidatorQueryKind* {.pure.} = enum
    Index, Key
--- a/beacon_chain/rpc/validator_rest_api.nim
+++ b/beacon_chain/rpc/validator_rest_api.nim
@ -47,7 +47,7 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let indexList =
      block:
        if contentBody.isNone():
-          return RestApiResponse.jsonError(Http400, "Empty request's body")
+          return RestApiResponse.jsonError(Http400, EmptyRequestBodyError)
        let dres = decodeBody(seq[RestValidatorIndex], contentBody.get())
        if dres.isErr():
          return RestApiResponse.jsonError(Http400, "Unable to decode " &
@ -60,10 +60,10 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
            case vres.error()
            of ValidatorIndexError.TooHighValue:
              return RestApiResponse.jsonError(Http400,
-                                              "Incorrect validator index value")
+                                               TooHighValidatorIndexValueError)
            of ValidatorIndexError.UnsupportedValue:
              return RestApiResponse.jsonError(Http500,
-                                            "Unsupported validator index value")
+                                            UnsupportedValidatorIndexValueError)
          res.add(vres.get())
        if len(res) == 0:
          return RestApiResponse.jsonError(Http400, "Empty indexes list")
@ -71,23 +71,20 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let qepoch =
      block:
        if epoch.isErr():
-          return RestApiResponse.jsonError(Http400, "Incorrect epoch value",
+          return RestApiResponse.jsonError(Http400, InvalidEpochValueError,
                                           $epoch.error())
        let res = epoch.get()
        if res > MaxEpoch:
-          return RestApiResponse.jsonError(Http400, "Requesting epoch for " &
-                                           "which slot would overflow")
+          return RestApiResponse.jsonError(Http400, EpochOverflowValueError)
        res
    let qhead =
      block:
        let res = node.getCurrentHead(qepoch)
        if res.isErr():
          if not(node.isSynced(node.chainDag.head)):
-            return RestApiResponse.jsonError(Http503, "Beacon node is " &
-              "currently syncing and not serving request on that endpoint")
+            return RestApiResponse.jsonError(Http503, BeaconNodeInSyncError)
          else:
-            return RestApiResponse.jsonError(Http400,
-                                             "Cound not find head for slot",
+            return RestApiResponse.jsonError(Http400, NoHeadForSlotError,
                                             $res.error())
        res.get()
    let droot =
@ -97,8 +94,7 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
        )
        if isNil(bref):
          if not(node.isSynced(node.chainDag.head)):
-            return RestApiResponse.jsonError(Http503, "Beacon node is " &
-              "currently syncing and not serving request on that endpoint")
+            return RestApiResponse.jsonError(Http503, BeaconNodeInSyncError)
          else:
            return RestApiResponse.jsonError(Http400,
                                             "Cound not find slot data")
@ -141,23 +137,20 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let qepoch =
      block:
        if epoch.isErr():
-          return RestApiResponse.jsonError(Http400, "Incorrect epoch value",
+          return RestApiResponse.jsonError(Http400, InvalidEpochValueError,
                                           $epoch.error())
        let res = epoch.get()
        if res > MaxEpoch:
-          return RestApiResponse.jsonError(Http400, "Requesting epoch for " &
-                                           "which slot would overflow")
+          return RestApiResponse.jsonError(Http400, EpochOverflowValueError)
        res
    let qhead =
      block:
        let res = node.getCurrentHead(qepoch)
        if res.isErr():
          if not(node.isSynced(node.chainDag.head)):
-            return RestApiResponse.jsonError(Http503, "Beacon node is " &
-              "currently syncing and not serving request on that endpoint")
+            return RestApiResponse.jsonError(Http503, BeaconNodeInSyncError)
          else:
-            return RestApiResponse.jsonError(Http400,
-                                             "Cound not find head for slot",
+            return RestApiResponse.jsonError(Http400, NoHeadForSlotError,
                                             $res.error())
        res.get()
    let droot =
@ -167,11 +160,9 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
        )
        if isNil(bref):
          if not(node.isSynced(node.chainDag.head)):
-            return RestApiResponse.jsonError(Http503, "Beacon node is " &
-              "currently syncing and not serving request on that endpoint")
+            return RestApiResponse.jsonError(Http503, BeaconNodeInSyncError)
          else:
-            return RestApiResponse.jsonError(Http400,
-                                             "Cound not find slot data")
+            return RestApiResponse.jsonError(Http400, BlockNotFoundError)
        bref.root
      else:
        node.chainDag.genesis.root
@ -201,7 +192,7 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
        let qslot =
          block:
            if slot.isErr():
-              return RestApiResponse.jsonError(Http400, "Incorrect slot value",
+              return RestApiResponse.jsonError(Http400, InvalidSlotValueError,
                                               $slot.error())
            slot.get()
        let qrandao =
@ -230,11 +221,9 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
            let res = node.getCurrentHead(qslot)
            if res.isErr():
              if not(node.isSynced(node.chainDag.head)):
-                return RestApiResponse.jsonError(Http503, "Beacon node is " &
-                  "currently syncing and not serving request on that endpoint")
+                return RestApiResponse.jsonError(Http503, BeaconNodeInSyncError)
              else:
-                return RestApiResponse.jsonError(Http400,
-                                                 "Cound not find head for slot",
+                return RestApiResponse.jsonError(Http400, NoHeadForSlotError,
                                                 $res.error())
            res.get()
        let proposer = node.chainDag.getProposer(qhead, qslot)
@ -258,21 +247,21 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
        let qslot =
          block:
            if slot.isNone():
-              return RestApiResponse.jsonError(Http400, "Missing slot value")
+              return RestApiResponse.jsonError(Http400, MissingSlotValueError)
            let res = slot.get()
            if res.isErr():
-              return RestApiResponse.jsonError(Http400, "Incorrect slot value",
+              return RestApiResponse.jsonError(Http400, InvalidSlotValueError,
                                               $res.error())
            res.get()
        let qindex =
          block:
            if committee_index.isNone():
              return RestApiResponse.jsonError(Http400,
-                                               "Missing committee_index value")
+                                               MissingCommitteeIndexValueError)
            let res = committee_index.get()
            if res.isErr():
-              return RestApiResponse.jsonError(Http400, "Incorrect " &
-                                               "committee_index value",
+              return RestApiResponse.jsonError(Http400,
+                                               InvalidCommitteeIndexValueError,
                                               $res.error())
            res.get()
        let qhead =
@ -280,11 +269,9 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
            let res = node.getCurrentHead(qslot)
            if res.isErr():
              if not(node.isSynced(node.chainDag.head)):
-                return RestApiResponse.jsonError(Http503, "Beacon node is " &
-                  "currently syncing and not serving request on that endpoint")
+                return RestApiResponse.jsonError(Http503, BeaconNodeInSyncError)
              else:
-                return RestApiResponse.jsonError(Http400,
-                                                 "Cound not find head for slot",
+                return RestApiResponse.jsonError(Http400, NoHeadForSlotError,
                                                 $res.error())
            res.get()
        let epochRef = node.chainDag.getEpochRef(qhead, qslot.epoch)
@ -300,10 +287,10 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
        let qslot =
          block:
            if slot.isNone():
-              return RestApiResponse.jsonError(Http400, "Missing slot value")
+              return RestApiResponse.jsonError(Http400, MissingSlotValueError)
            let res = slot.get()
            if res.isErr():
-              return RestApiResponse.jsonError(Http400, "Incorrect slot value",
+              return RestApiResponse.jsonError(Http400, InvalidSlotValueError,
                                               $res.error())
            res.get()
        let qroot =
@ -330,7 +317,7 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let payload =
      block:
        if contentBody.isNone():
-          return RestApiResponse.jsonError(Http400, "Empty request's body")
+          return RestApiResponse.jsonError(Http400, EmptyRequestBodyError)
        let dres = decodeBody(SignedAggregateAndProof, contentBody.get())
        if dres.isErr():
          return RestApiResponse.jsonError(Http400, "Unable to decode " &
@ -357,7 +344,7 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
    let requests =
      block:
        if contentBody.isNone():
-          return RestApiResponse.jsonError(Http400, "Empty request's body")
+          return RestApiResponse.jsonError(Http400, EmptyRequestBodyError)
        let dres = decodeBody(seq[RestCommitteeSubscriptionTuple],
                              contentBody.get())
        if dres.isErr():
@ -365,13 +352,12 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
            "subscription request(s)")
        dres.get()
    if not(node.isSynced(node.chainDag.head)):
-      return RestApiResponse.jsonError(Http503, "Beacon node is " &
-        "currently syncing and not serving request on that endpoint")
+      return RestApiResponse.jsonError(Http503, BeaconNodeInSyncError)

    for request in requests:
      if uint64(request.committee_index) >= uint64(ATTESTATION_SUBNET_COUNT):
-        return RestApiResponse.jsonError(Http400, "Invalid committee_index " &
-                                         "value")
+        return RestApiResponse.jsonError(Http400,
+                                         InvalidCommitteeIndexValueError)
      let validator_pubkey =
        block:
          let idx = request.validator_index
@ -400,4 +386,4 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
        get_committee_count_per_slot(epochRef), request.slot,
        request.committee_index)
      )
-    return RestApiResponse.jsonError(Http500, "Not implemented yet")
+    return RestApiResponse.jsonError(Http500, NoImplementationError)