Added Avail DA to Rollkit

da/avail/avail.go

@@ -0,0 +1,187 @@
+package avail
+
+import (
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	ds "github.com/ipfs/go-datastore"
+	openrpc "github.com/rollkit/celestia-openrpc"
+	openrpcns "github.com/rollkit/celestia-openrpc/types/namespace"
+	"github.com/rollkit/rollkit/da"
+	"github.com/rollkit/rollkit/da/avail/datasubmit"
+	"github.com/rollkit/rollkit/log"
+	"github.com/rollkit/rollkit/types"
+)
+
+type Config struct {
+	BaseURL    string  `json:"base_url"`
+	Seed       string  `json:"seed"`
+	ApiURL     string  `json:"api_url"`
+	Size       int     `json:"size"`
+	AppID      int     `json:"app_id"`
+	confidence float64 `json:"confidence"`
+}
+
+type DataAvailabilityLayerClient struct {
+	rpc       *openrpc.Client
+	namespace openrpcns.Namespace
+	config    Config
+	logger    log.Logger
+}
+
+type Confidence struct {
+	Block                uint32  `json:"block"`
+	Confidence           float64 `json:"confidence"`
+	SerialisedConfidence *string `json:"serialised_confidence,omitempty"`
+}
+
+type AppData struct {
+	Block      uint32 `json:"block"`
+	Extrinsics string `json:"extrinsics"`
+}
+
+var _ da.DataAvailabilityLayerClient = &DataAvailabilityLayerClient{}
+var _ da.BlockRetriever = &DataAvailabilityLayerClient{}
+
+// Init initializes DataAvailabilityLayerClient instance.
+func (c *DataAvailabilityLayerClient) Init(namespaceID types.NamespaceID, config []byte, kvStore ds.Datastore, logger log.Logger) error {
+	c.logger = logger
+
+	if len(config) > 0 {
+		return json.Unmarshal(config, &c.config)
+	}
+
+	return nil
+}
+
+// Start prepares DataAvailabilityLayerClient to work.
+func (c *DataAvailabilityLayerClient) Start() error {
+
+	c.logger.Info("starting avail Data Availability Layer Client", "baseURL", c.config.ApiURL)
+
+	return nil
+}
+
+// Stop stops DataAvailabilityLayerClient.
+func (c *DataAvailabilityLayerClient) Stop() error {
+
+	c.logger.Info("stopping Avail Data Availability Layer Client")
+
+	return nil
+}
+
+// SubmitBlock submits a block to DA layer.
+func (c *DataAvailabilityLayerClient) SubmitBlock(ctx context.Context, block *types.Block) da.ResultSubmitBlock {
+
+	data, err := block.MarshalBinary()
+	if err != nil {
+		return da.ResultSubmitBlock{
+			BaseResult: da.BaseResult{
+				Code:    da.StatusError,
+				Message: err.Error(),
+			},
+		}
+	}
+
+	txHash, err := datasubmit.SubmitData(c.config.Size, c.config.ApiURL, c.config.Seed, c.config.AppID, data)
+
+	if err != nil {
+		return da.ResultSubmitBlock{
+			BaseResult: da.BaseResult{
+				Code:    da.StatusError,
+				Message: err.Error(),
+			},
+		}
+	}
+
+	return da.ResultSubmitBlock{
+		BaseResult: da.BaseResult{
+			Code:     da.StatusSuccess,
+			Message:  "tx hash: " + hex.EncodeToString(txHash[:]),
+			DAHeight: 1,
+		},
+	}
+}
+
+// CheckBlockAvailability queries DA layer to check data availability of block.
+func (c *DataAvailabilityLayerClient) CheckBlockAvailability(ctx context.Context, dataLayerHeight uint64) da.ResultCheckBlock {
+
+	blockNumber := dataLayerHeight
+	confidenceURL := fmt.Sprintf(c.config.BaseURL+"/confidence/%d", blockNumber)
+
+	response, err := http.Get(confidenceURL)
+
+	if err != nil {
+		return da.ResultCheckBlock{
+			BaseResult: da.BaseResult{
+				Code:    da.StatusError,
+				Message: err.Error(),
+			},
+		}
+	}
+
+	responseData, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		return da.ResultCheckBlock{
+			BaseResult: da.BaseResult{
+				Code:    da.StatusError,
+				Message: err.Error(),
+			},
+		}
+	}
+
+	var confidenceObject Confidence
+	json.Unmarshal(responseData, &confidenceObject)
+
+	return da.ResultCheckBlock{
+		BaseResult: da.BaseResult{
+			Code:     da.StatusSuccess,
+			DAHeight: uint64(confidenceObject.Block),
+		},
+		DataAvailable: confidenceObject.Confidence > float64(c.config.confidence),
+	}
+}
+
+//RetrieveBlocks gets the block from DA layer.
+
+func (c *DataAvailabilityLayerClient) RetrieveBlocks(ctx context.Context, dataLayerHeight uint64) da.ResultRetrieveBlocks {
+
+	blocks := make([]*types.Block, 1)
+	blocks[0] = new(types.Block)
+
+	blockNumber := dataLayerHeight
+	appDataURL := fmt.Sprintf(c.config.BaseURL+"/appdata/%d?decode=true", blockNumber)
+	response, err := http.Get(appDataURL)
+	if err != nil {
+		return da.ResultRetrieveBlocks{
+			BaseResult: da.BaseResult{
+				Code:    da.StatusError,
+				Message: err.Error(),
+			},
+		}
+	}
+	responseData, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		return da.ResultRetrieveBlocks{
+			BaseResult: da.BaseResult{
+				Code:    da.StatusError,
+				Message: err.Error(),
+			},
+		}
+	}
+	var appDataObject AppData
+	json.Unmarshal(responseData, &appDataObject)
+
+	return da.ResultRetrieveBlocks{
+		BaseResult: da.BaseResult{
+			Code:     da.StatusSuccess,
+			DAHeight: uint64(appDataObject.Block),
+			Message:  "block data: " + appDataObject.Extrinsics,
+		},
+		Blocks: blocks,
+	}
+}

