github/prysm
1
1
Fork 0
mirror of https://github.com/OffchainLabs/prysm.git synced 2026-01-08 23:18:15 -05:00
Code Issues Packages Projects Releases Wiki Activity
Files
2773bdef89ab460aea4353d4d98833a4eeaa4918
prysm/beacon-chain/sync/validate_beacon_attestation_test.go
Bastin 92bd211e4d upgrade v6 to v7 (#15989) 
* upgrade v6 to v7

* changelog

* update-go-ssz
2025-11-06 16:16:23 +00:00

652 lines
21 KiB
Go
Raw Blame History

package sync
import (
"bytes"
"context"
"fmt"
"testing"
"time"
"github.com/OffchainLabs/go-bitfield"
mockChain "github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/testing"
"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
dbtest "github.com/OffchainLabs/prysm/v7/beacon-chain/db/testing"
p2ptest "github.com/OffchainLabs/prysm/v7/beacon-chain/p2p/testing"
"github.com/OffchainLabs/prysm/v7/beacon-chain/startup"
mockSync "github.com/OffchainLabs/prysm/v7/beacon-chain/sync/initial-sync/testing"
lruwrpr "github.com/OffchainLabs/prysm/v7/cache/lru"
fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
"github.com/OffchainLabs/prysm/v7/config/params"
"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
"github.com/OffchainLabs/prysm/v7/testing/assert"
"github.com/OffchainLabs/prysm/v7/testing/require"
"github.com/OffchainLabs/prysm/v7/testing/util"
pubsub "github.com/libp2p/go-libp2p-pubsub"
pubsubpb "github.com/libp2p/go-libp2p-pubsub/pb"
)
func TestService_validateCommitteeIndexBeaconAttestation(t *testing.T) {
p := p2ptest.NewTestP2P(t)
db := dbtest.SetupDB(t)
chain := &mockChain.ChainService{
// 1 slot ago.
Genesis: time.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second),
ValidatorsRoot: [32]byte{'A'},
ValidAttestation: true,
DB: db,
Optimistic: true,
}
ctx, cancel := context.WithCancel(t.Context())
defer cancel()
s := &Service{
ctx: ctx,
cfg: &config{
initialSync: &mockSync.Sync{IsSyncing: false},
p2p: p,
beaconDB: db,
chain: chain,
clock: startup.NewClock(chain.Genesis, chain.ValidatorsRoot),
attestationNotifier: (&mockChain.ChainService{}).OperationNotifier(),
},
blkRootToPendingAtts: make(map[[32]byte][]any),
seenUnAggregatedAttestationCache: lruwrpr.New(10),
signatureChan: make(chan *signatureVerifier, verifierLimit),
}
s.initCaches()
go s.verifierRoutine()
invalidRoot := [32]byte{'A', 'B', 'C', 'D'}
s.setBadBlock(ctx, invalidRoot)
digest, err := s.currentForkDigest()
require.NoError(t, err)
blk := util.NewBeaconBlock()
blk.Block.Slot = 1
util.SaveBlock(t, ctx, db, blk)
validBlockRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err)
chain.FinalizedCheckPoint = &ethpb.Checkpoint{
Root: validBlockRoot[:],
Epoch: 0,
}
validators := uint64(64)
savedState, keys := util.DeterministicGenesisState(t, validators)
require.NoError(t, savedState.SetSlot(1))
require.NoError(t, db.SaveState(t.Context(), savedState, validBlockRoot))
chain.State = savedState
tests := []struct {
name string
msg ethpb.Att
topic string
validAttestationSignature bool
want bool
}{
{
name: "valid attestation signature",
msg: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b101},
Data: &ethpb.AttestationData{
BeaconBlockRoot: validBlockRoot[:],
CommitteeIndex: 0,
Slot: 1,
Target: &ethpb.Checkpoint{
Epoch: 0,
Root: validBlockRoot[:],
},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
},
topic: fmt.Sprintf("/eth2/%x/beacon_attestation_1", digest),
validAttestationSignature: true,
want: true,
},
{
name: "valid attestation signature with nil topic",
msg: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b101},
Data: &ethpb.AttestationData{
BeaconBlockRoot: validBlockRoot[:],
CommitteeIndex: 0,
Slot: 1,
Target: &ethpb.Checkpoint{
Epoch: 0,
Root: validBlockRoot[:],
},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
},
topic: "",
validAttestationSignature: true,
want: false,
},
{
name: "bad target epoch",
msg: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b101},
Data: &ethpb.AttestationData{
BeaconBlockRoot: validBlockRoot[:],
CommitteeIndex: 0,
Slot: 1,
Target: &ethpb.Checkpoint{
Epoch: 10,
Root: validBlockRoot[:],
},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
},
topic: fmt.Sprintf("/eth2/%x/beacon_attestation_1", digest),
validAttestationSignature: true,
want: false,
},
{
name: "already seen",
msg: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b101},
Data: &ethpb.AttestationData{
BeaconBlockRoot: validBlockRoot[:],
CommitteeIndex: 0,
Slot: 1,
Target: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
},
topic: fmt.Sprintf("/eth2/%x/beacon_attestation_1", digest),
validAttestationSignature: true,
want: false,
},
{
name: "invalid beacon block",
msg: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b101},
Data: &ethpb.AttestationData{
BeaconBlockRoot: invalidRoot[:],
CommitteeIndex: 0,
Slot: 1,
Target: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
},
topic: fmt.Sprintf("/eth2/%x/beacon_attestation_1", digest),
validAttestationSignature: true,
want: false,
},
{
name: "committee index exceeds committee length",
msg: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b101},
Data: &ethpb.AttestationData{
BeaconBlockRoot: validBlockRoot[:],
CommitteeIndex: 4,
Slot: 1,
Target: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
},
topic: fmt.Sprintf("/eth2/%x/beacon_attestation_2", digest),
validAttestationSignature: true,
want: false,
},
{
name: "wrong committee index",
msg: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b101},
Data: &ethpb.AttestationData{
BeaconBlockRoot: validBlockRoot[:],
CommitteeIndex: 2,
Slot: 1,
Target: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
},
topic: fmt.Sprintf("/eth2/%x/beacon_attestation_2", digest),
validAttestationSignature: true,
want: false,
},
{
name: "already aggregated",
msg: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b1011},
Data: &ethpb.AttestationData{
BeaconBlockRoot: validBlockRoot[:],
CommitteeIndex: 1,
Slot: 1,
Target: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
},
topic: fmt.Sprintf("/eth2/%x/beacon_attestation_1", digest),
validAttestationSignature: true,
want: false,
},
{
name: "missing block",
msg: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b101},
Data: &ethpb.AttestationData{
BeaconBlockRoot: bytesutil.PadTo([]byte("missing"), fieldparams.RootLength),
CommitteeIndex: 1,
Slot: 1,
Target: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
},
topic: fmt.Sprintf("/eth2/%x/beacon_attestation_1", digest),
validAttestationSignature: true,
want: false,
},
{
name: "invalid attestation",
msg: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b101},
Data: &ethpb.AttestationData{
BeaconBlockRoot: validBlockRoot[:],
CommitteeIndex: 1,
Slot: 1,
Target: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
},
topic: fmt.Sprintf("/eth2/%x/beacon_attestation_1", digest),
validAttestationSignature: false,
want: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
helpers.ClearCache()
chain.ValidAttestation = tt.validAttestationSignature
if tt.validAttestationSignature {
com, err := helpers.BeaconCommitteeFromState(t.Context(), savedState, tt.msg.GetData().Slot, tt.msg.GetData().CommitteeIndex)
require.NoError(t, err)
domain, err := signing.Domain(savedState.Fork(), tt.msg.GetData().Target.Epoch, params.BeaconConfig().DomainBeaconAttester, savedState.GenesisValidatorsRoot())
require.NoError(t, err)
attRoot, err := signing.ComputeSigningRoot(tt.msg.GetData(), domain)
require.NoError(t, err)
for i := 0; ; i++ {
if tt.msg.GetAggregationBits().BitAt(uint64(i)) {
tt.msg.SetSignature(keys[com[i]].Sign(attRoot[:]).Marshal())
break
}
}
} else {
tt.msg.SetSignature(make([]byte, 96))
}
buf := new(bytes.Buffer)
_, err := p.Encoding().EncodeGossip(buf, tt.msg)
require.NoError(t, err)
m := &pubsub.Message{
Message: &pubsubpb.Message{
Data: buf.Bytes(),
Topic: &tt.topic,
},
}
if tt.topic == "" {
m.Message.Topic = nil
}
res, err := s.validateCommitteeIndexBeaconAttestation(ctx, "", m)
received := res == pubsub.ValidationAccept
if received != tt.want {
t.Fatalf("Did not received wanted validation. Got %v, wanted %v", !tt.want, tt.want)
}
if tt.want && err != nil {
t.Errorf("Non nil error returned: %v", err)
}
if tt.want && m.ValidatorData == nil {
t.Error("Expected validator data to be set")
}
})
}
}
func TestService_validateCommitteeIndexBeaconAttestationElectra(t *testing.T) {
params.SetupTestConfigCleanup(t)
params.BeaconConfig().InitializeForkSchedule()
p := p2ptest.NewTestP2P(t)
db := dbtest.SetupDB(t)
currentSlot := 1 + (primitives.Slot(params.BeaconConfig().ElectraForkEpoch) * params.BeaconConfig().SlotsPerEpoch)
genesisOffset := time.Duration(currentSlot) * time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second
chain := &mockChain.ChainService{
Genesis: time.Now().Add(-1 * genesisOffset),
ValidatorsRoot: params.BeaconConfig().GenesisValidatorsRoot,
ValidAttestation: true,
DB: db,
Optimistic: true,
}
ctx, cancel := context.WithCancel(t.Context())
defer cancel()
s := &Service{
ctx: ctx,
cfg: &config{
initialSync: &mockSync.Sync{IsSyncing: false},
p2p: p,
beaconDB: db,
chain: chain,
clock: startup.NewClock(chain.Genesis, chain.ValidatorsRoot),
attestationNotifier: (&mockChain.ChainService{}).OperationNotifier(),
},
blkRootToPendingAtts: make(map[[32]byte][]any),
seenUnAggregatedAttestationCache: lruwrpr.New(10),
signatureChan: make(chan *signatureVerifier, verifierLimit),
}
require.Equal(t, currentSlot, s.cfg.clock.CurrentSlot())
s.initCaches()
go s.verifierRoutine()
digest, err := s.currentForkDigest()
require.NoError(t, err)
blk := util.NewBeaconBlock()
blk.Block.Slot = s.cfg.clock.CurrentSlot()
util.SaveBlock(t, ctx, db, blk)
validBlockRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err)
chain.FinalizedCheckPoint = &ethpb.Checkpoint{
Root: validBlockRoot[:],
Epoch: 0,
}
validators := uint64(64)
savedState, keys := util.DeterministicGenesisState(t, validators)
require.NoError(t, savedState.SetSlot(s.cfg.clock.CurrentSlot()))
require.NoError(t, db.SaveState(t.Context(), savedState, validBlockRoot))
chain.State = savedState
committee, err := helpers.BeaconCommitteeFromState(ctx, savedState, s.cfg.clock.CurrentSlot(), 0)
require.NoError(t, err)
tests := []struct {
name string
msg ethpb.Att
want bool
}{
{
name: "valid",
msg: &ethpb.SingleAttestation{
Data: &ethpb.AttestationData{
BeaconBlockRoot: validBlockRoot[:],
CommitteeIndex: 0,
Slot: s.cfg.clock.CurrentSlot(),
Target: &ethpb.Checkpoint{
Epoch: s.cfg.clock.CurrentEpoch(),
Root: validBlockRoot[:],
},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
AttesterIndex: committee[0],
},
want: true,
},
{
name: "non-zero committee index in att data",
msg: &ethpb.SingleAttestation{
Data: &ethpb.AttestationData{
BeaconBlockRoot: validBlockRoot[:],
CommitteeIndex: 1,
Slot: s.cfg.clock.CurrentSlot(),
Target: &ethpb.Checkpoint{
Epoch: s.cfg.clock.CurrentEpoch(),
Root: validBlockRoot[:],
},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
AttesterIndex: committee[0],
},
want: false,
},
{
name: "attesting index not in committee",
msg: &ethpb.SingleAttestation{
Data: &ethpb.AttestationData{
BeaconBlockRoot: validBlockRoot[:],
CommitteeIndex: 1,
Slot: s.cfg.clock.CurrentSlot(),
Target: &ethpb.Checkpoint{
Epoch: s.cfg.clock.CurrentEpoch(),
Root: validBlockRoot[:],
},
Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
},
AttesterIndex: 999999,
},
want: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
helpers.ClearCache()
com, err := helpers.BeaconCommitteeFromState(t.Context(), savedState, tt.msg.GetData().Slot, tt.msg.GetData().CommitteeIndex)
require.NoError(t, err)
domain, err := signing.Domain(savedState.Fork(), tt.msg.GetData().Target.Epoch, params.BeaconConfig().DomainBeaconAttester, savedState.GenesisValidatorsRoot())
require.NoError(t, err)
attRoot, err := signing.ComputeSigningRoot(tt.msg.GetData(), domain)
require.NoError(t, err)
tt.msg.SetSignature(keys[com[0]].Sign(attRoot[:]).Marshal())
buf := new(bytes.Buffer)
_, err = p.Encoding().EncodeGossip(buf, tt.msg)
require.NoError(t, err)
topic := fmt.Sprintf("/eth2/%x/beacon_attestation_1", digest)
m := &pubsub.Message{
Message: &pubsubpb.Message{
Data: buf.Bytes(),
Topic: &topic,
},
}
res, err := s.validateCommitteeIndexBeaconAttestation(ctx, "", m)
received := res == pubsub.ValidationAccept
if received != tt.want {
t.Fatalf("Did not received wanted validation. Got %v, wanted %v", !tt.want, tt.want)
}
if tt.want && err != nil {
t.Errorf("Non nil error returned: %v", err)
}
if tt.want && m.ValidatorData == nil {
t.Error("Expected validator data to be set")
}
})
}
}
func TestService_setSeenUnaggregatedAtt(t *testing.T) {
s := NewService(t.Context(), WithP2P(p2ptest.NewTestP2P(t)))
// Helper function to generate key and handle errors in tests
generateKey := func(t *testing.T, att ethpb.Att) string {
key, err := generateUnaggregatedAttCacheKey(att)
require.NoError(t, err)
return key
}
t.Run("phase0", func(t *testing.T) {
s.initCaches()
s0c0a0 := &ethpb.Attestation{
Data: &ethpb.AttestationData{Slot: 0, CommitteeIndex: 0},
AggregationBits: bitfield.Bitlist{0b1001},
}
s0c0a1 := &ethpb.Attestation{
Data: &ethpb.AttestationData{Slot: 0, CommitteeIndex: 0},
AggregationBits: bitfield.Bitlist{0b1010},
}
s0c0a2 := &ethpb.Attestation{
Data: &ethpb.AttestationData{Slot: 0, CommitteeIndex: 0},
AggregationBits: bitfield.Bitlist{0b1100},
}
s0c1a0 := &ethpb.Attestation{
Data: &ethpb.AttestationData{Slot: 0, CommitteeIndex: 1},
AggregationBits: bitfield.Bitlist{0b1001},
}
s0c2a0 := &ethpb.Attestation{
Data: &ethpb.AttestationData{Slot: 0, CommitteeIndex: 2},
AggregationBits: bitfield.Bitlist{0b1001},
}
s1c0a0 := &ethpb.Attestation{
Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 0},
AggregationBits: bitfield.Bitlist{0b1001},
}
s2c0a0 := &ethpb.Attestation{
Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 0},
AggregationBits: bitfield.Bitlist{0b1001},
}
t.Run("empty cache", func(t *testing.T) {
key := generateKey(t, s0c0a0)
assert.Equal(t, false, s.hasSeenUnaggregatedAtt(key))
})
t.Run("ok", func(t *testing.T) {
key := generateKey(t, s0c0a0)
s.setSeenUnaggregatedAtt(key)
assert.Equal(t, true, s.hasSeenUnaggregatedAtt(key))
})
t.Run("different slot", func(t *testing.T) {
key1 := generateKey(t, s1c0a0)
key2 := generateKey(t, s2c0a0)
s.setSeenUnaggregatedAtt(key1)
assert.Equal(t, false, s.hasSeenUnaggregatedAtt(key2))
})
t.Run("different committee index", func(t *testing.T) {
key1 := generateKey(t, s0c1a0)
key2 := generateKey(t, s0c2a0)
s.setSeenUnaggregatedAtt(key1)
assert.Equal(t, false, s.hasSeenUnaggregatedAtt(key2))
})
t.Run("different bit", func(t *testing.T) {
key1 := generateKey(t, s0c0a1)
key2 := generateKey(t, s0c0a2)
s.setSeenUnaggregatedAtt(key1)
assert.Equal(t, false, s.hasSeenUnaggregatedAtt(key2))
})
t.Run("0 bits set is considered not seen", func(t *testing.T) {
a := &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b1000}}
_, err := generateUnaggregatedAttCacheKey(a)
require.Equal(t, err != nil, true, "Should error because no bits set is invalid")
})
t.Run("multiple bits set is considered not seen", func(t *testing.T) {
a := &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b1111}}
_, err := generateUnaggregatedAttCacheKey(a)
require.Equal(t, err != nil, true, "Should error because no bits set is invalid")
})
})
t.Run("electra", func(t *testing.T) {
s.initCaches()
s0c0a0 := &ethpb.SingleAttestation{
Data: &ethpb.AttestationData{Slot: 0},
CommitteeId: 0,
AttesterIndex: 0,
}
s0c0a1 := &ethpb.SingleAttestation{
Data: &ethpb.AttestationData{Slot: 0},
CommitteeId: 0,
AttesterIndex: 1,
}
s0c0a2 := &ethpb.SingleAttestation{
Data: &ethpb.AttestationData{Slot: 0},
CommitteeId: 0,
AttesterIndex: 2,
}
s0c1a0 := &ethpb.SingleAttestation{
Data: &ethpb.AttestationData{Slot: 0},
CommitteeId: 1,
AttesterIndex: 0,
}
s0c2a0 := &ethpb.SingleAttestation{
Data: &ethpb.AttestationData{Slot: 0},
CommitteeId: 2,
AttesterIndex: 0,
}
s1c0a0 := &ethpb.SingleAttestation{
Data: &ethpb.AttestationData{Slot: 1},
CommitteeId: 0,
AttesterIndex: 0,
}
s2c0a0 := &ethpb.SingleAttestation{
Data: &ethpb.AttestationData{Slot: 2},
CommitteeId: 0,
AttesterIndex: 0,
}
t.Run("empty cache", func(t *testing.T) {
key := generateKey(t, s0c0a0)
assert.Equal(t, false, s.hasSeenUnaggregatedAtt(key))
})
t.Run("ok", func(t *testing.T) {
key := generateKey(t, s0c0a0)
s.setSeenUnaggregatedAtt(key)
assert.Equal(t, true, s.hasSeenUnaggregatedAtt(key))
})
t.Run("different slot", func(t *testing.T) {
key1 := generateKey(t, s1c0a0)
key2 := generateKey(t, s2c0a0)
s.setSeenUnaggregatedAtt(key1)
assert.Equal(t, false, s.hasSeenUnaggregatedAtt(key2))
})
t.Run("different committee index", func(t *testing.T) {
key1 := generateKey(t, s0c1a0)
key2 := generateKey(t, s0c2a0)
s.setSeenUnaggregatedAtt(key1)
assert.Equal(t, false, s.hasSeenUnaggregatedAtt(key2))
})
t.Run("different attester", func(t *testing.T) {
key1 := generateKey(t, s0c0a1)
key2 := generateKey(t, s0c0a2)
s.setSeenUnaggregatedAtt(key1)
assert.Equal(t, false, s.hasSeenUnaggregatedAtt(key2))
})
t.Run("single attestation is considered not seen", func(t *testing.T) {
a := &ethpb.AttestationElectra{}
_, err := generateUnaggregatedAttCacheKey(a)
require.Equal(t, err != nil, true, "Should error because no bits set is invalid")
})
})
}
func Test_validateCommitteeIndexAndCount_Boundary(t *testing.T) {
ctx := t.Context()
// Create a minimal state with a known number of validators.
validators := uint64(64)
bs, _ := util.DeterministicGenesisState(t, validators)
require.NoError(t, bs.SetSlot(1))
s := &Service{}
// Build a minimal Phase0 attestation (unaggregated path).
att := &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 1,
CommitteeIndex: 0,
},
}
// First call to obtain the active validator count used to derive committees per slot.
_, valCount, res, err := s.validateCommitteeIndexAndCount(ctx, att, bs)
require.NoError(t, err)
require.Equal(t, pubsub.ValidationAccept, res)
count := helpers.SlotCommitteeCount(valCount)
// committee_index == count - 1 should be accepted.
att.Data.CommitteeIndex = primitives.CommitteeIndex(count - 1)
_, _, res, err = s.validateCommitteeIndexAndCount(ctx, att, bs)
require.NoError(t, err)
require.Equal(t, pubsub.ValidationAccept, res)
// committee_index == count should be rejected (out of range).
att.Data.CommitteeIndex = primitives.CommitteeIndex(count)
_, _, res, err = s.validateCommitteeIndexAndCount(ctx, att, bs)
require.ErrorContains(t, "committee index", err)
require.Equal(t, pubsub.ValidationReject, res)
}
Reference in New Issue View Git Blame Copy Permalink