raises for beacon validators & router (#5826)

Changes here are more significant because of some good old tech debt in
block production which has grown quite hairy - the reduction in
exception handling at least provides some steps in the right direction.

beacon_chain/el/el_manager.nim

@@ -768,7 +768,7 @@ proc getPayload*(m: ELManager,
                  randomData: Eth2Digest,
                  suggestedFeeRecipient: Eth1Address,
                  withdrawals: seq[capella.Withdrawal]):
-                 Future[Opt[PayloadType]] {.async.} =
+                 Future[Opt[PayloadType]] {.async: (raises: [CancelledError]).} =
   if m.elConnections.len == 0:
     return err()
 
@@ -790,6 +790,7 @@ proc getPayload*(m: ELManager,
     ))
     requestsCompleted = allFutures(requests)
 
+  # TODO cancel requests on cancellation
   await requestsCompleted or deadline
 
   var bestPayloadIdx = none int
@@ -807,40 +808,40 @@ proc getPayload*(m: ELManager,
           # TODO: The engine_api module may offer an alternative API where it is guaranteed
           #       to return the correct response type (i.e. the rule below will be enforced
           #       during deserialization).
-          if req.read.executionPayload.withdrawals.isNone:
+          if req.value().executionPayload.withdrawals.isNone:
             warn "Execution client returned a block without a 'withdrawals' field for a post-Shanghai block",
                   url = m.elConnections[idx].engineUrl.url
             continue
 
-        if engineApiWithdrawals != req.read.executionPayload.withdrawals.maybeDeref:
+        if engineApiWithdrawals != req.value().executionPayload.withdrawals.maybeDeref:
           # otherwise it formats as "@[(index: ..., validatorIndex: ...,
           # address: ..., amount: ...), (index: ..., validatorIndex: ...,
           # address: ..., amount: ...)]"
           warn "Execution client did not return correct withdrawals",
             withdrawals_from_cl_len = engineApiWithdrawals.len,
             withdrawals_from_el_len =
-              req.read.executionPayload.withdrawals.maybeDeref.len,
+              req.value().executionPayload.withdrawals.maybeDeref.len,
             withdrawals_from_cl =
               mapIt(engineApiWithdrawals, it.asConsensusWithdrawal),
             withdrawals_from_el =
               mapIt(
-                req.read.executionPayload.withdrawals.maybeDeref,
+                req.value().executionPayload.withdrawals.maybeDeref,
                 it.asConsensusWithdrawal)
 
-      if req.read.executionPayload.extraData.len > MAX_EXTRA_DATA_BYTES:
+      if req.value().executionPayload.extraData.len > MAX_EXTRA_DATA_BYTES:
         warn "Execution client provided a block with invalid extraData (size exceeds limit)",
-             size = req.read.executionPayload.extraData.len,
+             size = req.value().executionPayload.extraData.len,
              limit = MAX_EXTRA_DATA_BYTES
         continue
 
       if bestPayloadIdx.isNone:
         bestPayloadIdx = some idx
       else:
-        if cmpGetPayloadResponses(req.read, requests[bestPayloadIdx.get].read) > 0:
+        if cmpGetPayloadResponses(req.value(), requests[bestPayloadIdx.get].value()) > 0:
           bestPayloadIdx = some idx
 
   if bestPayloadIdx.isSome:
-    return ok requests[bestPayloadIdx.get].read.asConsensusType
+    return ok requests[bestPayloadIdx.get].value().asConsensusType
   else:
     return err()
 

beacon_chain/spec/eth2_apis/rest_remote_signer_calls.nim

@@ -91,10 +91,10 @@ proc signDataPlain*(identifier: ValidatorPubKey,
 proc init(t: typedesc[Web3SignerError], kind: Web3SignerErrorKind,
           message: string): Web3SignerError =
   Web3SignerError(kind: kind, message: message)
-
 proc signData*(client: RestClientRef, identifier: ValidatorPubKey,
                body: Web3SignerRequest
-              ): Future[Web3SignerDataResponse] {.async.} =
+              ): Future[Web3SignerDataResponse]
+              {.async: (raises: [CancelledError]).} =
   inc(nbc_remote_signer_requests)
 
   let
@@ -111,124 +111,118 @@ proc signData*(client: RestClientRef, identifier: ValidatorPubKey,
       except RestError as exc:
         return Web3SignerDataResponse.err(
           Web3SignerError.init(Web3SignerErrorKind.CommError, $exc.msg))
-      except CancelledError as exc:
-        raise exc
-      except CatchableError as exc:
-        return Web3SignerDataResponse.err(
-          Web3SignerError.init(Web3SignerErrorKind.UnexpectedError, $exc.msg))
 
-  return
-    case response.status
-    of 200:
-      inc(nbc_remote_signer_200_responses)
-      let sig =
-        if response.contentType.isNone() or
-           isWildCard(response.contentType.get().mediaType):
-          inc(nbc_remote_signer_failures)
-          return Web3SignerDataResponse.err(
-            Web3SignerError.init(
-              Web3SignerErrorKind.InvalidContentType,
-              "Unable to decode signature from missing or incorrect content"
-            )
-          )
-        else:
-          let mediaType = response.contentType.get().mediaType
-          if mediaType == TextPlainMediaType:
-            let
-              asStr = fromBytes(string, response.data)
-              sigFromText = fromHex(ValidatorSig, asStr).valueOr:
-                inc(nbc_remote_signer_failures)
-                return Web3SignerDataResponse.err(
-                  Web3SignerError.init(
-                    Web3SignerErrorKind.InvalidPlain,
-                    "Unable to decode signature from plain text"
-                  )
-                )
-            sigFromText.load()
-          else:
-            let res = decodeBytes(Web3SignerSignatureResponse, response.data,
-                                  response.contentType).valueOr:
-              inc(nbc_remote_signer_failures)
-              return Web3SignerDataResponse.err(
-                Web3SignerError.init(
-                  Web3SignerErrorKind.InvalidContent,
-                  "Unable to decode remote signer response [" & $error & "]"
-                )
-              )
-            res.signature.load()
-
-      if sig.isNone():
+  case response.status
+  of 200:
+    inc(nbc_remote_signer_200_responses)
+    let sig = block:
+      if response.contentType.isNone() or
+          isWildCard(response.contentType.get().mediaType):
         inc(nbc_remote_signer_failures)
         return Web3SignerDataResponse.err(
           Web3SignerError.init(
-            Web3SignerErrorKind.InvalidSignature,
-            "Remote signer returns invalid signature"
+            Web3SignerErrorKind.InvalidContentType,
+            "Unable to decode signature from missing or incorrect content"
           )
         )
 
-      inc(nbc_remote_signer_signatures)
-      Web3SignerDataResponse.ok(sig.get())
-    of 400:
-      inc(nbc_remote_signer_400_responses)
-      let message =
-        block:
-          let res = decodeBytes(Web3SignerErrorResponse, response.data,
-                                response.contentType)
-          if res.isErr():
-            "Remote signer returns 400 Bad Request Format Error"
-          else:
-            res.get().error
-      Web3SignerDataResponse.err(
-        Web3SignerError.init(Web3SignerErrorKind.Error400, message))
-    of 404:
-      inc(nbc_remote_signer_404_responses)
-      let message =
-        block:
-          let res = decodeBytes(Web3SignerErrorResponse, response.data,
-                                response.contentType)
-          if res.isErr():
-            "Remote signer returns 404 Validator's Key Not Found Error"
-          else:
-            res.get().error
-      Web3SignerDataResponse.err(
-        Web3SignerError.init(Web3SignerErrorKind.Error404, message))
-    of 412:
-      inc(nbc_remote_signer_412_responses)
-      let message =
-        block:
-          let res = decodeBytes(Web3SignerErrorResponse, response.data,
-                                response.contentType)
-          if res.isErr():
-            "Remote signer returns 412 Slashing Protection Error"
-          else:
-            res.get().error
-      Web3SignerDataResponse.err(
-        Web3SignerError.init(Web3SignerErrorKind.Error412, message))
-    of 500:
-      inc(nbc_remote_signer_500_responses)
-      let message =
-        block:
-          let res = decodeBytes(Web3SignerErrorResponse, response.data,
-                                response.contentType)
-          if res.isErr():
-            "Remote signer returns 500 Internal Server Error"
-          else:
-            res.get().error
-      Web3SignerDataResponse.err(
-        Web3SignerError.init(Web3SignerErrorKind.Error500, message))
-    else:
-      inc(nbc_remote_signer_unknown_responses)
-      let message =
-        block:
-          let res = decodeBytes(Web3SignerErrorResponse, response.data,
-                                response.contentType)
-          if res.isErr():
-            "Remote signer returns unexpected status code " &
-              Base10.toString(uint64(response.status))
-          else:
-            res.get().error
-      Web3SignerDataResponse.err(
-        Web3SignerError.init(Web3SignerErrorKind.UknownStatus, message))
+      let mediaType = response.contentType.get().mediaType
+      if mediaType == TextPlainMediaType:
+        let
+          asStr = fromBytes(string, response.data)
+          sigFromText = fromHex(ValidatorSig, asStr).valueOr:
+            inc(nbc_remote_signer_failures)
+            return Web3SignerDataResponse.err(
+              Web3SignerError.init(
+                Web3SignerErrorKind.InvalidPlain,
+                "Unable to decode signature from plain text"
+              )
+            )
+        sigFromText.load()
+      else:
+        let res = decodeBytes(Web3SignerSignatureResponse, response.data,
+                              response.contentType).valueOr:
+          inc(nbc_remote_signer_failures)
+          return Web3SignerDataResponse.err(
+            Web3SignerError.init(
+              Web3SignerErrorKind.InvalidContent,
+              "Unable to decode remote signer response [" & $error & "]"
+            )
+          )
+        res.signature.load()
+
+    if sig.isNone():
+      inc(nbc_remote_signer_failures)
+      return Web3SignerDataResponse.err(
+        Web3SignerError.init(
+          Web3SignerErrorKind.InvalidSignature,
+          "Remote signer returns invalid signature"
+        )
+      )
+
+    inc(nbc_remote_signer_signatures)
+    Web3SignerDataResponse.ok(sig.get())
+  of 400:
+    inc(nbc_remote_signer_400_responses)
+    let message =
+      block:
+        let res = decodeBytes(Web3SignerErrorResponse, response.data,
+                              response.contentType)
+        if res.isErr():
+          "Remote signer returns 400 Bad Request Format Error"
+        else:
+          res.get().error
+    Web3SignerDataResponse.err(
+      Web3SignerError.init(Web3SignerErrorKind.Error400, message))
+  of 404:
+    inc(nbc_remote_signer_404_responses)
+    let message =
+      block:
+        let res = decodeBytes(Web3SignerErrorResponse, response.data,
+                              response.contentType)
+        if res.isErr():
+          "Remote signer returns 404 Validator's Key Not Found Error"
+        else:
+          res.get().error
+    Web3SignerDataResponse.err(
+      Web3SignerError.init(Web3SignerErrorKind.Error404, message))
+  of 412:
+    inc(nbc_remote_signer_412_responses)
+    let message =
+      block:
+        let res = decodeBytes(Web3SignerErrorResponse, response.data,
+                              response.contentType)
+        if res.isErr():
+          "Remote signer returns 412 Slashing Protection Error"
+        else:
+          res.get().error
+    Web3SignerDataResponse.err(
+      Web3SignerError.init(Web3SignerErrorKind.Error412, message))
+  of 500:
+    inc(nbc_remote_signer_500_responses)
+    let message =
+      block:
+        let res = decodeBytes(Web3SignerErrorResponse, response.data,
+                              response.contentType)
+        if res.isErr():
+          "Remote signer returns 500 Internal Server Error"
+        else:
+          res.get().error
+    Web3SignerDataResponse.err(
+      Web3SignerError.init(Web3SignerErrorKind.Error500, message))
+  else:
+    inc(nbc_remote_signer_unknown_responses)
+    let message =
+      block:
+        let res = decodeBytes(Web3SignerErrorResponse, response.data,
+                              response.contentType)
+        if res.isErr():
+          "Remote signer returns unexpected status code " &
+            Base10.toString(uint64(response.status))
+        else:
+          res.get().error
+    Web3SignerDataResponse.err(
+      Web3SignerError.init(Web3SignerErrorKind.UknownStatus, message))
 
 proc signData*(
        client: RestClientRef,
@@ -236,7 +230,7 @@ proc signData*(
        timerFut: Future[void],
        attemptsCount: int,
        body: Web3SignerRequest
-     ): Future[Web3SignerDataResponse] {.async.} =
+     ): Future[Web3SignerDataResponse] {.async: (raises: [CancelledError]).} =
   doAssert(attemptsCount >= 1)
 
   const BackoffTimeouts = [
@@ -249,14 +243,17 @@ proc signData*(
 
   while true:
     var
-      operationFut: Future[Web3SignerDataResponse]
+      operationFut: Future[Web3SignerDataResponse].Raising([CancelledError])
       lastError: Opt[Web3SignerError]
     try:
       operationFut = signData(client, identifier, body)
       if isNil(timerFut):
         await allFutures(operationFut)
       else:
-        discard await race(timerFut, operationFut)
+        try:
+          discard await race(timerFut, operationFut)
+        except ValueError:
+          raiseAssert "race precondition satisfied"
     except CancelledError as exc:
       if not(operationFut.finished()):
         await operationFut.cancelAndWait()
@@ -275,7 +272,7 @@ proc signData*(
           )
         )
     else:
-      let resp = operationFut.read()
+      let resp = await operationFut
       if resp.isOk():
         return resp
 

beacon_chain/validators/keystore_management.nim

@@ -632,7 +632,8 @@ proc existsKeystore(keystoreDir: string,
       return true
   false
 
-proc queryValidatorsSource*(web3signerUrl: Web3SignerUrl): Future[QueryResult] {.async.} =
+proc queryValidatorsSource*(web3signerUrl: Web3SignerUrl):
+    Future[QueryResult] {.async: (raises: [CancelledError]).} =
   var keystores: seq[KeystoreData]
 
   logScope:
@@ -671,13 +672,6 @@ proc queryValidatorsSource*(web3signerUrl: Web3SignerUrl): Future[QueryResult] {
       except RestError as exc:
         warn "Unable to poll validator's source", reason = $exc.msg
         return QueryResult.err($exc.msg)
-      except CancelledError as exc:
-        debug "The polling of validator's source was interrupted"
-        raise exc
-      except CatchableError as exc:
-        warn "Unexpected error occured while polling validator's source",
-             error = $exc.name, reason = $exc.msg
-        return QueryResult.err($exc.msg)
 
     remoteType = if web3signerUrl.provenBlockProperties.len == 0:
       RemoteSignerType.Web3Signer
@@ -999,13 +993,7 @@ proc saveNetKeystore*(rng: var HmacDrbgContext, keystorePath: string,
 
   let keyStore = createNetKeystore(kdfScrypt, rng, netKey,
                                    KeystorePass.init password)
-  var encodedStorage: string
-  try:
-    encodedStorage = Json.encode(keyStore)
-  except SerializationError as exc:
-    error "Could not serialize network key storage", key_path = keystorePath
-    return err(KeystoreGenerationError(
-      kind: FailedToCreateKeystoreFile, error: exc.msg))
+  let encodedStorage = Json.encode(keyStore)
 
   let res = secureWriteFile(keystorePath, encodedStorage)
   if res.isOk():
@@ -1182,14 +1170,7 @@ proc saveKeystore*(
   let keyStore = createKeystore(kdfPbkdf2, rng, signingKey,
                                 keypass, signingKeyPath,
                                 mode = mode, salt = salt)
-
-  let encodedStorage =
-    try:
-      Json.encode(keyStore)
-    except SerializationError as e:
-      error "Could not serialize keystorage", key_path = keystoreFile
-      return err(KeystoreGenerationError(
-        kind: FailedToCreateKeystoreFile, error: e.msg))
+  let encodedStorage = Json.encode(keyStore)
 
   ? createLocalValidatorFiles(secretsDir, validatorsDir,
                               keystoreDir,
@@ -1223,13 +1204,7 @@ proc saveLockedKeystore(
                                 keypass, signingKeyPath,
                                 mode = mode)
 
-  let encodedStorage =
-    try:
-      Json.encode(keyStore)
-    except SerializationError as e:
-      error "Could not serialize keystorage", key_path = keystoreFile
-      return err(KeystoreGenerationError(
-        kind: FailedToCreateKeystoreFile, error: e.msg))
+  let encodedStorage = Json.encode(keyStore)
 
   let lock = ? createLockedLocalValidatorFiles(secretsDir, validatorsDir,
                                                keystoreDir,
@@ -1268,13 +1243,7 @@ proc saveKeystore(
     return err(KeystoreGenerationError(kind: DuplicateKeystoreFile,
       error: "Keystore file already exists"))
 
-  let encodedStorage =
-    try:
-      Json.encode(keyStore)
-    except SerializationError as exc:
-      error "Could not serialize keystorage", key_path = keystoreFile
-      return err(KeystoreGenerationError(
-        kind: FailedToCreateKeystoreFile, error: exc.msg))
+  let encodedStorage = Json.encode(keyStore)
 
   ? createRemoteValidatorFiles(validatorsDir, keystoreDir, keystoreFile,
                                encodedStorage)
@@ -1310,13 +1279,7 @@ proc saveLockedKeystore(
     return err(KeystoreGenerationError(kind: DuplicateKeystoreFile,
       error: "Keystore file already exists"))
 
-  let encodedStorage =
-    try:
-      Json.encode(keyStore)
-    except SerializationError as exc:
-      error "Could not serialize keystorage", key_path = keystoreFile
-      return err(KeystoreGenerationError(
-        kind: FailedToCreateKeystoreFile, error: exc.msg))
+  let encodedStorage = Json.encode(keyStore)
 
   let lock = ? createLockedRemoteValidatorFiles(validatorsDir, keystoreDir,
                                                 keystoreFile, encodedStorage)
@@ -1633,12 +1596,9 @@ proc generateDeposits*(cfg: RuntimeConfig,
   ok deposits
 
 proc saveWallet(wallet: Wallet, outWalletPath: string): Result[void, string] =
-  let walletDir = splitFile(outWalletPath).dir
-  var encodedWallet: string
-  try:
+  let
+    walletDir = splitFile(outWalletPath).dir
     encodedWallet = Json.encode(wallet, pretty = true)
-  except SerializationError:
-    return err("Could not serialize wallet")
 
   ? secureCreatePath(walletDir).mapErr(proc(e: auto): string =
     "Could not create wallet directory [" & walletDir & "]: " & $e)

beacon_chain/validators/message_router.nim

@@ -85,7 +85,8 @@ template getCurrentBeaconTime(router: MessageRouter): BeaconTime =
 type RouteBlockResult = Result[Opt[BlockRef], string]
 proc routeSignedBeaconBlock*(
     router: ref MessageRouter, blck: ForkySignedBeaconBlock,
-    blobsOpt: Opt[seq[BlobSidecar]]): Future[RouteBlockResult] {.async.} =
+    blobsOpt: Opt[seq[BlobSidecar]]):
+    Future[RouteBlockResult] {.async: (raises: [CancelledError]).} =
   ## Validate and broadcast beacon block, then add it to the block database
   ## Returns the new Head when block is added successfully to dag, none when
   ## block passes validation but is not added, and error otherwise
@@ -191,7 +192,8 @@ proc routeSignedBeaconBlock*(
 
 proc routeAttestation*(
     router: ref MessageRouter, attestation: Attestation,
-    subnet_id: SubnetId, checkSignature: bool): Future[SendResult] {.async.} =
+    subnet_id: SubnetId, checkSignature: bool):
+    Future[SendResult] {.async: (raises: [CancelledError]).} =
   ## Process and broadcast attestation - processing will register the it with
   ## the attestation pool
   block:
@@ -222,7 +224,7 @@ proc routeAttestation*(
 
 proc routeAttestation*(
     router: ref MessageRouter, attestation: Attestation):
-    Future[SendResult] {.async.} =
+    Future[SendResult] {.async: (raises: [CancelledError]).} =
   # Compute subnet, then route attestation
   let
     target = router[].dag.getBlockRef(attestation.data.target.root).valueOr:
@@ -252,7 +254,7 @@ proc routeAttestation*(
 proc routeSignedAggregateAndProof*(
     router: ref MessageRouter, proof: SignedAggregateAndProof,
     checkSignature = true):
-    Future[SendResult] {.async.} =
+    Future[SendResult] {.async: (raises: [CancelledError]).} =
   ## Validate and broadcast aggregate
   block:
     # Because the aggregate was (most likely) produced by this beacon node,
@@ -292,7 +294,8 @@ proc routeSignedAggregateAndProof*(
 proc routeSyncCommitteeMessage*(
     router: ref MessageRouter, msg: SyncCommitteeMessage,
     subcommitteeIdx: SyncSubcommitteeIndex,
-    checkSignature: bool): Future[SendResult] {.async.} =
+    checkSignature: bool):
+    Future[SendResult] {.async: (raises: [CancelledError]).} =
   block:
     let res = await router[].processor.processSyncCommitteeMessage(
       MsgSource.api, msg, subcommitteeIdx, checkSignature)
@@ -325,7 +328,7 @@ proc routeSyncCommitteeMessage*(
 
 proc routeSyncCommitteeMessages*(
     router: ref MessageRouter, msgs: seq[SyncCommitteeMessage]):
-    Future[seq[SendResult]] {.async.} =
+    Future[seq[SendResult]] {.async: (raises: [CancelledError]).} =
   return withState(router[].dag.headState):
     when consensusFork >= ConsensusFork.Altair:
       var statuses = newSeq[Opt[SendResult]](len(msgs))
@@ -382,13 +385,13 @@ proc routeSyncCommitteeMessages*(
 
       for index, future in pending:
         if future.completed():
-          let fres = future.read()
+          let fres = future.value()
           if fres.isErr():
             statuses[indices[index]] = Opt.some(SendResult.err(fres.error()))
           else:
             statuses[indices[index]] = Opt.some(SendResult.ok())
         elif future.failed() or future.cancelled():
-          let exc = future.readError()
+          let exc = future.error()
           debug "Unexpected failure while sending committee message",
             message = msgs[indices[index]], error = $exc.msg
           statuses[indices[index]] = Opt.some(SendResult.err(
@@ -410,7 +413,8 @@ proc routeSyncCommitteeMessages*(
 proc routeSignedContributionAndProof*(
     router: ref MessageRouter,
     msg: SignedContributionAndProof,
-    checkSignature: bool): Future[SendResult] {.async.} =
+    checkSignature: bool):
+    Future[SendResult] {.async: (raises: [CancelledError]).} =
   block:
     let res = await router[].processor.processSignedContributionAndProof(
       MsgSource.api, msg)
@@ -445,7 +449,7 @@ proc routeSignedContributionAndProof*(
 
 proc routeSignedVoluntaryExit*(
     router: ref MessageRouter, exit: SignedVoluntaryExit):
-    Future[SendResult] {.async.} =
+    Future[SendResult] {.async: (raises: [CancelledError]).} =
   block:
     let res =
       router[].processor[].processSignedVoluntaryExit(MsgSource.api, exit)
@@ -465,7 +469,7 @@ proc routeSignedVoluntaryExit*(
 
 proc routeAttesterSlashing*(
     router: ref MessageRouter, slashing: AttesterSlashing):
-    Future[SendResult] {.async.} =
+    Future[SendResult] {.async: (raises: [CancelledError]).} =
   block:
     let res =
       router[].processor[].processAttesterSlashing(MsgSource.api, slashing)
@@ -486,7 +490,7 @@ proc routeAttesterSlashing*(
 
 proc routeProposerSlashing*(
     router: ref MessageRouter, slashing: ProposerSlashing):
-    Future[SendResult] {.async.} =
+    Future[SendResult] {.async: (raises: [CancelledError]).} =
   block:
     let res =
       router[].processor[].processProposerSlashing(MsgSource.api, slashing)
@@ -508,7 +512,7 @@ proc routeProposerSlashing*(
 proc routeBlsToExecutionChange*(
     router: ref MessageRouter,
     bls_to_execution_change: SignedBLSToExecutionChange):
-    Future[SendResult] {.async.} =
+    Future[SendResult] {.async: (raises: [CancelledError]).} =
   block:
     let res = await router.processor.processBlsToExecutionChange(
       MsgSource.api, bls_to_execution_change)

beacon_chain/validators/message_router_mev.nim

@@ -47,7 +47,7 @@ proc unblindAndRouteBlockMEV*(
     blindedBlock:
       capella_mev.SignedBlindedBeaconBlock |
       deneb_mev.SignedBlindedBeaconBlock):
-    Future[Result[Opt[BlockRef], string]] {.async.} =
+    Future[Result[Opt[BlockRef], string]] {.async: (raises: [CancelledError]).} =
   const consensusFork = typeof(blindedBlock).kind
 
   info "Proposing blinded Builder API block",
@@ -63,7 +63,9 @@ proc unblindAndRouteBlockMEV*(
         return err("Submitting blinded block timed out")
       # From here on, including error paths, disallow local EL production by
       # returning Opt.some, regardless of whether on head or newBlock.
-    except CatchableError as exc:
+    except RestDecodingError as exc:
+      return err("REST decoding error submitting blinded block: " & exc.msg)
+    except RestError as exc:
       return err("exception in submitBlindedBlock: " & exc.msg)
 
   const httpOk = 200

beacon_chain/validators/validator_duties.nim

@@ -36,7 +36,8 @@ proc toAttestation*(
     registered.data, signature).expect("valid data")
 
 proc waitAfterBlockCutoff*(clock: BeaconClock, slot: Slot,
-                           head: Opt[BlockRef] = Opt.none(BlockRef)) {.async.} =
+                           head: Opt[BlockRef] = Opt.none(BlockRef))
+                           {.async: (raises: [CancelledError]).} =
   # The expected block arrived (or expectBlock was called again which
   # shouldn't happen as this is the only place we use it) - in our async
   # loop however, we might have been doing other processing that caused delays

beacon_chain/validators/validator_pool.nim

@@ -436,7 +436,7 @@ proc updateDynamicValidators*(pool: ref ValidatorPool,
 
 proc signWithDistributedKey(v: AttachedValidator,
                             request: Web3SignerRequest): Future[SignatureResult]
-                           {.async.} =
+                           {.async: (raises: [CancelledError]).} =
   doAssert v.data.threshold <= uint32(v.clients.len)
 
   let
@@ -453,8 +453,8 @@ proc signWithDistributedKey(v: AttachedValidator,
 
   for i, req in signatureReqs:
     template shareInfo: untyped = v.clients[i][1]
-    if req.completed() and req.read.isOk:
-      shares.add req.read.get.toSignatureShare(shareInfo.id)
+    if req.completed() and req.value().isOk:
+      shares.add req.value.get.toSignatureShare(shareInfo.id)
       neededShares = neededShares - 1
     else:
       warn "Failed to obtain signature from remote signer",
@@ -467,11 +467,11 @@ proc signWithDistributedKey(v: AttachedValidator,
       let recovered = shares.recoverSignature()
       return SignatureResult.ok recovered.toValidatorSig
 
-  return SignatureResult.err "Not enough shares to recover the signature"
+  SignatureResult.err "Not enough shares to recover the signature"
 
 proc signWithSingleKey(v: AttachedValidator,
-                       request: Web3SignerRequest): Future[SignatureResult] {.
-     async.} =
+                       request: Web3SignerRequest): Future[SignatureResult]
+                       {.async: (raises: [CancelledError]).} =
   doAssert v.clients.len == 1
   let
     deadline = sleepAsync(WEB3_SIGNER_DELAY_TOLERANCE)
@@ -480,12 +480,13 @@ proc signWithSingleKey(v: AttachedValidator,
 
   if not(deadline.finished()): await cancelAndWait(deadline)
   if res.isErr():
-    return SignatureResult.err(res.error.message)
+    SignatureResult.err(res.error.message)
   else:
-    return SignatureResult.ok(res.get().toValidatorSig())
+    SignatureResult.ok(res.get().toValidatorSig())
 
 proc signData(v: AttachedValidator,
-              request: Web3SignerRequest): Future[SignatureResult] =
+              request: Web3SignerRequest): Future[SignatureResult]
+              {.async: (raises: [CancelledError], raw: true).} =
   doAssert v.kind == ValidatorKind.Remote
   debug "Signing request with remote signer",
     validator = shortLog(v), kind = request.kind
@@ -502,7 +503,8 @@ proc getBlockSignature*(v: AttachedValidator, fork: Fork,
                               ForkedMaybeBlindedBeaconBlock |
                               capella_mev.BlindedBeaconBlock |
                               deneb_mev.BlindedBeaconBlock
-                       ): Future[SignatureResult] {.async.} =
+                       ): Future[SignatureResult]
+                       {.async: (raises: [CancelledError]).} =
   type SomeBlockBody =
     bellatrix.BeaconBlockBody |
     capella.BeaconBlockBody |
@@ -525,226 +527,225 @@ proc getBlockSignature*(v: AttachedValidator, fork: Fork,
           proof: proofRes.get)
     proofs
 
-  return
-    case v.kind
-    of ValidatorKind.Local:
-      SignatureResult.ok(
-        get_block_signature(
-          fork, genesis_validators_root, slot, block_root,
-          v.data.privateKey).toValidatorSig())
-    of ValidatorKind.Remote:
-      let web3signerRequest =
-        when blck is ForkedBlindedBeaconBlock:
-          case blck.kind
-          of ConsensusFork.Phase0, ConsensusFork.Altair, ConsensusFork.Bellatrix:
+  case v.kind
+  of ValidatorKind.Local:
+    SignatureResult.ok(
+      get_block_signature(
+        fork, genesis_validators_root, slot, block_root,
+        v.data.privateKey).toValidatorSig())
+  of ValidatorKind.Remote:
+    let web3signerRequest =
+      when blck is ForkedBlindedBeaconBlock:
+        case blck.kind
+        of ConsensusFork.Phase0, ConsensusFork.Altair, ConsensusFork.Bellatrix:
+          return SignatureResult.err("Invalid beacon block fork version")
+        of ConsensusFork.Capella:
+          case v.data.remoteType
+          of RemoteSignerType.Web3Signer:
+            Web3SignerRequest.init(fork, genesis_validators_root,
+              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
+                data: blck.capellaData.toBeaconBlockHeader))
+          of RemoteSignerType.VerifyingWeb3Signer:
+            let proofs = blockPropertiesProofs(
+              blck.capellaData.body, capellaIndex)
+            Web3SignerRequest.init(fork, genesis_validators_root,
+              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
+                data: blck.capellaData.toBeaconBlockHeader),
+              proofs)
+        of ConsensusFork.Deneb:
+          case v.data.remoteType
+          of RemoteSignerType.Web3Signer:
+            Web3SignerRequest.init(fork, genesis_validators_root,
+              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
+                data: blck.denebData.toBeaconBlockHeader))
+          of RemoteSignerType.VerifyingWeb3Signer:
+            let proofs = blockPropertiesProofs(
+              blck.denebData.body, denebIndex)
+            Web3SignerRequest.init(fork, genesis_validators_root,
+              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
+                data: blck.denebData.toBeaconBlockHeader),
+              proofs)
+      elif blck is capella_mev.BlindedBeaconBlock:
+        case v.data.remoteType
+        of RemoteSignerType.Web3Signer:
+          Web3SignerRequest.init(fork, genesis_validators_root,
+            Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
+              data: blck.toBeaconBlockHeader))
+        of RemoteSignerType.VerifyingWeb3Signer:
+          let proofs = blockPropertiesProofs(
+            blck.body, capellaIndex)
+          Web3SignerRequest.init(fork, genesis_validators_root,
+            Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
+              data: blck.toBeaconBlockHeader),
+            proofs)
+      elif blck is deneb_mev.BlindedBeaconBlock:
+        case v.data.remoteType
+        of RemoteSignerType.Web3Signer:
+          Web3SignerRequest.init(fork, genesis_validators_root,
+            Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
+              data: blck.toBeaconBlockHeader))
+        of RemoteSignerType.VerifyingWeb3Signer:
+          let proofs = blockPropertiesProofs(
+            blck.body, denebIndex)
+          Web3SignerRequest.init(fork, genesis_validators_root,
+            Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
+              data: blck.toBeaconBlockHeader),
+            proofs)
+      elif blck is ForkedMaybeBlindedBeaconBlock:
+        withForkyMaybeBlindedBlck(blck):
+          when consensusFork < ConsensusFork.Bellatrix:
             return SignatureResult.err("Invalid beacon block fork version")
-          of ConsensusFork.Capella:
-            case v.data.remoteType
-            of RemoteSignerType.Web3Signer:
-              Web3SignerRequest.init(fork, genesis_validators_root,
-                Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
-                  data: blck.capellaData.toBeaconBlockHeader))
-            of RemoteSignerType.VerifyingWeb3Signer:
-              let proofs = blockPropertiesProofs(
-                blck.capellaData.body, capellaIndex)
-              Web3SignerRequest.init(fork, genesis_validators_root,
-                Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
-                  data: blck.capellaData.toBeaconBlockHeader),
-                proofs)
-          of ConsensusFork.Deneb:
-            case v.data.remoteType
-            of RemoteSignerType.Web3Signer:
-              Web3SignerRequest.init(fork, genesis_validators_root,
-                Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
-                  data: blck.denebData.toBeaconBlockHeader))
-            of RemoteSignerType.VerifyingWeb3Signer:
-              let proofs = blockPropertiesProofs(
-                blck.denebData.body, denebIndex)
-              Web3SignerRequest.init(fork, genesis_validators_root,
-                Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
-                  data: blck.denebData.toBeaconBlockHeader),
-                proofs)
-        elif blck is capella_mev.BlindedBeaconBlock:
-          case v.data.remoteType
-          of RemoteSignerType.Web3Signer:
-            Web3SignerRequest.init(fork, genesis_validators_root,
-              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
-                data: blck.toBeaconBlockHeader))
-          of RemoteSignerType.VerifyingWeb3Signer:
-            let proofs = blockPropertiesProofs(
-              blck.body, capellaIndex)
-            Web3SignerRequest.init(fork, genesis_validators_root,
-              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
-                data: blck.toBeaconBlockHeader),
-              proofs)
-        elif blck is deneb_mev.BlindedBeaconBlock:
-          case v.data.remoteType
-          of RemoteSignerType.Web3Signer:
-            Web3SignerRequest.init(fork, genesis_validators_root,
-              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
-                data: blck.toBeaconBlockHeader))
-          of RemoteSignerType.VerifyingWeb3Signer:
-            let proofs = blockPropertiesProofs(
-              blck.body, denebIndex)
-            Web3SignerRequest.init(fork, genesis_validators_root,
-              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
-                data: blck.toBeaconBlockHeader),
-              proofs)
-        elif blck is ForkedMaybeBlindedBeaconBlock:
-          withForkyMaybeBlindedBlck(blck):
-            when consensusFork < ConsensusFork.Bellatrix:
+          elif consensusFork == ConsensusFork.Bellatrix:
+            when isBlinded:
               return SignatureResult.err("Invalid beacon block fork version")
-            elif consensusFork == ConsensusFork.Bellatrix:
-              when isBlinded:
-                return SignatureResult.err("Invalid beacon block fork version")
-              else:
-                case v.data.remoteType
-                of RemoteSignerType.Web3Signer:
-                  Web3SignerRequest.init(fork, genesis_validators_root,
-                    Web3SignerForkedBeaconBlock(kind: ConsensusFork.Bellatrix,
-                      data: forkyMaybeBlindedBlck.toBeaconBlockHeader))
-                of RemoteSignerType.VerifyingWeb3Signer:
-                  let proofs = blockPropertiesProofs(
-                    blck.bellatrixData.body, bellatrixIndex)
-                  Web3SignerRequest.init(fork, genesis_validators_root,
-                    Web3SignerForkedBeaconBlock(kind: ConsensusFork.Bellatrix,
-                      data: forkyMaybeBlindedBlck.toBeaconBlockHeader),
-                        proofs)
-            elif consensusFork == ConsensusFork.Capella:
-              when isBlinded:
-                case v.data.remoteType
-                of RemoteSignerType.Web3Signer:
-                  Web3SignerRequest.init(fork, genesis_validators_root,
-                    Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
-                      data: forkyMaybeBlindedBlck.toBeaconBlockHeader))
-                of RemoteSignerType.VerifyingWeb3Signer:
-                  let proofs =
-                    blockPropertiesProofs(forkyMaybeBlindedBlck.body,
-                                          capellaIndex)
-                  Web3SignerRequest.init(fork, genesis_validators_root,
-                    Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
-                      data: forkyMaybeBlindedBlck.toBeaconBlockHeader), proofs)
-              else:
-                case v.data.remoteType
-                of RemoteSignerType.Web3Signer:
-                  Web3SignerRequest.init(fork, genesis_validators_root,
-                    Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
-                      data: forkyMaybeBlindedBlck.toBeaconBlockHeader))
-                of RemoteSignerType.VerifyingWeb3Signer:
-                  let proofs =
-                    blockPropertiesProofs(forkyMaybeBlindedBlck.body,
-                                          capellaIndex)
-                  Web3SignerRequest.init(fork, genesis_validators_root,
-                    Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
-                      data: forkyMaybeBlindedBlck.toBeaconBlockHeader),
-                        proofs)
-            elif consensusFork == ConsensusFork.Deneb:
-              when isBlinded:
-                case v.data.remoteType
-                of RemoteSignerType.Web3Signer:
-                  Web3SignerRequest.init(fork, genesis_validators_root,
-                    Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
-                      data: forkyMaybeBlindedBlck.toBeaconBlockHeader))
-                of RemoteSignerType.VerifyingWeb3Signer:
-                  let proofs =
-                    blockPropertiesProofs(forkyMaybeBlindedBlck.body,
-                                          denebIndex)
-                  Web3SignerRequest.init(fork, genesis_validators_root,
-                    Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
-                      data: forkyMaybeBlindedBlck.toBeaconBlockHeader), proofs)
-              else:
-                case v.data.remoteType
-                of RemoteSignerType.Web3Signer:
-                  Web3SignerRequest.init(fork, genesis_validators_root,
-                    Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
-                      data: forkyMaybeBlindedBlck.`block`.toBeaconBlockHeader))
-                of RemoteSignerType.VerifyingWeb3Signer:
-                  let proofs =
-                    blockPropertiesProofs(forkyMaybeBlindedBlck.`block`.body,
-                                          denebIndex)
-                  Web3SignerRequest.init(fork, genesis_validators_root,
-                    Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
-                      data: forkyMaybeBlindedBlck.`block`.toBeaconBlockHeader),
-                        proofs)
-        else:
-          case blck.kind
-          of ConsensusFork.Phase0, ConsensusFork.Altair:
-            return SignatureResult.err("Invalid beacon block fork version")
-          of ConsensusFork.Bellatrix:
-            case v.data.remoteType
-            of RemoteSignerType.Web3Signer:
-              Web3SignerRequest.init(fork, genesis_validators_root,
-                Web3SignerForkedBeaconBlock(kind: ConsensusFork.Bellatrix,
-                  data: blck.bellatrixData.toBeaconBlockHeader))
-            of RemoteSignerType.VerifyingWeb3Signer:
-              let proofs = blockPropertiesProofs(
-                blck.bellatrixData.body, bellatrixIndex)
-              Web3SignerRequest.init(fork, genesis_validators_root,
-                Web3SignerForkedBeaconBlock(kind: ConsensusFork.Bellatrix,
-                  data: blck.bellatrixData.toBeaconBlockHeader),
-                proofs)
-          of ConsensusFork.Capella:
-            case v.data.remoteType
-            of RemoteSignerType.Web3Signer:
-              Web3SignerRequest.init(fork, genesis_validators_root,
-                Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
-                  data: blck.capellaData.toBeaconBlockHeader))
-            of RemoteSignerType.VerifyingWeb3Signer:
-              let proofs = blockPropertiesProofs(
-                blck.capellaData.body, capellaIndex)
-              Web3SignerRequest.init(fork, genesis_validators_root,
-                Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
-                  data: blck.capellaData.toBeaconBlockHeader),
-                proofs)
-          of ConsensusFork.Deneb:
-            case v.data.remoteType
-            of RemoteSignerType.Web3Signer:
-              Web3SignerRequest.init(fork, genesis_validators_root,
-                Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
-                  data: blck.denebData.toBeaconBlockHeader))
-            of RemoteSignerType.VerifyingWeb3Signer:
-              let proofs = blockPropertiesProofs(
-                blck.denebData.body, denebIndex)
-              Web3SignerRequest.init(fork, genesis_validators_root,
-                Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
-                  data: blck.denebData.toBeaconBlockHeader),
-                proofs)
-      await v.signData(web3signerRequest)
+            else:
+              case v.data.remoteType
+              of RemoteSignerType.Web3Signer:
+                Web3SignerRequest.init(fork, genesis_validators_root,
+                  Web3SignerForkedBeaconBlock(kind: ConsensusFork.Bellatrix,
+                    data: forkyMaybeBlindedBlck.toBeaconBlockHeader))
+              of RemoteSignerType.VerifyingWeb3Signer:
+                let proofs = blockPropertiesProofs(
+                  blck.bellatrixData.body, bellatrixIndex)
+                Web3SignerRequest.init(fork, genesis_validators_root,
+                  Web3SignerForkedBeaconBlock(kind: ConsensusFork.Bellatrix,
+                    data: forkyMaybeBlindedBlck.toBeaconBlockHeader),
+                      proofs)
+          elif consensusFork == ConsensusFork.Capella:
+            when isBlinded:
+              case v.data.remoteType
+              of RemoteSignerType.Web3Signer:
+                Web3SignerRequest.init(fork, genesis_validators_root,
+                  Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
+                    data: forkyMaybeBlindedBlck.toBeaconBlockHeader))
+              of RemoteSignerType.VerifyingWeb3Signer:
+                let proofs =
+                  blockPropertiesProofs(forkyMaybeBlindedBlck.body,
+                                        capellaIndex)
+                Web3SignerRequest.init(fork, genesis_validators_root,
+                  Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
+                    data: forkyMaybeBlindedBlck.toBeaconBlockHeader), proofs)
+            else:
+              case v.data.remoteType
+              of RemoteSignerType.Web3Signer:
+                Web3SignerRequest.init(fork, genesis_validators_root,
+                  Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
+                    data: forkyMaybeBlindedBlck.toBeaconBlockHeader))
+              of RemoteSignerType.VerifyingWeb3Signer:
+                let proofs =
+                  blockPropertiesProofs(forkyMaybeBlindedBlck.body,
+                                        capellaIndex)
+                Web3SignerRequest.init(fork, genesis_validators_root,
+                  Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
+                    data: forkyMaybeBlindedBlck.toBeaconBlockHeader),
+                      proofs)
+          elif consensusFork == ConsensusFork.Deneb:
+            when isBlinded:
+              case v.data.remoteType
+              of RemoteSignerType.Web3Signer:
+                Web3SignerRequest.init(fork, genesis_validators_root,
+                  Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
+                    data: forkyMaybeBlindedBlck.toBeaconBlockHeader))
+              of RemoteSignerType.VerifyingWeb3Signer:
+                let proofs =
+                  blockPropertiesProofs(forkyMaybeBlindedBlck.body,
+                                        denebIndex)
+                Web3SignerRequest.init(fork, genesis_validators_root,
+                  Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
+                    data: forkyMaybeBlindedBlck.toBeaconBlockHeader), proofs)
+            else:
+              case v.data.remoteType
+              of RemoteSignerType.Web3Signer:
+                Web3SignerRequest.init(fork, genesis_validators_root,
+                  Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
+                    data: forkyMaybeBlindedBlck.`block`.toBeaconBlockHeader))
+              of RemoteSignerType.VerifyingWeb3Signer:
+                let proofs =
+                  blockPropertiesProofs(forkyMaybeBlindedBlck.`block`.body,
+                                        denebIndex)
+                Web3SignerRequest.init(fork, genesis_validators_root,
+                  Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
+                    data: forkyMaybeBlindedBlck.`block`.toBeaconBlockHeader),
+                      proofs)
+      else:
+        case blck.kind
+        of ConsensusFork.Phase0, ConsensusFork.Altair:
+          return SignatureResult.err("Invalid beacon block fork version")
+        of ConsensusFork.Bellatrix:
+          case v.data.remoteType
+          of RemoteSignerType.Web3Signer:
+            Web3SignerRequest.init(fork, genesis_validators_root,
+              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Bellatrix,
+                data: blck.bellatrixData.toBeaconBlockHeader))
+          of RemoteSignerType.VerifyingWeb3Signer:
+            let proofs = blockPropertiesProofs(
+              blck.bellatrixData.body, bellatrixIndex)
+            Web3SignerRequest.init(fork, genesis_validators_root,
+              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Bellatrix,
+                data: blck.bellatrixData.toBeaconBlockHeader),
+              proofs)
+        of ConsensusFork.Capella:
+          case v.data.remoteType
+          of RemoteSignerType.Web3Signer:
+            Web3SignerRequest.init(fork, genesis_validators_root,
+              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
+                data: blck.capellaData.toBeaconBlockHeader))
+          of RemoteSignerType.VerifyingWeb3Signer:
+            let proofs = blockPropertiesProofs(
+              blck.capellaData.body, capellaIndex)
+            Web3SignerRequest.init(fork, genesis_validators_root,
+              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Capella,
+                data: blck.capellaData.toBeaconBlockHeader),
+              proofs)
+        of ConsensusFork.Deneb:
+          case v.data.remoteType
+          of RemoteSignerType.Web3Signer:
+            Web3SignerRequest.init(fork, genesis_validators_root,
+              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
+                data: blck.denebData.toBeaconBlockHeader))
+          of RemoteSignerType.VerifyingWeb3Signer:
+            let proofs = blockPropertiesProofs(
+              blck.denebData.body, denebIndex)
+            Web3SignerRequest.init(fork, genesis_validators_root,
+              Web3SignerForkedBeaconBlock(kind: ConsensusFork.Deneb,
+                data: blck.denebData.toBeaconBlockHeader),
+              proofs)
+    await v.signData(web3signerRequest)
 
 # https://github.com/ethereum/consensus-specs/blob/v1.4.0-beta.6/specs/phase0/validator.md#aggregate-signature
 proc getAttestationSignature*(v: AttachedValidator, fork: Fork,
                               genesis_validators_root: Eth2Digest,
                               data: AttestationData
-                             ): Future[SignatureResult] {.async.} =
-  return
-    case v.kind
-    of ValidatorKind.Local:
-      SignatureResult.ok(
-        get_attestation_signature(
-          fork, genesis_validators_root, data,
-          v.data.privateKey).toValidatorSig())
-    of ValidatorKind.Remote:
-      let request = Web3SignerRequest.init(fork, genesis_validators_root, data)
-      await v.signData(request)
+                             ): Future[SignatureResult]
+                             {.async: (raises: [CancelledError]).} =
+  case v.kind
+  of ValidatorKind.Local:
+    SignatureResult.ok(
+      get_attestation_signature(
+        fork, genesis_validators_root, data,
+        v.data.privateKey).toValidatorSig())
+  of ValidatorKind.Remote:
+    let request = Web3SignerRequest.init(fork, genesis_validators_root, data)
+    await v.signData(request)
 
 # https://github.com/ethereum/consensus-specs/blob/v1.4.0-beta.6/specs/phase0/validator.md#broadcast-aggregate
 proc getAggregateAndProofSignature*(v: AttachedValidator,
                                     fork: Fork,
                                     genesis_validators_root: Eth2Digest,
                                     aggregate_and_proof: AggregateAndProof
-                                   ): Future[SignatureResult] {.async.} =
-  return
-    case v.kind
-    of ValidatorKind.Local:
-      SignatureResult.ok(
-        get_aggregate_and_proof_signature(
-          fork, genesis_validators_root, aggregate_and_proof,
-          v.data.privateKey).toValidatorSig()
-      )
-    of ValidatorKind.Remote:
-      let request = Web3SignerRequest.init(
-        fork, genesis_validators_root, aggregate_and_proof)
-      await v.signData(request)
+                                   ): Future[SignatureResult]
+                                   {.async: (raises: [CancelledError]).} =
+  case v.kind
+  of ValidatorKind.Local:
+    SignatureResult.ok(
+      get_aggregate_and_proof_signature(
+        fork, genesis_validators_root, aggregate_and_proof,
+        v.data.privateKey).toValidatorSig()
+    )
+  of ValidatorKind.Remote:
+    let request = Web3SignerRequest.init(
+      fork, genesis_validators_root, aggregate_and_proof)
+    await v.signData(request)
 
 # https://github.com/ethereum/consensus-specs/blob/v1.4.0-beta.6/specs/altair/validator.md#prepare-sync-committee-message
 proc getSyncCommitteeMessage*(v: AttachedValidator,
@@ -752,7 +753,8 @@ proc getSyncCommitteeMessage*(v: AttachedValidator,
                               genesis_validators_root: Eth2Digest,
                               slot: Slot,
                               beacon_block_root: Eth2Digest
-                             ): Future[SyncCommitteeMessageResult] {.async.} =
+                             ): Future[SyncCommitteeMessageResult]
+                             {.async: (raises: [CancelledError]).} =
   let signature =
     case v.kind
     of ValidatorKind.Local:
