add blocks x val endpoint

Author: Marketen

api/api.go

@@ -61,6 +61,7 @@ const (
 	pathMemoryWrongFeeBlocks         = "/memory/wrongfeeblocks"
 	pathMemoryDonations              = "/memory/donations"
 	pathMemoryPoolStatistics         = "/memory/statistics"
+	pathMemoryValidatorBlocks        = "/memory/validatorblocks"
 
 	// Onchain endpoints: what is submitted to the contract
 	pathOnchainValidators             = "/onchain/validators"                     // TODO
@@ -178,6 +179,13 @@ type httpOkProofs struct {
 	PendingRewardsWei          string   `json:"pending_rewards_wei"`
 }
 
+type httpOkValBlocks struct {
+	ValidatorIndex uint64         `json:"validator_index"`
+	ProposedBlocks []oracle.Block `json:"proposed_blocks"`
+	MissedBlocks   []oracle.Block `json:"missed_blocks"`
+	WrongFeeBlocks []oracle.Block `json:"wrong_fee_blocks"`
+}
+
 type ApiService struct {
 	srv           *http.Server
 	cfg           *config.Config
@@ -243,6 +251,7 @@ func (m *ApiService) getRouter() http.Handler {
 	r.HandleFunc(pathMemoryMissedBlocks, m.handleMemoryMissedBlocks).Methods(http.MethodGet)
 	r.HandleFunc(pathMemoryWrongFeeBlocks, m.handleMemoryWrongFeeBlocks).Methods(http.MethodGet)
 	r.HandleFunc(pathMemoryDonations, m.handleMemoryDonations).Methods(http.MethodGet)
+	r.HandleFunc(pathMemoryValidatorBlocks, m.handleMemoryValidatorBlocks).Methods(http.MethodGet)
 
 	// Onchain endpoints
 	r.HandleFunc(pathOnchainMerkleProof, m.handleOnchainMerkleProof).Methods(http.MethodGet)
@@ -305,6 +314,70 @@ func (m *ApiService) handleRoot(w http.ResponseWriter, req *http.Request) {
 	m.respondOK(w, "see api doc for available endpoints")
 }
 
+func (m *ApiService) handleMemoryValidatorBlocks(w http.ResponseWriter, r *http.Request) {
+	// Access the existing OracleState instance from the ApiService
+	oracleState := m.oracle.State()
+
+	// Retrieve the ProposedBlocks, MissedBlocks, and WrongFeeBlocks from the OracleState
+	proposedBlocks := oracleState.ProposedBlocks
+	missedBlocks := oracleState.MissedBlocks
+	wrongFeeBlocks := oracleState.WrongFeeBlocks
+
+	// Create a map to hold the ordered blocks, with the ValidatorIndex as the key
+	orderedBlocks := make(map[uint64]*httpOkValBlocks)
+
+	// Iterate over the ProposedBlocks and add them to the orderedBlocks map
+	for _, block := range proposedBlocks {
+		validatorIndex := block.ValidatorIndex
+		if valBlocks, ok := orderedBlocks[validatorIndex]; ok {
+			valBlocks.ProposedBlocks = append(valBlocks.ProposedBlocks, block)
+		} else {
+			orderedBlocks[validatorIndex] = &httpOkValBlocks{
+				ValidatorIndex: validatorIndex,
+				ProposedBlocks: []oracle.Block{block},
+			}
+		}
+	}
+
+	// Iterate over the MissedBlocks and add them to the orderedBlocks map
+	for _, block := range missedBlocks {
+		validatorIndex := block.ValidatorIndex
+		if valBlocks, ok := orderedBlocks[validatorIndex]; ok {
+			valBlocks.MissedBlocks = append(valBlocks.MissedBlocks, block)
+		} else {
+			orderedBlocks[validatorIndex] = &httpOkValBlocks{
+				ValidatorIndex: validatorIndex,
+				MissedBlocks:   []oracle.Block{block},
+			}
+		}
+	}
+
+	// Iterate over the WrongFeeBlocks and add them to the orderedBlocks map
+	for _, block := range wrongFeeBlocks {
+		validatorIndex := block.ValidatorIndex
+		if valBlocks, ok := orderedBlocks[validatorIndex]; ok {
+			valBlocks.WrongFeeBlocks = append(valBlocks.WrongFeeBlocks, block)
+		} else {
+			orderedBlocks[validatorIndex] = &httpOkValBlocks{
+				ValidatorIndex: validatorIndex,
+				WrongFeeBlocks: []oracle.Block{block},
+			}
+		}
+	}
+
+	// Create a slice to hold the final JSON output
+	finalOutput := make([]*httpOkValBlocks, 0, len(orderedBlocks))
+
+	// Iterate over the orderedBlocks map using the validator indices in ascending order
+	for index := uint64(0); index < uint64(len(orderedBlocks)); index++ {
+		if valBlocks, ok := orderedBlocks[index]; ok {
+			finalOutput = append(finalOutput, valBlocks)
+		}
+	}
+
+	m.respondOK(w, finalOutput)
+}
+
 func (m *ApiService) handleMemoryStatistics(w http.ResponseWriter, req *http.Request) {
 	totalSubscribed := uint64(0)
 	totalActive := uint64(0)

api/api_test.go

@@ -2,7 +2,11 @@ package api
 
 import (
 	"encoding/hex"
+	"fmt"
 	"math/big"
+	"math/rand"
+	"net/http"
+	"net/http/httptest"
 	"testing"
 
 	v1 "github.com/attestantio/go-eth2-client/api/v1"
@@ -314,3 +318,120 @@ func Test_ApiEndpoint(t *testing.T) {
 		require.Equal(t, 1, 1)
 	*/
 }
+
+func TestHandleGetOrderedBlocksByValidatorKey(t *testing.T) {
+
+	// Create a mock config
+	mockConfig := &config.Config{
+		ConsensusEndpoint:     "http://consensus_endpoint",
+		ExecutionEndpoint:     "http://execution_endpoint",
+		Network:               "testnet",
+		PoolAddress:           "pool_address",
+		DeployedSlot:          1000,
+		DeployedBlock:         10000,
+		CheckPointSizeInSlots: 10,
+		PoolFeesPercent:       150,
+		PoolFeesAddress:       "fees_address",
+		DryRun:                true,
+		NumRetries:            3,
+		CollateralInWei:       big.NewInt(1000),
+		UpdaterKeyPass:        "key_pass",
+		UpdaterKeyPath:        "key_path",
+	}
+
+	// Create a mock Oracle using the NewOracle function
+	mockOracle := oracle.NewOracle(mockConfig)
+	oracle.NewOracleState(mockConfig)
+	numBlocks := 100
+	for i := 0; i < numBlocks; i++ {
+		// Generate a random ValidatorIndex between 0 and 99
+		validatorIndex := rand.Intn(100)
+
+		// Create mock blocks and add them to the OracleState's ProposedBlocks
+		mockBlock := blockOkProposal(
+			rand.Uint64()%101,
+			uint64(validatorIndex),
+			"PUBKEY",
+			big.NewInt(int64(rand.Intn(1000)+10000)),
+			"0xaaa0000000000000000000000000000000000000",
+		)
+		mockOracle.State().HandleCorrectBlockProposal(mockBlock)
+
+		// Create mock missed blocks and add them to the OracleState's MissedBlocks
+		mockMissedBlock := MissedBlock(
+			rand.Uint64()%101,
+			uint64(validatorIndex),
+			"PUBKEY",
+		)
+		mockOracle.State().HandleMissedBlock(mockMissedBlock)
+
+		// Create mock wrong fee blocks and add them to the OracleState's WrongFeeBlocks
+		mockWrongFeeBlock := WrongFeeBlock(
+			rand.Uint64()%101,
+			uint64(validatorIndex),
+			"PUBKEY",
+		)
+		mockOracle.State().HandleBanValidator(mockWrongFeeBlock)
+	}
+	// Create an instance of your ApiService with the mock Oracle
+	apiService := &ApiService{
+		oracle: mockOracle,
+		// other fields initialization...
+	}
+	req, err := http.NewRequest("GET", "/memory/validatorblocks", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rr := httptest.NewRecorder()
+	// Call the handler function directly, passing in the ResponseRecorder and the Request
+	handler := http.HandlerFunc(apiService.handleMemoryValidatorBlocks)
+	handler.ServeHTTP(rr, req)
+	fmt.Println(rr.Body)
+
+	// handler2 := http.HandlerFunc(apiService.handleMemoryAllBlocks)
+	// handler2.ServeHTTP(rr, req)
+	// fmt.Print(rr.Body.String())
+
+	// Perform assertions on the response
+	if status := rr.Code; status != http.StatusOK {
+		t.Errorf("handler returned wrong status code: got %v, want %v", status, http.StatusOK)
+	}
+	// Perform additional assertions on the response body or headers if needed
+	// For example, you can check the response body for expected JSON data
+
+	// Example assertion for JSON response
+	// expectedResponse := `{"message":"success"}`
+	// if rr.Body.String() != expectedResponse {
+	// 	t.Errorf("handler returned unexpected body: got %v, want %v", rr.Body.String(), expectedResponse)
+	// }
+}
+
+func MissedBlock(slot uint64, valIndex uint64, pubKey string) oracle.Block {
+	return oracle.Block{
+		Slot:           slot,
+		ValidatorIndex: valIndex,
+		ValidatorKey:   pubKey,
+		BlockType:      oracle.MissedProposal,
+	}
+}
+
+func WrongFeeBlock(slot uint64, valIndex uint64, pubKey string) oracle.Block {
+	return oracle.Block{
+		Slot:           slot,
+		ValidatorIndex: valIndex,
+		ValidatorKey:   pubKey,
+		BlockType:      oracle.WrongFeeRecipient,
+	}
+}
+
+func blockOkProposal(slot uint64, valIndex uint64, pubKey string, reward *big.Int, withAddress string) oracle.Block {
+	return oracle.Block{
+		Slot:              slot,
+		ValidatorIndex:    valIndex,
+		ValidatorKey:      pubKey,
+		BlockType:         oracle.OkPoolProposal,
+		Reward:            reward,
+		RewardType:        oracle.MevBlock,
+		WithdrawalAddress: withAddress,
+	}
+}