feat(faucet): gno address and email/token mapping

Closes #148

- Register in redis the gno address as key and email/token as values
- Add a pseudo endpoint to retrieve email and token from gno adresses

Author: tbruyelle

faucet/main.go

@@ -21,14 +21,15 @@ import (
 	tm2Client "github.com/gnolang/faucet/client/http"
 	"github.com/gnolang/faucet/config"
 	"github.com/gnolang/faucet/estimate/static"
-	"github.com/gnolang/gno/tm2/pkg/crypto"
-	"github.com/gnolang/gno/tm2/pkg/std"
 	"github.com/peterbourgon/ff/v3"
 	"github.com/peterbourgon/ff/v3/fftoml"
 	"github.com/redis/go-redis/v9"
 	"go.uber.org/zap"
 	"golang.org/x/sync/errgroup"
 
+	"github.com/gnolang/gno/tm2/pkg/crypto"
+	"github.com/gnolang/gno/tm2/pkg/std"
+
 	"github.com/peterbourgon/ff/v3/ffcli"
 )
 
@@ -175,7 +176,7 @@ func registerFlags(fs *flag.FlagSet, c *rootCfg) {
 	fs.StringVar(
 		&c.redisURL,
 		"redis-url",
-		"redis://user:pass@127.0.0.1:6379",
+		"redis://127.0.0.1:6379",
 		"redis connection string",
 	)
 
@@ -221,12 +222,10 @@ func execMain(cfg *rootCfg) error {
 	cli := tm2Client.NewClient(cfg.remote)
 
 	// Prepare the middlewares
-	middlewares := []faucet.Middleware{
-		prepareFundMiddleware(cli, fundLimit),
-	}
+	var middlewares []faucet.Middleware
 
-	// TODO temporary
 	if len(cfg.allowedTokens) != 0 {
+		// TODO temporary for testing purpose without redis
 		middlewares = append(middlewares, prepareTokenListMiddleware(cfg.allowedTokens))
 	} else {
 		redisOpts, err := redis.ParseURL(cfg.redisURL)
@@ -235,8 +234,21 @@ func execMain(cfg *rootCfg) error {
 		}
 		redisClient := redis.NewClient(redisOpts)
 
+		// Add /?addr={gnoAddr} endpoint as a middleware in first position.
+		// If the request contains an `addr` field in the query string, it will fetch
+		// the email from redis and returns it, without calling the other handlers
+		// or middlewares behind it.
+		//
+		// Why not a faucet.Handler option instead of a middleware ?
+		// This is not achievable with a real handler passed in the faucet options
+		// because it inherits the other middlewares which requires a
+		// faucet.Request or else fails with Bad Request.
+		middlewares = append(middlewares, getEmail(redisClient))
+
 		middlewares = append(middlewares, prepareTokenMiddleware(redisClient))
 	}
+	// Call prepareFundMiddleware last to avoid funding users with invalid tokens
+	middlewares = append(middlewares, prepareFundMiddleware(cli, fundLimit))
 
 	// Create a new faucet with
 	// static gas estimation
@@ -464,14 +476,74 @@ func prepareTokenMiddleware(redisClient *redis.Client) faucet.Middleware {
 				return
 			}
 
-			// Continue with serving the faucet request
-			next.ServeHTTP(w, r)
-
 			_, err = redisClient.HSet(r.Context(), "TOKEN:"+token, "used", "true").Result()
 			if err != nil {
 				http.Error(w, "Unable to lock token", http.StatusInternalServerError)
 				return
 			}
+
+			// Parse the request to extract the address
+			// XXX copied from prepareFundMiddleware, don't have time to refactor without unit tests!
+			var request faucet.Request
+			body, err := io.ReadAll(r.Body)
+			if err != nil {
+				http.Error(w, "Error reading request body", http.StatusInternalServerError)
+				return
+			}
+			// Close the original body
+			if err := r.Body.Close(); err != nil {
+				http.Error(w, "Error closing request body", http.StatusInternalServerError)
+				return
+			}
+			// Create a new ReadCloser from the read bytes
+			// so that future middleware will be able to read
+			r.Body = io.NopCloser(bytes.NewReader(body))
+			// Decode the original request
+			if err := json.NewDecoder(bytes.NewBuffer(body)).Decode(&request); err != nil {
+				http.Error(w, "Invalid request", http.StatusBadRequest)
+				return
+			}
+
+			// Read email
+			email, err := redisClient.HGet(r.Context(), "TOKEN:"+token, "email").Result()
+			if err != nil {
+				http.Error(w, "Unable to read token email", http.StatusInternalServerError)
+				return
+			}
+			// Store gno adress, email and token, so they are retrievable via the
+			// getEmail middleware.
+			err = redisClient.HSet(r.Context(), "GNO:"+request.To, "email", email, "token", token).Err()
+			if err != nil {
+				http.Error(w, "Unable to set gno address and email", http.StatusInternalServerError)
+				return
+			}
+
+			// Continue with serving the faucet request
+			next.ServeHTTP(w, r)
+		})
+	}
+}
+
+// getEmail detects the presence of `addr` form value, if present returns the
+// corresponding hashset from redis and stops the request.
+func getEmail(redisClient *redis.Client) faucet.Middleware {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			addr := r.FormValue("addr")
+			if addr != "" {
+				res := redisClient.HGetAll(r.Context(), "GNO:"+addr)
+				if res.Err() != nil {
+					http.Error(w, "Unable to get gno address", http.StatusInternalServerError)
+					return
+				}
+				err := json.NewEncoder(w).Encode(res.Val())
+				if err != nil {
+					http.Error(w, "Unable to encode gno address values", http.StatusInternalServerError)
+					return
+				}
+				return
+			}
+			next.ServeHTTP(w, r)
 		})
 	}
 }

web/assets/js/components/gameoptions.ts

@@ -358,7 +358,7 @@ const Gameoptions = class extends Component {
         isTokenError = true;
         this.DOM.el.querySelector('#id-gameoptions-token').value = '';
         this.DOM.ctrl1.innerHTML = 'Connection';
-        this.call('appear', ['Invalid token', 'error'], 'toast');
+        this.call('appear', [e, 'error'], 'toast');
       }
     }
     this.disabled = false;