@@ -765,58 +767,58 @@ proc getSyncCommitteeMessage*(v: AttachedValidator,
       await v.signData(request)
 
   if signature.isErr:
-    return SyncCommitteeMessageResult.err("Failed to obtain signature")
+    return err("Failed to obtain signature")
 
-  return
-    SyncCommitteeMessageResult.ok(
-      SyncCommitteeMessage(
-        slot: slot,
-        beacon_block_root: beacon_block_root,
-        validator_index: uint64(v.index.get()),
-        signature: signature.get()
-      )
+  ok(
+    SyncCommitteeMessage(
+      slot: slot,
+      beacon_block_root: beacon_block_root,
+      validator_index: uint64(v.index.get()),
+      signature: signature.get()
     )
+  )
 
 # https://github.com/ethereum/consensus-specs/blob/v1.4.0-beta.6/specs/altair/validator.md#aggregation-selection
 proc getSyncCommitteeSelectionProof*(v: AttachedValidator, fork: Fork,
                                      genesis_validators_root: Eth2Digest,
                                      slot: Slot,
                                      subcommittee_index: SyncSubcommitteeIndex
-                                    ): Future[SignatureResult] {.async.} =
-  return
-    case v.kind
-    of ValidatorKind.Local:
-      SignatureResult.ok(get_sync_committee_selection_proof(
-        fork, genesis_validators_root, slot, subcommittee_index,
-        v.data.privateKey).toValidatorSig())
-    of ValidatorKind.Remote:
-      let request = Web3SignerRequest.init(
-        fork, genesis_validators_root,
-        SyncAggregatorSelectionData(
-          slot: slot, subcommittee_index: uint64 subcommittee_index)
-      )
-      await v.signData(request)
+                                    ): Future[SignatureResult]
+                                    {.async: (raises: [CancelledError]).} =
+  case v.kind
+  of ValidatorKind.Local:
+    SignatureResult.ok(get_sync_committee_selection_proof(
+      fork, genesis_validators_root, slot, subcommittee_index,
+      v.data.privateKey).toValidatorSig())
+  of ValidatorKind.Remote:
+    let request = Web3SignerRequest.init(
+      fork, genesis_validators_root,
+      SyncAggregatorSelectionData(
+        slot: slot, subcommittee_index: uint64 subcommittee_index)
+    )
+    await v.signData(request)
 
 # https://github.com/ethereum/consensus-specs/blob/v1.4.0-beta.6/specs/altair/validator.md#broadcast-sync-committee-contribution
 proc getContributionAndProofSignature*(v: AttachedValidator, fork: Fork,
                                        genesis_validators_root: Eth2Digest,
                                        contribution_and_proof: ContributionAndProof
-                                      ): Future[SignatureResult] {.async.} =
-  return
-    case v.kind
-    of ValidatorKind.Local:
-      SignatureResult.ok(get_contribution_and_proof_signature(
-        fork, genesis_validators_root, contribution_and_proof,
-        v.data.privateKey).toValidatorSig())
-    of ValidatorKind.Remote:
-      let request = Web3SignerRequest.init(
-        fork, genesis_validators_root, contribution_and_proof)
-      await v.signData(request)
+                                      ): Future[SignatureResult]
+                                      {.async: (raises: [CancelledError]).} =
+  case v.kind
+  of ValidatorKind.Local:
+    SignatureResult.ok(get_contribution_and_proof_signature(
+      fork, genesis_validators_root, contribution_and_proof,
+      v.data.privateKey).toValidatorSig())
+  of ValidatorKind.Remote:
+    let request = Web3SignerRequest.init(
+      fork, genesis_validators_root, contribution_and_proof)
+    await v.signData(request)
 
 # https://github.com/ethereum/consensus-specs/blob/v1.4.0-beta.6/specs/phase0/validator.md#randao-reveal
 proc getEpochSignature*(v: AttachedValidator, fork: Fork,
                         genesis_validators_root: Eth2Digest, epoch: Epoch
-                       ): Future[SignatureResult] {.async.} =
+                       ): Future[SignatureResult]
+                       {.async: (raises: [CancelledError]).} =
   if v.epochSignature.isSome and v.epochSignature.get.epoch == epoch:
     return SignatureResult.ok(v.epochSignature.get.signature)
 
