add sorting

Author: Marketen

api/api.go

@@ -180,6 +180,7 @@ type httpOkProofs struct {
 }
 
 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"`
@@ -322,46 +323,69 @@ func (m *ApiService) handleMemoryValidatorBlocks(w http.ResponseWriter, r *http.
 	missedBlocks := oracleState.MissedBlocks
 	wrongFeeBlocks := oracleState.WrongFeeBlocks
 
-	// Sort the blocks by ValidatorKey
-	sort.Slice(proposedBlocks, func(i, j int) bool {
-		return proposedBlocks[i].ValidatorKey < proposedBlocks[j].ValidatorKey
-	})
-	sort.Slice(missedBlocks, func(i, j int) bool {
-		return missedBlocks[i].ValidatorKey < missedBlocks[j].ValidatorKey
-	})
-	sort.Slice(wrongFeeBlocks, func(i, j int) bool {
-		return wrongFeeBlocks[i].ValidatorKey < wrongFeeBlocks[j].ValidatorKey
-	})
-
-	// Create a map to hold the ordered blocks, with the ValidatorKey as the key
-	orderedBlocks := make(map[string]*httpOkValBlocks)
+	// Create a map to hold the ordered blocks, with the ValidatorIndex as the key
+	orderedBlocks := make(map[uint64]*httpOkValBlocks)
 
 	// Add the ordered blocks to the map
 	for _, block := range proposedBlocks {
-		validatorKey := block.ValidatorKey
-		if _, ok := orderedBlocks[validatorKey]; !ok {
-			orderedBlocks[validatorKey] = &httpOkValBlocks{}
+		validatorIndex := block.ValidatorIndex
+		if _, ok := orderedBlocks[validatorIndex]; !ok {
+			orderedBlocks[validatorIndex] = &httpOkValBlocks{ValidatorIndex: validatorIndex}
 		}
-		orderedBlocks[validatorKey].ProposedBlocks = append(orderedBlocks[validatorKey].ProposedBlocks, block)
+		orderedBlocks[validatorIndex].ProposedBlocks = append(orderedBlocks[validatorIndex].ProposedBlocks, block)
 	}
 
 	for _, block := range missedBlocks {
-		validatorKey := block.ValidatorKey
-		if _, ok := orderedBlocks[validatorKey]; !ok {
-			orderedBlocks[validatorKey] = &httpOkValBlocks{}
+		validatorIndex := block.ValidatorIndex
+		if _, ok := orderedBlocks[validatorIndex]; !ok {
+			orderedBlocks[validatorIndex] = &httpOkValBlocks{ValidatorIndex: validatorIndex}
 		}
-		orderedBlocks[validatorKey].MissedBlocks = append(orderedBlocks[validatorKey].MissedBlocks, block)
+		orderedBlocks[validatorIndex].MissedBlocks = append(orderedBlocks[validatorIndex].MissedBlocks, block)
 	}
 
 	for _, block := range wrongFeeBlocks {
-		validatorKey := block.ValidatorKey
-		if _, ok := orderedBlocks[validatorKey]; !ok {
-			orderedBlocks[validatorKey] = &httpOkValBlocks{}
+		validatorIndex := block.ValidatorIndex
+		if _, ok := orderedBlocks[validatorIndex]; !ok {
+			orderedBlocks[validatorIndex] = &httpOkValBlocks{ValidatorIndex: validatorIndex}
 		}
-		orderedBlocks[validatorKey].WrongFeeBlocks = append(orderedBlocks[validatorKey].WrongFeeBlocks, block)
+		orderedBlocks[validatorIndex].WrongFeeBlocks = append(orderedBlocks[validatorIndex].WrongFeeBlocks, block)
+	}
+
+	// Sort the blocks within each validator index by slot number
+	for _, valBlocks := range orderedBlocks {
+		sort.Slice(valBlocks.ProposedBlocks, func(i, j int) bool {
+			return valBlocks.ProposedBlocks[i].Slot < valBlocks.ProposedBlocks[j].Slot
+		})
+		sort.Slice(valBlocks.MissedBlocks, func(i, j int) bool {
+			return valBlocks.MissedBlocks[i].Slot < valBlocks.MissedBlocks[j].Slot
+		})
+		sort.Slice(valBlocks.WrongFeeBlocks, func(i, j int) bool {
+			return valBlocks.WrongFeeBlocks[i].Slot < valBlocks.WrongFeeBlocks[j].Slot
+		})
+	}
+
+	// Create a slice to hold the ordered validator indices
+	orderedIndices := make([]uint64, 0, len(orderedBlocks))
+
+	// Extract the validator indices from the map into the slice
+	for index := range orderedBlocks {
+		orderedIndices = append(orderedIndices, index)
+	}
+
+	// Sort the validator indices in ascending order
+	sort.Slice(orderedIndices, func(i, j int) bool {
+		return orderedIndices[i] < orderedIndices[j]
+	})
+
+	// Create a slice to hold the final JSON output
+	finalOutput := make([]*httpOkValBlocks, 0, len(orderedBlocks))
+
+	// Add the blocks to the final JSON output in the ordered sequence
+	for _, index := range orderedIndices {
+		finalOutput = append(finalOutput, orderedBlocks[index])
 	}
 
-	m.respondOK(w, orderedBlocks)
+	m.respondOK(w, finalOutput)
 }
 
 func (m *ApiService) handleMemoryStatistics(w http.ResponseWriter, req *http.Request) {

api/api_test.go

@@ -342,18 +342,36 @@ func TestHandleGetOrderedBlocksByValidatorKey(t *testing.T) {
 	// 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(
-			0,
-			420,
-			fmt.Sprintf("%d", i+1),
+			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{
@@ -388,6 +406,24 @@ func TestHandleGetOrderedBlocksByValidatorKey(t *testing.T) {
 	// }
 }
 
+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,