fix: align attester light client RPC data

modules/network/keeper/grpc_query.go

@@ -257,3 +257,34 @@ func (q *queryServer) AttesterInfo(c context.Context, req *types.QueryAttesterIn
 		AttesterInfo: attesterInfo,
 	}, nil
 }
+
+// Attesters queries the registered attester set.
+func (q *queryServer) Attesters(c context.Context, req *types.QueryAttestersRequest) (*types.QueryAttestersResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+
+	ctx := sdk.UnwrapSDKContext(c)
+
+	attesterAddresses, err := q.keeper.GetAllAttesters(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("get all attesters: %w", err)
+	}
+
+	attesters := make([]*types.RegisteredAttester, 0, len(attesterAddresses))
+	for _, address := range attesterAddresses {
+		attesterInfo, err := q.keeper.GetAttesterInfo(ctx, address)
+		if err != nil {
+			return nil, fmt.Errorf("get attester info for %s: %w", address, err)
+		}
+
+		attesters = append(attesters, &types.RegisteredAttester{
+			ValidatorAddress: address,
+			AttesterInfo:     attesterInfo,
+		})
+	}
+
+	return &types.QueryAttestersResponse{
+		Attesters: attesters,
+	}, nil
+}

modules/network/keeper/grpc_query_test.go

@@ -0,0 +1,89 @@
+package keeper
+
+import (
+	"testing"
+
+	"github.com/cometbft/cometbft/crypto/ed25519"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/evstack/ev-abci/modules/network/types"
+)
+
+func TestAttestersQueryReturnsRegisteredAttesterInfo(t *testing.T) {
+	newQueryServer := func(t *testing.T) (types.QueryServer, Keeper, sdk.Context) {
+		t.Helper()
+		sk := NewMockStakingKeeper()
+		_, keeper, ctx := newTestServer(t, &sk)
+		return NewQueryServer(keeper), keeper, ctx
+	}
+
+	t.Run("nil request", func(t *testing.T) {
+		queryServer, _, ctx := newQueryServer(t)
+
+		resp, err := queryServer.Attesters(ctx, nil)
+
+		require.Nil(t, resp)
+		require.Error(t, err)
+		require.Equal(t, codes.InvalidArgument, status.Code(err))
+	})
+
+	t.Run("empty set", func(t *testing.T) {
+		queryServer, _, ctx := newQueryServer(t)
+
+		resp, err := queryServer.Attesters(ctx, &types.QueryAttestersRequest{})
+
+		require.NoError(t, err)
+		require.NotNil(t, resp)
+		require.Empty(t, resp.Attesters)
+	})
+
+	t.Run("joined attester with pubkey", func(t *testing.T) {
+		queryServer, keeper, ctx := newQueryServer(t)
+		pubKeyAny := newAttesterPubKeyAny(t)
+		consensusAddress := sdk.ValAddress(ed25519.GenPrivKey().PubKey().Address()).String()
+		attesterInfo := &types.AttesterInfo{
+			Authority:    sdk.AccAddress("operator").String(),
+			Pubkey:       pubKeyAny,
+			JoinedHeight: ctx.BlockHeight(),
+		}
+		require.NoError(t, keeper.SetAttesterSetMember(ctx, consensusAddress))
+		require.NoError(t, keeper.SetAttesterInfo(ctx, consensusAddress, attesterInfo))
+
+		resp, err := queryServer.Attesters(ctx, &types.QueryAttestersRequest{})
+
+		require.NoError(t, err)
+		require.Len(t, resp.Attesters, 1)
+		require.Equal(t, consensusAddress, resp.Attesters[0].ValidatorAddress)
+		require.Equal(t, attesterInfo.Authority, resp.Attesters[0].AttesterInfo.Authority)
+		require.Equal(t, attesterInfo.JoinedHeight, resp.Attesters[0].AttesterInfo.JoinedHeight)
+		require.Equal(t, pubKeyAny.TypeUrl, resp.Attesters[0].AttesterInfo.Pubkey.TypeUrl)
+		require.Equal(t, pubKeyAny.Value, resp.Attesters[0].AttesterInfo.Pubkey.Value)
+	})
+
+	t.Run("missing attester info", func(t *testing.T) {
+		queryServer, keeper, ctx := newQueryServer(t)
+		consensusAddress := sdk.ValAddress(ed25519.GenPrivKey().PubKey().Address()).String()
+		require.NoError(t, keeper.SetAttesterSetMember(ctx, consensusAddress))
+
+		resp, err := queryServer.Attesters(ctx, &types.QueryAttestersRequest{})
+
+		require.Nil(t, resp)
+		require.Error(t, err)
+	})
+}
+
+func newAttesterPubKeyAny(t *testing.T) *codectypes.Any {
+	t.Helper()
+
+	sdkPubKey, err := cryptocodec.FromCmtPubKeyInterface(ed25519.GenPrivKey().PubKey())
+	require.NoError(t, err)
+
+	pubKeyAny, err := codectypes.NewAnyWithValue(sdkPubKey)
+	require.NoError(t, err)
+	return pubKeyAny
+}

