feat(prospective-parachains): implements GetBackableCandidates

dot/parachain/prospective-parachains/prospective-parachains.go

@@ -6,12 +6,23 @@ import (
 
 	parachaintypes "github.com/ChainSafe/gossamer/dot/parachain/types"
 	"github.com/ChainSafe/gossamer/internal/log"
+	"github.com/ChainSafe/gossamer/lib/common"
 )
 
 var logger = log.NewFromGlobal(log.AddContext("pkg", "prospective_parachains"), log.SetLevel(log.Debug))
 
 type ProspectiveParachains struct {
 	SubsystemToOverseer chan<- any
+	View                *view
+}
+
+type view struct {
+	activeLeaves   map[common.Hash]bool
+	perRelayParent map[common.Hash]*relayParentData
+}
+
+type relayParentData struct {
+	fragmentChains map[parachaintypes.ParaID]*fragmentChain
 }
 
 // Name returns the name of the subsystem
@@ -57,7 +68,7 @@ func (pp *ProspectiveParachains) processMessage(msg any) {
 	case CandidateBacked:
 		panic("not implemented yet: see issue #4309")
 	case GetBackableCandidates:
-		panic("not implemented yet: see issue #4310")
+		pp.getBackableCandidates(msg)
 	case GetHypotheticalMembership:
 		panic("not implemented yet: see issue #4311")
 	case GetMinimumRelayParents:
@@ -80,3 +91,77 @@ func (*ProspectiveParachains) ProcessBlockFinalizedSignal(parachaintypes.BlockFi
 	// NOTE: this subsystem does not process block finalized signal
 	return nil
 }
+
+func (pp *ProspectiveParachains) getBackableCandidates(
+	msg GetBackableCandidates,
+) {
+	// Extract details from the message
+	relayParentHash := msg.RelayParentHash
+	paraId := msg.ParaId
+	requestedQty := msg.RequestedQty
+	ancestors := msg.Ancestors
+	responseChan := msg.Response
+
+	// Check if the relay parent is active
+	if _, exists := pp.View.activeLeaves[relayParentHash]; !exists {
+		logger.Debugf(
+			"Requested backable candidates for inactive relay-parent. "+
+				"RelayParentHash: %v, ParaId: %v",
+			relayParentHash, paraId,
+		)
+		responseChan <- []parachaintypes.CandidateHashAndRelayParent{}
+		return
+	}
+
+	// Retrieve data for the relay parent
+	data, ok := pp.View.perRelayParent[relayParentHash]
+	if !ok {
+		logger.Debugf(
+			"Requested backable candidates for nonexistent relay-parent. "+
+				"RelayParentHash: %v, ParaId: %v",
+			relayParentHash, paraId,
+		)
+		responseChan <- []parachaintypes.CandidateHashAndRelayParent{}
+		return
+	}
+
+	// Retrieve the fragment chain for the ParaID
+	chain, ok := data.fragmentChains[paraId]
+	if !ok {
+		logger.Debugf(
+			"Requested backable candidates for inactive ParaID. "+
+				"RelayParentHash: %v, ParaId: %v",
+			relayParentHash, paraId,
+		)
+		responseChan <- []parachaintypes.CandidateHashAndRelayParent{}
+		return
+	}
+
+	// Retrieve backable candidates from the fragment chain
+	backableCandidates := chain.findBackableChain(ancestors, requestedQty)
+	if len(backableCandidates) == 0 {
+		logger.Debugf(
+			"No backable candidates found. RelayParentHash: %v, ParaId: %v, Ancestors: %v",
+			relayParentHash, paraId, ancestors,
+		)
+		responseChan <- []parachaintypes.CandidateHashAndRelayParent{}
+		return
+	}
+
+	logger.Debugf(
+		"Found backable candidates: %v. RelayParentHash: %v, ParaId: %v, Ancestors: %v",
+		backableCandidates, relayParentHash, paraId, ancestors,
+	)
+
+	// Convert backable candidates to the expected response format
+	candidateHashes := make([]parachaintypes.CandidateHashAndRelayParent, len(backableCandidates))
+	for i, candidate := range backableCandidates {
+		candidateHashes[i] = parachaintypes.CandidateHashAndRelayParent{
+			CandidateHash:        candidate.candidateHash,
+			CandidateRelayParent: candidate.realyParentHash,
+		}
+	}
+
+	// Send the result through the response channel
+	responseChan <- candidateHashes
+}