da/avail/datasubmit/submitdata.go

@@ -0,0 +1,88 @@
+package datasubmit
+
+import (
+	gsrpc "github.com/centrifuge/go-substrate-rpc-client/v4"
+	"github.com/centrifuge/go-substrate-rpc-client/v4/signature"
+	"github.com/centrifuge/go-substrate-rpc-client/v4/types"
+)
+
+// submit data submits the extrinsic through substrate api
+func SubmitData(size int, apiURL string, seed string, AppID int, data []byte) (types.Hash, error) {
+	api, err := gsrpc.NewSubstrateAPI(apiURL)
+	if err != nil {
+		return types.Hash{}, err
+	}
+
+	meta, err := api.RPC.State.GetMetadataLatest()
+	if err != nil {
+		return types.Hash{}, err
+	}
+
+	var appID int
+
+	// if app id is greater than 0 then it must be created before submitting data
+	if AppID != 0 {
+		appID = AppID
+	}
+
+	c, err := types.NewCall(meta, "DataAvailability.submit_data", data)
+	if err != nil {
+		return types.Hash{}, err
+	}
+
+	//Create the extrinsic
+	ext := types.NewExtrinsic(c)
+
+	genesisHash, err := api.RPC.Chain.GetBlockHash(0)
+	if err != nil {
+		return types.Hash{}, err
+	}
+
+	rv, err := api.RPC.State.GetRuntimeVersionLatest()
+	if err != nil {
+		return types.Hash{}, err
+	}
+
+	keyringPair, err := signature.KeyringPairFromSecret(seed, 42)
+	if err != nil {
+		return types.Hash{}, err
+	}
+
+	key, err := types.CreateStorageKey(meta, "System", "Account", keyringPair.PublicKey)
+	if err != nil {
+		return types.Hash{}, err
+	}
+
+	var accountInfo types.AccountInfo
+	ok, err := api.RPC.State.GetStorageLatest(key, &accountInfo)
+	if err != nil || !ok {
+		return types.Hash{}, err
+	}
+
+	nonce := uint32(accountInfo.Nonce)
+	o := types.SignatureOptions{
+		BlockHash:          genesisHash,
+		Era:                types.ExtrinsicEra{IsMortalEra: false},
+		GenesisHash:        genesisHash,
+		Nonce:              types.NewUCompactFromUInt(uint64(nonce)),
+		SpecVersion:        rv.SpecVersion,
+		Tip:                types.NewUCompactFromUInt(0),
+		AppID:              types.NewUCompactFromUInt(uint64(appID)),
+		TransactionVersion: rv.TransactionVersion,
+	}
+
+	// Sign the transaction using Alice's default account
+	err = ext.Sign(keyringPair, o)
+	if err != nil {
+		return types.Hash{}, err
+	}
+
+	// Send the extrinsic
+	hash, err := api.RPC.Author.SubmitExtrinsic(ext)
+	if err != nil {
+		return types.Hash{}, err
+	}
+
+	return hash, nil
+
+}

da/registry/registry.go

@@ -4,7 +4,9 @@ import (
 	"fmt"
 
 	"github.com/rollkit/rollkit/da"
+	"github.com/rollkit/rollkit/da/avail"
 	"github.com/rollkit/rollkit/da/celestia"
+
 	"github.com/rollkit/rollkit/da/grpc"
 	"github.com/rollkit/rollkit/da/mock"
 )
@@ -23,6 +25,7 @@ var clients = map[string]func() da.DataAvailabilityLayerClient{
 	"mock":     func() da.DataAvailabilityLayerClient { return &mock.DataAvailabilityLayerClient{} },
 	"grpc":     func() da.DataAvailabilityLayerClient { return &grpc.DataAvailabilityLayerClient{} },
 	"celestia": func() da.DataAvailabilityLayerClient { return &celestia.DataAvailabilityLayerClient{} },
+	"avail":    func() da.DataAvailabilityLayerClient { return &avail.DataAvailabilityLayerClient{} },
 }
 
 // GetClient returns client identified by name.