Fix/c4 qa

challenger/eventhandler/pending_events.go

@@ -75,12 +75,7 @@ func (ch *ChallengeEventHandler) GetAllPendingEvents() []challengertypes.Challen
 
 func (ch *ChallengeEventHandler) GetAllSortedPendingEvents() []challengertypes.ChallengeEvent {
 	pendingEvents := ch.GetAllPendingEvents()
-	sort.Slice(pendingEvents, func(i, j int) bool {
-		if pendingEvents[i].Type() == pendingEvents[j].Type() {
-			return pendingEvents[i].Id().Id < pendingEvents[j].Id().Id
-		}
-		return pendingEvents[i].Type() < pendingEvents[j].Type()
-	})
+	SortPendingEvents(pendingEvents)
 	return pendingEvents
 }
 
@@ -97,5 +92,16 @@ func (ch *ChallengeEventHandler) GetUnprocessedPendingEvents(processedEvents []c
 	for _, event := range copiedPendingEvents {
 		unprocessedPendingEvents = append(unprocessedPendingEvents, event)
 	}
+	SortPendingEvents(unprocessedPendingEvents)
 	return unprocessedPendingEvents
 }
+
+func SortPendingEvents(pendingEvents []challengertypes.ChallengeEvent) []challengertypes.ChallengeEvent {
+	sort.Slice(pendingEvents, func(i, j int) bool {
+		if pendingEvents[i].Type() == pendingEvents[j].Type() {
+			return pendingEvents[i].Id().Id < pendingEvents[j].Id().Id
+		}
+		return pendingEvents[i].Type() < pendingEvents[j].Type()
+	})
+	return pendingEvents
+}

merkle/db.go

@@ -51,6 +51,25 @@ func DeleteFutureWorkingTrees(db types.DB, fromVersion uint64) error {
 	return nil
 }
 
+func DeleteFutureNodes(db types.DB, treeIndex uint64) error {
+	var deleteKeys [][]byte
+	err := db.Iterate(dbtypes.AppendSplitter(merkletypes.NodePrefix), merkletypes.PrefixedNodeKeyWithTreeIndex(treeIndex), func(key, _ []byte) (bool, error) {
+		deleteKeys = append(deleteKeys, key)
+		return false, nil
+	})
+	if err != nil {
+		return err
+	}
+
+	for _, key := range deleteKeys {
+		err := db.Delete(key)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // GetWorkingTree returns the working tree with the given version.
 func GetWorkingTree(db types.BasicDB, version uint64) (merkletypes.TreeInfo, error) {
 	data, err := db.Get(merkletypes.PrefixedWorkingTreeKey(version))

merkle/db_test.go

@@ -231,3 +231,56 @@ func TestDeleteFutureWorkingTrees(t *testing.T) { //nolint
 		require.Error(t, err)
 	}
 }
+
+func TestDeleteFutureNodes(t *testing.T) {
+	db, err := db.NewMemDB()
+	require.NoError(t, err)
+
+	var nodes []merkletypes.Node
+	for treeIndex := uint64(1); treeIndex <= 10; treeIndex++ {
+		for treeHeight := uint8(0); treeHeight <= 5; treeHeight++ {
+			for nodeIndex := uint64(0); nodeIndex <= 10; nodeIndex++ {
+				node := merkletypes.Node{
+					TreeIndex:      treeIndex,
+					Height:         treeHeight,
+					LocalNodeIndex: nodeIndex,
+					Data:           []byte{byte(treeIndex), treeHeight, byte(nodeIndex)},
+				}
+				nodes = append(nodes, node)
+			}
+		}
+	}
+	err = SaveNodes(db, nodes...)
+	require.NoError(t, err)
+
+	err = DeleteFutureNodes(db, 5)
+	require.NoError(t, err)
+	for treeIndex := uint64(1); treeIndex <= 4; treeIndex++ {
+		for treeHeight := uint8(0); treeHeight <= 5; treeHeight++ {
+			for nodeIndex := uint64(0); nodeIndex <= 10; nodeIndex++ {
+				nodeBytes, err := GetNodeBytes(db, treeIndex, treeHeight, nodeIndex)
+				require.NoError(t, err)
+				require.Equal(t, []byte{byte(treeIndex), treeHeight, byte(nodeIndex)}, nodeBytes)
+			}
+		}
+	}
+	for treeIndex := uint64(5); treeIndex <= 10; treeIndex++ {
+		for treeHeight := uint8(0); treeHeight <= 5; treeHeight++ {
+			for nodeIndex := uint64(0); nodeIndex <= 10; nodeIndex++ {
+				_, err := GetNodeBytes(db, treeIndex, treeHeight, nodeIndex)
+				require.Error(t, err)
+			}
+		}
+	}
+
+	err = DeleteFutureNodes(db, 0)
+	require.NoError(t, err)
+	for treeIndex := uint64(0); treeIndex <= 10; treeIndex++ {
+		for treeHeight := uint8(0); treeHeight <= 5; treeHeight++ {
+			for nodeIndex := uint64(0); nodeIndex <= 10; nodeIndex++ {
+				_, err := GetNodeBytes(db, treeIndex, treeHeight, nodeIndex)
+				require.Error(t, err)
+			}
+		}
+	}
+}

merkle/merkle_test.go

@@ -209,7 +209,6 @@ func TestFillLeaves(t *testing.T) {
 			}
 
 			nodes, err := m.fillLeaves()
-			require.NoError(t, err)
 
 			if tc.expected {
 				require.NoError(t, err)
@@ -303,10 +302,10 @@ func TestInsertLeaf(t *testing.T) {
 	}, nodes[1])
 	require.Equal(t, merkletypes.Node{
 		TreeIndex:      1,
-		Height:         1,
-		LocalNodeIndex: 1,
-		Data:           hash34[:],
-	}, nodes[1])
+		Height:         2,
+		LocalNodeIndex: 0,
+		Data:           hash1234[:],
+	}, nodes[2])
 
 	// 5 nodes
 	nodes, err = m.InsertLeaf([]byte("node5"))