@@ -840,7 +842,8 @@ proc getEpochSignature*(v: AttachedValidator, fork: Fork,
 # https://github.com/ethereum/consensus-specs/blob/v1.4.0-beta.6/specs/phase0/validator.md#aggregation-selection
 proc getSlotSignature*(v: AttachedValidator, fork: Fork,
                        genesis_validators_root: Eth2Digest, slot: Slot
-                      ): Future[SignatureResult] {.async.} =
+                      ): Future[SignatureResult]
+                      {.async: (raises: [CancelledError]).} =
   if v.slotSignature.isSome and v.slotSignature.get.slot == slot:
     return SignatureResult.ok(v.slotSignature.get.signature)
 
@@ -863,41 +866,40 @@ proc getSlotSignature*(v: AttachedValidator, fork: Fork,
 proc getValidatorExitSignature*(v: AttachedValidator, fork: Fork,
                                 genesis_validators_root: Eth2Digest,
                                 voluntary_exit: VoluntaryExit
-                               ): Future[SignatureResult] {.async.} =
-  return
-    case v.kind
-    of ValidatorKind.Local:
-      SignatureResult.ok(get_voluntary_exit_signature(
-        fork, genesis_validators_root, voluntary_exit,
-        v.data.privateKey).toValidatorSig())
-    of ValidatorKind.Remote:
-      let request = Web3SignerRequest.init(fork, genesis_validators_root,
-                                           voluntary_exit)
-      await v.signData(request)
+                               ): Future[SignatureResult]
+                               {.async: (raises: [CancelledError]).} =
+  case v.kind
+  of ValidatorKind.Local:
+    SignatureResult.ok(get_voluntary_exit_signature(
+      fork, genesis_validators_root, voluntary_exit,
+      v.data.privateKey).toValidatorSig())
+  of ValidatorKind.Remote:
+    let request = Web3SignerRequest.init(fork, genesis_validators_root,
+                                          voluntary_exit)
+    await v.signData(request)
 
 proc getDepositMessageSignature*(v: AttachedValidator, version: Version,
                                  deposit_message: DepositMessage
-                                ): Future[SignatureResult] {.async.} =
-  return
-    case v.kind
-    of ValidatorKind.Local:
-      SignatureResult.ok(get_deposit_signature(
-        deposit_message, version,
-        v.data.privateKey).toValidatorSig())
-    of ValidatorKind.Remote:
-      let request = Web3SignerRequest.init(version, deposit_message)
-      await v.signData(request)
+                                ): Future[SignatureResult]
+                                {.async: (raises: [CancelledError]).} =
+  case v.kind
+  of ValidatorKind.Local:
+    SignatureResult.ok(get_deposit_signature(
+      deposit_message, version,
+      v.data.privateKey).toValidatorSig())
+  of ValidatorKind.Remote:
+    let request = Web3SignerRequest.init(version, deposit_message)
+    await v.signData(request)
 
 # https://github.com/ethereum/builder-specs/blob/v0.4.0/specs/bellatrix/builder.md#signing
 proc getBuilderSignature*(v: AttachedValidator, fork: Fork,
     validatorRegistration: ValidatorRegistrationV1):
-    Future[SignatureResult] {.async.} =
-  return
-    case v.kind
-    of ValidatorKind.Local:
-      SignatureResult.ok(get_builder_signature(
-        fork, validatorRegistration, v.data.privateKey).toValidatorSig())
-    of ValidatorKind.Remote:
-      let request = Web3SignerRequest.init(
-        fork, ZERO_HASH, validatorRegistration)
-      await v.signData(request)
+    Future[SignatureResult] {.async: (raises: [CancelledError]).} =
+  case v.kind
+  of ValidatorKind.Local:
+    SignatureResult.ok(get_builder_signature(
+      fork, validatorRegistration, v.data.privateKey).toValidatorSig())
+  of ValidatorKind.Remote:
+    let request = Web3SignerRequest.init(
+      fork, ZERO_HASH, validatorRegistration)
+    await v.signData(request)