feat(parachain): availability store skeleton (#3521)

dot/parachain/availability-store/availabilitystore.go

@@ -0,0 +1,84 @@
+// Copyright 2023 ChainSafe Systems (ON)
+// SPDX-License-Identifier: LGPL-3.0-only
+
+package availability_store
+
+import (
+	"context"
+
+	"github.com/ChainSafe/gossamer/internal/log"
+)
+
+var logger = log.NewFromGlobal(log.AddContext("pkg", "parachain-availability-store"))
+
+type AvailabilityStoreSubsystem struct {
+	SubSystemToOverseer chan<- any
+	OverseerToSubSystem <-chan any
+	//db            interface{} // Define the actual database type
+	//config        Config      // Define the actual config type
+	//pruningConfig PruningConfig
+	//clock         Clock
+	//metrics       Metrics
+}
+
+func (av *AvailabilityStoreSubsystem) Run(ctx context.Context, OverseerToSubsystem chan any,
+	SubsystemToOverseer chan any) error {
+	av.processMessages()
+	return nil
+}
+
+func (av *AvailabilityStoreSubsystem) processMessages() {
+	for msg := range av.OverseerToSubSystem {
+		logger.Debugf("received message %v", msg)
+		switch msg := msg.(type) {
+		case QueryAvailableData:
+			av.handleQueryAvailableData(msg)
+		case QueryDataAvailability:
+			av.handleQueryDataAvailability(msg)
+		case QueryChunk:
+			av.handleQueryChunk(msg)
+		case QueryChunkSize:
+			av.handleQueryChunkSize(msg)
+		case QueryAllChunks:
+			av.handleQueryAllChunks(msg)
+		case QueryChunkAvailability:
+			av.handleQueryChunkAvailability(msg)
+		case StoreChunk:
+			av.handleStoreChunk(msg)
+		case StoreAvailableData:
+			av.handleStoreAvailableData(msg)
+		}
+	}
+}
+
+func (av *AvailabilityStoreSubsystem) handleQueryAvailableData(msg QueryAvailableData) {
+	// TODO: handle query available data
+}
+
+func (av *AvailabilityStoreSubsystem) handleQueryDataAvailability(msg QueryDataAvailability) {
+	// TODO: handle query data availability
+}
+
+func (av *AvailabilityStoreSubsystem) handleQueryChunk(msg QueryChunk) {
+	// TODO: handle query chunk
+}
+
+func (av *AvailabilityStoreSubsystem) handleQueryChunkSize(msg QueryChunkSize) {
+	// TODO: handle query chunk size
+}
+
+func (av *AvailabilityStoreSubsystem) handleQueryAllChunks(msg QueryAllChunks) {
+	// TODO: handle query all chunks
+}
+
+func (av *AvailabilityStoreSubsystem) handleQueryChunkAvailability(msg QueryChunkAvailability) {
+	// TODO: handle query chunk availability
+}
+
+func (av *AvailabilityStoreSubsystem) handleStoreChunk(msg StoreChunk) {
+	// TODO: handle store chunk
+}
+
+func (av *AvailabilityStoreSubsystem) handleStoreAvailableData(msg StoreAvailableData) {
+	// TODO: handle store available data
+}

dot/parachain/availability-store/messages.go

@@ -0,0 +1,57 @@
+// Copyright 2023 ChainSafe Systems (ON)
+// SPDX-License-Identifier: LGPL-3.0-only
+
+package availability_store
+
+import (
+	"github.com/ChainSafe/gossamer/lib/common"
+)
+
+// QueryAvailableData query a AvailableData from the AV store
+type QueryAvailableData struct {
+	CandidateHash common.Hash
+	AvailableData AvailableData
+}
+
+type QueryDataAvailability struct {
+	CandidateHash common.Hash
+	Sender        chan AvailableData
+}
+
+type QueryChunk struct {
+	CandidateHash  common.Hash
+	ValidatorIndex uint32
+	Sender         chan []byte
+}
+
+type QueryChunkSize struct {
+	CandidateHash common.Hash
+	Sender        chan uint32
+}
+
+type QueryAllChunks struct {
+	CandidateHash common.Hash
+	Sender        chan []byte
+}
+
+type QueryChunkAvailability struct {
+	CandidateHash  common.Hash
+	ValidatorIndex uint32
+	Sender         chan bool
+}
+
+type StoreChunk struct {
+	CandidateHash common.Hash
+	Chunk         []byte
+	Sender        chan any
+}
+
+type StoreAvailableData struct {
+	CandidateHash       common.Hash
+	NValidators         uint32
+	AvailableData       AvailableData
+	ExpectedErasureRoot common.Hash
+	Sender              chan any
+}
+
+type AvailableData struct{} // Define your AvailableData type

dot/parachain/availability-store/register.go

@@ -0,0 +1,12 @@
+// Copyright 2023 ChainSafe Systems (ON)
+// SPDX-License-Identifier: LGPL-3.0-only
+
+package availability_store
+
+func Register(overseerChan chan<- any) (*AvailabilityStoreSubsystem, error) {
+	availabilityStore := AvailabilityStoreSubsystem{
+		SubSystemToOverseer: overseerChan,
+	}
+
+	return &availabilityStore, nil
+}

dot/parachain/service.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/ChainSafe/gossamer/dot/network"
+	availability_store "github.com/ChainSafe/gossamer/dot/parachain/availability-store"
 	"github.com/ChainSafe/gossamer/dot/parachain/backing"
 	collatorprotocol "github.com/ChainSafe/gossamer/dot/parachain/collator-protocol"
 	"github.com/ChainSafe/gossamer/dot/parachain/overseer"
@@ -34,11 +35,17 @@ var logger = log.NewFromGlobal(log.AddContext("pkg", "parachain"))
 func NewService(net Network, forkID string, genesisHash common.Hash) (*Service, error) {
 	overseer := overseer.NewOverseer()
 
+	availabilityStore, err := availability_store.Register(overseer.SubsystemsToOverseer)
+	if err != nil {
+		return nil, fmt.Errorf("registering availability store: %w", err)
+	}
+	availabilityStore.OverseerToSubSystem = overseer.RegisterSubsystem(availabilityStore)
+
 	validationProtocolID := GeneratePeersetProtocolName(
 		ValidationProtocolName, forkID, genesisHash, ValidationProtocolVersion)
 
 	// register validation protocol
-	err := net.RegisterNotificationsProtocol(
+	err = net.RegisterNotificationsProtocol(
 		protocol.ID(validationProtocolID),
 		network.ValidationMsgType,
 		getValidationHandshake,