lstar: skip trivial 1-raw-sig + 0-children case in aggregate()

Extend the early-skip predicate in `aggregate()` so an `AttestationData`
with exactly one raw gossip sig and no child proofs is not aggregated.

Why:

- A 1-validator "aggregate" carries no information the raw gossip sig
  doesn't already carry. The sig is on the per-subnet
  `attestation_signatures` gossip topic at sign time, so any peer
  aggregator can fold it in as a raw entry next round.
- The recursive STARK prover (`xmss/aggregation.py:aggregate`) is
  roughly constant-cost in input size — building a 1-validator proof
  costs the same as building a 32-validator one. On the multi-client
  devnet this caused two zeam aggregators to spend ~10.8 s of FFI per
  worker run on a single-validator proof, dropping ~50% of slot
  triggers as `in_flight`. See blockblaz/zeam#907.

The unconsumed gossip sig is preserved in `store.attestation_signatures`
by the existing bookkeeping (only sigs whose `att_data` produced an
aggregate are pruned), so a future round folds it in once another sig
or a child shows up.

Test changes:

- Add `test_aggregate_skips_single_gossip_sig_with_no_children` covering
  the new skip case and asserting the sig survives in the store.
- Update `test_multiple_attestation_data_grouped_separately` to seed
  two raw sigs per `att_data`. The original test put one sig per
  data, which is now (correctly) the trivial case that does not
  produce a proof; the test's intent — that two distinct
  `AttestationData` produce two distinct proofs — is preserved by
  upgrading both groups to non-trivial inputs.

Closes #747

Author: ch4r10t33r

src/lean_spec/forks/lstar/spec.py

@@ -1676,10 +1676,28 @@ def aggregate(self, store: LstarStore) -> tuple[LstarStore, list[SignedAggregate
                 if e.validator_id not in covered
             ]
 
-            # The aggregation layer enforces a minimum: either at least one
-            # raw signature, or at least two child proofs to merge.
+            # Skip cases where running the prover provides no consensus value:
             #
-            # A lone child proof is already a valid proof — nothing to do.
+            #   - 0 raw + 0 children: nothing to aggregate.
+            #   - 0 raw + 1 child:    a lone child proof is already a valid
+            #                         proof; nothing to do.
+            #   - 1 raw + 0 children: a single-validator "aggregate" carries
+            #                         no information the raw gossip sig
+            #                         doesn't already carry — the sig is on
+            #                         the per-subnet `attestation_signatures`
+            #                         gossip topic at sign time, so any peer
+            #                         aggregator can fold it in as a raw
+            #                         entry next round. The recursive STARK
+            #                         prover is constant-cost in input size,
+            #                         so building a 1-validator proof spends
+            #                         the full prover budget for zero
+            #                         consensus signal. The unconsumed gossip
+            #                         sig stays in `store.attestation_signatures`
+            #                         (see bookkeeping below) and gets folded
+            #                         in by a future round once another sig
+            #                         or a child shows up.
+            if not child_proofs and len(raw_entries) <= 1:
+                continue
             if not raw_entries and len(child_proofs) < 2:
                 continue
 

tests/lean_spec/forks/lstar/forkchoice/test_store_attestations.py

@@ -593,12 +593,33 @@ def test_multiple_attestation_data_grouped_separately(
             source=att_data_1.source,
         )
 
-        # Validators 1 attests to data_1, validator 2 attests to data_2
-        sig_1 = key_manager.sign_attestation_data(ValidatorIndex(1), att_data_1)
-        sig_2 = key_manager.sign_attestation_data(ValidatorIndex(2), att_data_2)
+        # Validators 1, 3 attest to data_1; validators 2, 0 attest to data_2.
+        # Two distinct sigs per att_data is the minimum non-trivial shape:
+        # `aggregate()` skips the `1 raw + 0 children` case (a single-validator
+        # "aggregate" carries no information the raw gossip sig doesn't
+        # already carry), so this test must seed at least two raw sigs per
+        # `att_data` for the per-data grouping it is asserting.
         attestation_signatures = {
-            att_data_1: {AttestationSignatureEntry(ValidatorIndex(1), sig_1)},
-            att_data_2: {AttestationSignatureEntry(ValidatorIndex(2), sig_2)},
+            att_data_1: {
+                AttestationSignatureEntry(
+                    ValidatorIndex(1),
+                    key_manager.sign_attestation_data(ValidatorIndex(1), att_data_1),
+                ),
+                AttestationSignatureEntry(
+                    ValidatorIndex(3),
+                    key_manager.sign_attestation_data(ValidatorIndex(3), att_data_1),
+                ),
+            },
+            att_data_2: {
+                AttestationSignatureEntry(
+                    ValidatorIndex(2),
+                    key_manager.sign_attestation_data(ValidatorIndex(2), att_data_2),
+                ),
+                AttestationSignatureEntry(
+                    ValidatorIndex(0),
+                    key_manager.sign_attestation_data(ValidatorIndex(0), att_data_2),
+                ),
+            },
         }
 
         store = base_store.model_copy(

tests/lean_spec/forks/lstar/state/test_state_aggregation.py

@@ -141,6 +141,41 @@ def test_aggregate_with_empty_attestation_signatures(
     assert results == []
 
 
+def test_aggregate_skips_single_gossip_sig_with_no_children(
+    container_key_manager: XmssKeyManager,
+    spec: LstarSpec,
+) -> None:
+    """Trivial 1 raw sig + 0 children case: aggregate returns nothing.
+
+    A single-validator "aggregate" carries no information the raw gossip
+    sig doesn't already carry — the sig is on the per-subnet
+    `attestation_signatures` gossip topic at sign time, so any peer
+    aggregator can fold it in as a raw entry next round. The recursive
+    STARK prover is constant-cost in input size, so building a
+    1-validator proof spends the full prover budget for zero consensus
+    signal. The unconsumed gossip sig must remain in
+    `store.attestation_signatures` so it is folded in by a future round
+    once another sig or a child shows up.
+    """
+    store = make_store(num_validators=2, key_manager=container_key_manager)
+    source = Checkpoint(root=make_bytes32(1), slot=Slot(0))
+    att_data = make_attestation_data_simple(
+        Slot(2), make_bytes32(3), make_bytes32(4), source=source
+    )
+    sig_entry = AttestationSignatureEntry(
+        ValidatorIndex(0),
+        container_key_manager.sign_attestation_data(ValidatorIndex(0), att_data),
+    )
+    attestation_signatures = {att_data: {sig_entry}}
+
+    store = store.model_copy(update={"attestation_signatures": attestation_signatures})
+    updated_store, results = spec.aggregate(store)
+
+    assert results == []
+    # The lone sig must survive untouched for a later, non-trivial pass.
+    assert updated_store.attestation_signatures == attestation_signatures
+
+
 def test_aggregated_signatures_with_multiple_data_groups(
     container_key_manager: XmssKeyManager,
     spec: LstarSpec,