Add GetAggregateAttestation V2 endpoint version

AllTests-mainnet.md

@@ -10,8 +10,9 @@ OK: 1/1 Fail: 0/1 Skip: 0/1
 + Aggregated attestations with disjoint comittee bits into a single on-chain aggregate [Pres OK
 + Attestations with disjoint comittee bits and equal data into single on-chain aggregate [Pr OK
 + Can add and retrieve simple electra attestations [Preset: mainnet]                         OK
++ Working with electra aggregates [Preset: mainnet]                                          OK
 ```
-OK: 3/3 Fail: 0/3 Skip: 0/3
+OK: 4/4 Fail: 0/4 Skip: 0/4
 ## Attestation pool processing [Preset: mainnet]
 ```diff
 + Attestation from different branch [Preset: mainnet]                                        OK
@@ -1040,4 +1041,4 @@ OK: 2/2 Fail: 0/2 Skip: 0/2
 OK: 9/9 Fail: 0/9 Skip: 0/9
 
 ---TOTAL---
-OK: 693/698 Fail: 0/698 Skip: 5/698
+OK: 694/699 Fail: 0/699 Skip: 5/699

beacon_chain/consensus_object_pools/attestation_pool.nim

@@ -199,11 +199,16 @@ proc addForkChoiceVotes(
       # hopefully the fork choice will heal itself over time.
       error "Couldn't add attestation to fork choice, bug?", err = v.error()
 
-func candidateIdx(pool: AttestationPool, slot: Slot): Opt[int] =
+func candidateIdx(pool: AttestationPool, slot: Slot,
+  isElectra: bool = false): Opt[int] =
   static: doAssert pool.phase0Candidates.len == pool.electraCandidates.len
+
+  let poolLength = if isElectra:
+    pool.electraCandidates.lenu64 else: pool.phase0Candidates.lenu64
+
   if slot >= pool.startingSlot and
-      slot < (pool.startingSlot + pool.phase0Candidates.lenu64):
-    Opt.some(int(slot mod pool.phase0Candidates.lenu64))
+      slot < (pool.startingSlot + poolLength):
+    Opt.some(int(slot mod poolLength))
   else:
     Opt.none(int)
 
@@ -978,7 +983,8 @@ proc getElectraAttestationsForBlock*(
     else:
       default(seq[electra.Attestation])
 
-func bestValidation(aggregates: openArray[Phase0Validation]): (int, int) =
+func bestValidation(
+    aggregates: openArray[Phase0Validation | ElectraValidation]): (int, int) =
   # Look for best validation based on number of votes in the aggregate
   doAssert aggregates.len() > 0,
     "updateAggregates should have created at least one aggregate"
@@ -993,6 +999,29 @@ func bestValidation(aggregates: openArray[Phase0Validation]): (int, int) =
       bestIndex = i
   (bestIndex, best)
 
+func getElectraAggregatedAttestation*(
+    pool: var AttestationPool, slot: Slot,
+    attestationDataRoot: Eth2Digest, committeeIndex: CommitteeIndex):
+    Opt[electra.Attestation] =
+
+  let candidateIdx = pool.candidateIdx(slot)
+  if candidateIdx.isNone:
+    return Opt.none(electra.Attestation)
+
+  var res: Opt[electra.Attestation]
+  for _, entry in pool.electraCandidates[candidateIdx.get].mpairs():
+    if entry.data.index != committeeIndex.distinctBase:
+      continue
+
+    entry.updateAggregates()
+
+    let (bestIndex, best) = bestValidation(entry.aggregates)
+
+    if res.isNone() or best > res.get().aggregation_bits.countOnes():
+      res = Opt.some(entry.toElectraAttestation(entry.aggregates[bestIndex]))
+
+  res
+
 func getAggregatedAttestation*(
     pool: var AttestationPool, slot: Slot, attestation_data_root: Eth2Digest):
     Opt[phase0.Attestation] =

beacon_chain/rpc/rest_validator_api.nim

@@ -771,10 +771,12 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
         makeAttestationData(epochRef, qhead.atSlot(qslot), qindex)
     RestApiResponse.jsonResponse(adata)
 
-  # https://ethereum.github.io/beacon-APIs/#/Validator/getAggregatedAttestation
-  router.api2(MethodGet, "/eth/v1/validator/aggregate_attestation") do (
+  # https://ethereum.github.io/beacon-APIs/#/Validator/getAggregatedAttestationV2
+  router.api2(MethodGet, "/eth/v2/validator/aggregate_attestation") do (
     attestation_data_root: Option[Eth2Digest],
+    committee_index: Option[CommitteeIndex],
     slot: Option[Slot]) -> RestApiResponse:
+
     let attestation =
       block:
         let qslot =
@@ -786,7 +788,18 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
               return RestApiResponse.jsonError(Http400, InvalidSlotValueError,
                                                $res.error())
             res.get()
-        let qroot =
+        let committee_index =
+          block:
+            if committee_index.isNone():
+              return RestApiResponse.jsonError(Http400,
+                                               MissingCommitteeIndexValueError)
+            let res = committee_index.get()
+            if res.isErr():
+              return RestApiResponse.jsonError(Http400,
+                                               InvalidCommitteeIndexValueError,
+                                               $res.error())
+            res.get()
+        let root =
           block:
             if attestation_data_root.isNone():
               return RestApiResponse.jsonError(Http400,
@@ -797,7 +810,12 @@ proc installValidatorApiHandlers*(router: var RestRouter, node: BeaconNode) =
                              InvalidAttestationDataRootValueError, $res.error())
             res.get()
         let res =
-          node.attestationPool[].getAggregatedAttestation(qslot, qroot)
+          block:
+            let contextFork = node.dag.cfg.consensusForkAtEpoch(epoch(qslot))
+            if contextFork >= ConsensusFork.Electra:
+              node.attestationPool[].getElectraAggregatedAttestation(qslot, root, committee_index)
+            else:
+              node.attestationPool[].getAggregatedAttestation(qslot, root)
         if res.isNone():
           return RestApiResponse.jsonError(Http400,
                                           UnableToGetAggregatedAttestationError)

beacon_chain/spec/eth2_apis/rest_types.nim

@@ -530,6 +530,7 @@ type
   # Types based on the OAPI yaml file - used in responses to requests
   GetBeaconHeadResponse* = DataEnclosedObject[Slot]
   GetAggregatedAttestationResponse* = DataEnclosedObject[phase0.Attestation]
+  GetElectraAggregatedAttestationResponse* = DataEnclosedObject[electra.Attestation]
   GetAttesterDutiesResponse* = DataRootEnclosedObject[seq[RestAttesterDuty]]
   GetBlockAttestationsResponse* = DataEnclosedObject[seq[phase0.Attestation]]
   GetBlockHeaderResponse* = DataOptimisticAndFinalizedObject[RestBlockHeaderInfo]

beacon_chain/spec/eth2_apis/rest_validator_calls.nim

@@ -63,13 +63,14 @@ proc produceAttestationDataPlain*(
      meth: MethodGet.}
   ## https://ethereum.github.io/beacon-APIs/#/Validator/produceAttestationData
 
-proc getAggregatedAttestationPlain*(
+proc getAggregatedAttestationPlainV2*(
        attestation_data_root: Eth2Digest,
-       slot: Slot
+       slot: Slot,
+       committee_index: CommitteeIndex
      ): RestPlainResponse {.
-     rest, endpoint: "/eth/v1/validator/aggregate_attestation"
+     rest, endpoint: "/eth/v2/validator/aggregate_attestation"
      meth: MethodGet.}
-  ## https://ethereum.github.io/beacon-APIs/#/Validator/getAggregatedAttestation
+  ## https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getPoolAttestationsV2
 
 proc publishAggregateAndProofs*(
        body: seq[phase0.SignedAggregateAndProof]

beacon_chain/validator_client/api.nim

@@ -1662,6 +1662,7 @@ proc submitPoolSyncCommitteeSignature*(
 proc getAggregatedAttestation*(
        vc: ValidatorClientRef,
        slot: Slot,
+       committee_index: CommitteeIndex,
        root: Eth2Digest,
        strategy: ApiStrategyKind
      ): Future[phase0.Attestation] {.async.} =
@@ -1678,7 +1679,7 @@ proc getAggregatedAttestation*(
       OneThirdDuration,
       ViableNodeStatus,
       {BeaconNodeRole.AggregatedData},
-      getAggregatedAttestationPlain(it, root, slot)):
+      getAggregatedAttestationPlainV2(it, root, slot, committee_index)):
       if apiResponse.isErr():
         handleCommunicationError()
         ApiResponse[GetAggregatedAttestationResponse].err(apiResponse.error)
@@ -1718,7 +1719,7 @@ proc getAggregatedAttestation*(
       OneThirdDuration,
       ViableNodeStatus,
       {BeaconNodeRole.AggregatedData},
-      getAggregatedAttestationPlain(it, root, slot),
+      getAggregatedAttestationPlainV2(it, root, slot, committee_index),
       getAggregatedAttestationDataScore(itresponse)):
       if apiResponse.isErr():
         handleCommunicationError()
@@ -1764,7 +1765,7 @@ proc getAggregatedAttestation*(
       OneThirdDuration,
       ViableNodeStatus,
       {BeaconNodeRole.AggregatedData},
-      getAggregatedAttestationPlain(it, root, slot)):
+      getAggregatedAttestationPlainV2(it, root, slot, committee_index)):
       if apiResponse.isErr():
         handleCommunicationError()
         false

beacon_chain/validator_client/attestation_service.nim

@@ -281,6 +281,7 @@ proc produceAndPublishAggregates(service: AttestationServiceRef,
     let aggAttestation =
       try:
         await vc.getAggregatedAttestation(slot, attestationRoot,
+                                          committeeIndex,
                                           ApiStrategyKind.Best)
       except ValidatorApiError as exc:
         warn "Unable to get aggregated attestation data", slot = slot,

ncli/resttest-rules.json

@@ -4480,7 +4480,7 @@
   {
     "topics": ["validator", "aggregate_attestation"],
     "request": {
-      "url": "/eth/v1/validator/aggregate_attestation",
+      "url": "/eth/v2/validator/aggregate_attestation",
       "headers": {"Accept": "application/json"}
     },
     "response": {
@@ -4492,7 +4492,7 @@
     {
     "topics": ["validator", "aggregate_attestation"],
     "request": {
-      "url": "/eth/v1/validator/aggregate_attestation?slot=0",
+      "url": "/eth/v2/validator/aggregate_attestation?slot=0",
       "headers": {"Accept": "application/json"}
     },
     "response": {
@@ -4504,7 +4504,7 @@
   {
     "topics": ["validator", "aggregate_attestation"],
     "request": {
-      "url": "/eth/v1/validator/aggregate_attestation?slot=&attestation_data_root=",
+      "url": "/eth/v2/validator/aggregate_attestation?slot=&attestation_data_root=",
       "headers": {"Accept": "application/json"}
     },
     "response": {
@@ -4516,7 +4516,29 @@
   {
     "topics": ["validator", "aggregate_attestation"],
     "request": {
-      "url": "/eth/v1/validator/aggregate_attestation?slot=0&attestation_data_root=0x0000000000000000000000000000000000000000000000000000000000000000",
+      "url": "/eth/v2/validator/aggregate_attestation?slot=&attestation_data_root=&committee_index=",
+      "headers": {"Accept": "application/json"}
+    },
+    "response": {
+      "status": {"operator": "equals", "value": "400"},
+      "headers": [{"key": "Content-Type", "value": "application/json", "operator": "equals"}],
+      "body": [{"operator": "jstructcmpns", "value": {"code": 400, "message": ""}}]
+    }
+  },
+  {
+    "topics": ["validator", "aggregate_attestation"],
+    "request": {
+      "url": "/eth/v2/validator/aggregate_attestation?slot=0&attestation_data_root=0x0000000000000000000000000000000000000000000000000000000000000000",
+      "headers": {"Accept": "application/json"}
+    },
+    "response": {
+      "status": {"operator": "oneof", "value": ["400", "200"]}
+    }
+  },
+  {
+    "topics": ["validator", "aggregate_attestation"],
+    "request": {
+      "url": "/eth/v2/validator/aggregate_attestation?slot=0&attestation_data_root=0x0000000000000000000000000000000000000000000000000000000000000000&committee_index=0",
       "headers": {"Accept": "application/json"}
     },
     "response": {

tests/test_attestation_pool.nim

@@ -28,7 +28,8 @@ import
 from std/sequtils import toSeq
 from ./testbcutil import addHeadBlock
 
-func combine(tgt: var phase0.Attestation, src: phase0.Attestation) =
+func combine(tgt: var (phase0.Attestation | electra.Attestation),
+  src: phase0.Attestation | electra.Attestation) =
   ## Combine the signature and participation bitfield, with the assumption that
   ## the same data is being signed - if the signatures overlap, they are not
   ## combined.
@@ -849,10 +850,13 @@ suite "Attestation pool electra processing" & preset():
       # We should now get both attestations for the block, but the aggregate
       # should be the one with the most votes
       pool[].getElectraAttestationsForBlock(state[], cache).len() == 2
-      # pool[].getAggregatedAttestation(2.Slot, 0.CommitteeIndex).
-      #   get().aggregation_bits.countOnes() == 2
-      # pool[].getAggregatedAttestation(2.Slot, hash_tree_root(att2.data)).
-      #   get().aggregation_bits.countOnes() == 2
+      pool[].getElectraAggregatedAttestation(2.Slot, combined[0].data.beacon_block_root,
+        0.CommitteeIndex).get().aggregation_bits.countOnes() == 2
+      pool[].getElectraAggregatedAttestation(2.Slot, hash_tree_root(att2.data), 0.CommitteeIndex).
+         get().aggregation_bits.countOnes() == 2
+      # requests to get and aggregate from different committees should be empty
+      pool[].getElectraAggregatedAttestation(
+        2.Slot, combined[0].data.beacon_block_root, 1.CommitteeIndex).isNone()
 
     let
       # Someone votes for a different root
@@ -949,4 +953,72 @@ suite "Attestation pool electra processing" & preset():
       # with same data, 2 committee bits and 3 aggregation bits
       attestations.len == 1
       attestations[0].aggregation_bits.countOnes() == 3
-      attestations[0].committee_bits.countOnes() == 2
+      attestations[0].committee_bits.countOnes() == 2
+
+
+  test "Working with electra aggregates" & preset():
+    let
+      # Create an attestation for slot 1!
+      bc0 = get_beacon_committee(
+        state[], getStateField(state[], slot), 0.CommitteeIndex, cache)
+
+    var
+      att0 = makeElectraAttestation(
+        state[], state[].latest_block_root, bc0[0], cache)
+      att0x = att0
+      att1 = makeElectraAttestation(
+        state[], state[].latest_block_root, bc0[1], cache)
+      att2 = makeElectraAttestation(
+        state[], state[].latest_block_root, bc0[2], cache)
+      att3 = makeElectraAttestation(
+        state[], state[].latest_block_root, bc0[3], cache)
+
+    # Both attestations include member 2 but neither is a subset of the other
+    att0.combine(att2)
+    att1.combine(att2)
+
+    check:
+      not pool[].covers(att0.data, att0.aggregation_bits)
+
+    pool[].addAttestation(
+      att0, @[bc0[0], bc0[2]], att0.loadSig, att0.data.slot.start_beacon_time)
+    pool[].addAttestation(
+      att1, @[bc0[1], bc0[2]], att1.loadSig, att1.data.slot.start_beacon_time)
+
+    check:
+      process_slots(
+        defaultRuntimeConfig, state[],
+        getStateField(state[], slot) + MIN_ATTESTATION_INCLUSION_DELAY, cache,
+        info, {}).isOk()
+
+    check:
+      pool[].getElectraAttestationsForBlock(state[], cache).len() == 1
+      # Can get either aggregate here, random!
+      pool[].getElectraAggregatedAttestation(
+        1.Slot, att0.data.beacon_block_root, 0.CommitteeIndex).isSome()
+
+    # Add in attestation 3 - both aggregates should now have it added
+    pool[].addAttestation(
+      att3, @[bc0[3]], att3.loadSig, att3.data.slot.start_beacon_time)
+
+    block:
+      let attestations = pool[].getElectraAttestationsForBlock(state[], cache)
+      check:
+        attestations.len() == 1
+        attestations[0].aggregation_bits.countOnes() == 6
+        # Can get either aggregate here, random!
+        pool[].getElectraAggregatedAttestation(
+          1.Slot, attestations[0].data.beacon_block_root, 0.CommitteeIndex).isSome()
+
+    # Add in attestation 0 as single - attestation 1 is now a superset of the
+    # aggregates in the pool, so everything else should be removed
+    pool[].addAttestation(
+      att0x, @[bc0[0]], att0x.loadSig, att0x.data.slot.start_beacon_time)
+
+    block:
+      let attestations = pool[].getElectraAttestationsForBlock(state[], cache)
+      check:
+        attestations.len() == 1
+        attestations[0].aggregation_bits.countOnes() == 4
+        pool[].getElectraAggregatedAttestation(
+          1.Slot, attestations[0].data.beacon_block_root, 0.CommitteeIndex).isSome()