modules/network/keeper/keeper.go

@@ -282,8 +282,8 @@ func (k Keeper) CheckQuorum(ctx sdk.Context, votedPower, totalPower uint64) (boo
 		return false, fmt.Errorf("invalid quorum fraction: %w", err)
 	}
 
-	requiredPower := math.LegacyNewDec(int64(totalPower)).Mul(quorumFrac).TruncateInt().Uint64()
-	return votedPower >= requiredPower, nil
+	requiredPower := math.LegacyNewDec(int64(totalPower)).Mul(quorumFrac)
+	return math.LegacyNewDec(int64(votedPower)).GT(requiredPower), nil
 }
 
 // IsSoftConfirmed checks if a block at a given height is soft-confirmed

modules/network/keeper/msg_server_test.go

@@ -342,6 +342,88 @@ func TestAttest(t *testing.T) {
 	}
 }
 
+func TestAttestWithMultipleAttestersTracksQuorumAndSignatures(t *testing.T) {
+	sk := NewMockStakingKeeper()
+	server, keeper, ctx := newTestServer(t, &sk)
+	require.NoError(t, keeper.SetParams(ctx, types.DefaultParams()))
+
+	attesters := []struct {
+		authority        string
+		consensusAddress string
+		vote             []byte
+	}{
+		{
+			authority:        sdk.AccAddress("operator1").String(),
+			consensusAddress: sdk.ValAddress("attester1").String(),
+			vote:             bytes.Repeat([]byte{0x01}, MinVoteLen),
+		},
+		{
+			authority:        sdk.AccAddress("operator2").String(),
+			consensusAddress: sdk.ValAddress("attester2").String(),
+			vote:             bytes.Repeat([]byte{0x02}, MinVoteLen),
+		},
+		{
+			authority:        sdk.AccAddress("operator3").String(),
+			consensusAddress: sdk.ValAddress("attester3").String(),
+			vote:             bytes.Repeat([]byte{0x03}, MinVoteLen),
+		},
+		{
+			authority:        sdk.AccAddress("operator4").String(),
+			consensusAddress: sdk.ValAddress("attester4").String(),
+			vote:             bytes.Repeat([]byte{0x04}, MinVoteLen),
+		},
+	}
+	for _, attester := range attesters {
+		_, err := server.JoinAttesterSet(ctx, &types.MsgJoinAttesterSet{
+			Authority:        attester.authority,
+			ConsensusAddress: attester.consensusAddress,
+		})
+		require.NoError(t, err)
+	}
+	require.NoError(t, keeper.BuildValidatorIndexMap(ctx))
+
+	height := int64(10)
+	for i, attester := range attesters {
+		rsp, err := server.Attest(ctx, &types.MsgAttest{
+			Authority:        attester.authority,
+			ConsensusAddress: attester.consensusAddress,
+			Height:           height,
+			Vote:             attester.vote,
+		})
+		require.NoError(t, err)
+		require.NotNil(t, rsp)
+
+		bitmap, err := keeper.GetAttestationBitmap(ctx, height)
+		require.NoError(t, err)
+		votedPower, err := keeper.CalculateVotedPower(ctx, bitmap)
+		require.NoError(t, err)
+		require.Equal(t, uint64(i+1), votedPower)
+
+		totalPower, err := keeper.GetTotalPower(ctx)
+		require.NoError(t, err)
+		require.Equal(t, uint64(4), totalPower)
+
+		quorumReached, err := keeper.CheckQuorum(ctx, votedPower, totalPower)
+		require.NoError(t, err)
+		require.Equal(t, i >= 2, quorumReached)
+
+		lastAttestedHeight, err := keeper.GetLastAttestedHeight(ctx)
+		require.NoError(t, err)
+		if i < 2 {
+			require.Zero(t, lastAttestedHeight)
+		} else {
+			require.Equal(t, height, lastAttestedHeight)
+		}
+
+		signatures, err := keeper.GetAllSignaturesForHeight(ctx, height)
+		require.NoError(t, err)
+		require.Len(t, signatures, i+1)
+		for _, signedAttester := range attesters[:i+1] {
+			require.Equal(t, signedAttester.vote, signatures[signedAttester.consensusAddress])
+		}
+	}
+}
+
 func newTestServer(t *testing.T, sk *MockStakingKeeper) (msgServer, Keeper, sdk.Context) {
 	t.Helper()
 	cdc := moduletestutil.MakeTestEncodingConfig().Codec