merkle/types/key.go

@@ -46,6 +46,16 @@ func PrefixedNodeKey(treeIndex uint64, height uint8, nodeIndex uint64) []byte {
 	})
 }
 
+func PrefixedNodeKeyWithTreeIndex(treeIndex uint64) []byte {
+	data := make([]byte, 8)
+	binary.BigEndian.PutUint64(data, treeIndex)
+
+	return dbtypes.GenerateKey([][]byte{
+		NodePrefix,
+		data,
+	})
+}
+
 func ParseFinalizedTreeKey(key []byte) (startLeafIndex uint64, err error) {
 	if len(key) != FinalizedTreeKeyLength {
 		return 0, fmt.Errorf("invalid finalized tree key bytes: expected %d, got %d", FinalizedTreeKeyLength, len(key))

merkle/types/key_test.go

@@ -36,6 +36,13 @@ func TestPrefixedNodeKey(t *testing.T) {
 	require.Equal(t, key, append(NodePrefix, []byte{byte('/'), 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10}...))
 }
 
+func TestPrefixedNodeKeyWithTreeIndex(t *testing.T) {
+	treeIndex := uint64(256)
+
+	key := PrefixedNodeKeyWithTreeIndex(treeIndex)
+	require.Equal(t, key, append(NodePrefix, []byte{byte('/'), 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0}...))
+}
+
 func TestParseFinalizedTreeKey(t *testing.T) {
 	startLeafIndex := uint64(256)
 	key := PrefixedFinalizedTreeKey(startLeafIndex)

provider/child/child.go

@@ -151,6 +151,11 @@ func (b *BaseChild) Initialize(
 		if err != nil {
 			return 0, err
 		}
+
+		err = merkle.DeleteFutureNodes(b.DB(), version+1)
+		if err != nil {
+			return 0, err
+		}
 	}
 
 	// if oracle config is set in the bridge config, check if the oracle account has the grant from one of the executors