Refactor DAaaSh (#1)

* refactor: read CELESTIA_AUTH_TOKEN from .env

* refactor: single POST endpoint

* fix(main): error handling for .env read

---------

Co-authored-by: prampey <[email protected]>

Author: aashutoshrathi

.env.sample

@@ -0,0 +1 @@
+CELESTIA_AUTH_TOKEN=your_auth_token

.gitignore

@@ -0,0 +1 @@
+.env

README.md

@@ -2,7 +2,7 @@
 
 ![cover](./assets/cover.png)
 
-Unified interaction API for Data Availibility chains initially designed to work with Vulcan (Stackr's Verification Layer)
+Unified interaction API for Data Availability chains initially designed to work with Vulcan (Stackr's Verification Layer)
 
 This unified API for data availability services provides a scalable, secure, and efficient way for Vulcan to interact with different DA networks. It aims to standardize data access patterns, reduce complexity, and enhance the overall experience of using data availability services.
 
@@ -47,10 +47,10 @@ Each micro-rollup should be easily able to switch
 Avail and EigenDA runs via external RPC providers however Celestia requires a running light node to be able to post blobs through `go-daash`.
 
 You can find the instructions to run the light node [here](https://docs.celestia.org/developers/node-tutorial).
-Also export auth token as environment variable:
+You need an auth token to run your Celestia light node. Copy the `.env.example` file to `.env` and set the `CELESTIA_AUTH_TOKEN` environment variable to the auth token.
 
 ```bash
-export CELESTIA_AUTH_TOKEN=<your_auth_token>
+cp .env.example .env
 ```
 
 ## Installation/Running

avail.go

@@ -131,10 +131,11 @@ func (c *AvailDA) MaxBlobSize(ctx context.Context) (uint64, error) {
 // Currently, we submit to a trusted RPC Avail node. In the future, we will submit via an Avail light client.
 func (a *AvailDA) Submit(ctx context.Context, daBlobs []da.Blob, gasPrice float64) ([]da.ID, []da.Proof, error) {
 	// TODO: Add support for multiple blobs
-	log.Println("data", zap.Any("data", daBlobs[0]))
-	log.Println("⚡️ Preparing to post data to Avail:%d bytes", zap.Int("data_size", len(daBlobs[0])))
+	daBlob := daBlobs[0]
+	log.Println("data", zap.Any("data", daBlob))
+	log.Println("⚡️ Preparing to post data to Avail:%d bytes", zap.Int("data_size", len(daBlob)))
 	fmt.Println(*a)
-	newCall, err := types.NewCall(a.Meta, "DataAvailability.submit_data", types.NewBytes(daBlobs[0]))
+	newCall, err := types.NewCall(a.Meta, "DataAvailability.submit_data", types.NewBytes(daBlob))
 	if err != nil {
 		return nil, nil, fmt.Errorf("cannot create new call", err)
 	}

go.mod

@@ -191,6 +191,7 @@ require (
 	github.com/jbenet/goprocess v0.1.4 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/jmhodges/levigo v1.0.0 // indirect
+	github.com/joho/godotenv v1.5.1 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/compress v1.17.2 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.6 // indirect

go.sum

@@ -1292,6 +1292,8 @@ github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGw
 github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
 github.com/jmhodges/levigo v1.0.0 h1:q5EC36kV79HWeTBWsod3mG11EgStG3qArTKcvlksN1U=
 github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
 github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=

main.go

@@ -6,35 +6,49 @@ import (
 	"fmt"
 	"log"
 	"net/http"
-	"os"
 	"time"
 
 	rpc "github.com/celestiaorg/celestia-node/api/rpc/client"
 	"github.com/celestiaorg/celestia-node/share"
+	"github.com/joho/godotenv"
 	"github.com/rollkit/go-da"
 
 	"github.com/cenkalti/backoff/v4"
 	"github.com/gin-gonic/gin"
 )
 
+// Constants
+const (
+	CelestiaClientUrl = "http://localhost:26658"
+	EigenDaRpcUrl     = "disperser-goerli.eigenda.xyz:443"
+)
+
 func main() {
 	// initiates a gin Engine with the default logger and recovery middleware
 	router := gin.Default()
+	ctx := context.Background()
+
+	envFile, err := godotenv.Read(".env")
+	if err != nil {
+		fmt.Println("Error reading .env file")
+
+		return
+	}
+
 	// Initialise Avail DA client
 	avail, err := NewAvailDA()
 	if err != nil {
 		fmt.Printf("failed to create avail client: %v", err)
 	}
 
-	ctx := context.Background()
 	// Initialise Celestia DA client
 	// Read auth token from env
-	authToken := os.Getenv("CELESTIA_AUTH_TOKEN")
+	authToken := envFile["CELESTIA_AUTH_TOKEN"]
 	if authToken == "" {
 		fmt.Println("AUTH_TOKEN is not set")
 		return
 	}
-	client, err := rpc.NewClient(ctx, "http://localhost:26658", authToken)
+	client, err := rpc.NewClient(ctx, CelestiaClientUrl, authToken)
 	if err != nil {
 		fmt.Printf("failed to create rpc client: %v", err)
 	}
@@ -49,59 +63,28 @@ func main() {
 	celestia := NewCelestiaDA(client, namespace, -1, ctx)
 
 	// Initalise EigenDA client
-	eigen, err := NewEigendaDAClient("disperser-goerli.eigenda.xyz:443", time.Second*90, time.Second*5)
+	eigen, err := NewEigendaDAClient(EigenDaRpcUrl, time.Second*90, time.Second*5)
 	if err != nil {
 		fmt.Printf("failed to create eigen client: %v", err)
 	}
-	router.POST("/Avail", func(c *gin.Context) {
-		// Get the data in []byte from the request body
-		data, err := c.GetRawData()
-		if err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{
-				"message": fmt.Sprintf("get raw data: %v", err),
-			})
-			return
-		}
-		// Post the data to DA
-		ids, proofs, err := postToDA(c, data, avail)
-		if err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"message": fmt.Sprintf("post to DA: %v", err),
-			})
-			return
-		}
-		c.JSON(http.StatusOK, gin.H{
-			"message": "Daaaash",
-			"ids":     ids,
-			"proofs":  proofs,
-		})
-	})
 
-	router.POST("/Celestia", func(c *gin.Context) {
-		// Get the data in []byte from the request body
-		data, err := c.GetRawData()
-		if err != nil {
+	// Map of DA clients
+	daClients := map[string]da.DA{
+		"avail":    avail,
+		"celestia": celestia,
+		"eigen":    eigen,
+	}
+
+	router.POST("/:daName", func(c *gin.Context) {
+		daName := c.Param("daName")
+
+		if _, ok := daClients[daName]; !ok {
 			c.JSON(http.StatusBadRequest, gin.H{
-				"message": fmt.Sprintf("get raw data: %v", err),
+				"message": fmt.Sprintf("DA %s not found", daName),
 			})
 			return
 		}
-		// Post the data to DA
-		ids, proofs, err := postToDA(c, data, celestia)
-		if err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"message": fmt.Sprintf("post to DA: %v", err),
-			})
-			return
-		}
-		c.JSON(http.StatusOK, gin.H{
-			"message": "Daaaash",
-			"ids":     ids,
-			"proofs":  proofs,
-		})
-	})
 
-	router.POST("/Eigen", func(c *gin.Context) {
 		// Get the data in []byte from the request body
 		data, err := c.GetRawData()
 		if err != nil {
@@ -110,20 +93,22 @@ func main() {
 			})
 			return
 		}
+
 		// Post the data to DA
-		ids, proofs, err := postToDA(c, data, eigen)
+		ids, proofs, err := postToDA(c, data, daClients[daName])
 		if err != nil {
 			c.JSON(http.StatusInternalServerError, gin.H{
 				"message": fmt.Sprintf("post to DA: %v", err),
 			})
 			return
 		}
 		c.JSON(http.StatusOK, gin.H{
-			"message": "Daaaash",
+			"message": "DAaaaSh",
 			"ids":     ids,
 			"proofs":  proofs,
 		})
 	})
+
 	// Run implements a http.ListenAndServe() and takes in an optional Port number
 	// The default port is :8080
 	router.Run()