Pixel Shield (#428)

* feat: shield ui flow

* feat: added shield UI and multicall to register shield

* fix: avoid empty pixel call

* feat: improve call

* fix: allow only one pixel selection

* fix: remove unsed import

Author: addegbenga

backend/cmd/backend/backend.go

@@ -78,6 +78,7 @@ func main() {
 	indexer.InitIndexerRoutes()
 	routes.InitWebsocketRoutes()
 	routes.InitNFTStaticRoutes()
+	indexer.StartMessageProcessor()
 
 	core.AFKBackend.Start(core.AFKBackend.BackendConfig.Port)
 }

backend/postgres/init.sql

@@ -5,7 +5,8 @@ CREATE TABLE Pixels (
   position integer NOT NULL,
   day integer NOT NULL,
   color integer NOT NULL,
-  time timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
+  time timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  metadata JSONB DEFAULT NULL
 );
 CREATE INDEX pixels_address_index ON Pixels (address);
 CREATE INDEX pixels_position_index ON Pixels (position);

backend/routes/indexer/pixel.go

@@ -2,6 +2,8 @@ package indexer
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 	"strconv"
 
 	"github.com/AFK-AlignedFamKernel/afk_monorepo/backend/core"
@@ -52,6 +54,7 @@ func processPixelPlacedEvent(event IndexerEvent) {
 		return
 	}
 
+	fmt.Printf(address, position, dayIdx, color, "print")
 	// Set pixel in postgres
 	_, err = core.AFKBackend.Databases.Postgres.Exec(context.Background(), "INSERT INTO Pixels (address, position, day, color) VALUES ($1, $2, $3, $4)", address, position, dayIdx, color)
 	if err != nil {
@@ -116,7 +119,6 @@ func revertPixelPlacedEvent(event IndexerEvent) {
 func processBasicPixelPlacedEvent(event IndexerEvent) {
 	address := event.Event.Keys[1][2:] // Remove 0x prefix
 	timestampHex := event.Event.Data[0]
-
 	timestamp, err := strconv.ParseInt(timestampHex, 0, 64)
 	if err != nil {
 		PrintIndexerError("processBasicPixelPlacedEvent", "Error converting timestamp hex to int", address, timestampHex)
@@ -234,3 +236,117 @@ func revertExtraPixelsPlacedEvent(event IndexerEvent) {
 		return
 	}
 }
+
+func processBasicPixelPlacedEventWithMetadata(event IndexerEvent) {
+	address := event.Event.Keys[1][2:] // Remove 0x prefix
+	timestampHex := event.Event.Data[0]
+	timestamp, err := strconv.ParseInt(timestampHex, 0, 64)
+	if err != nil {
+		PrintIndexerError("processBasicPixelPlacedEventWithMetadata", "Error converting timestamp hex to int", address, timestampHex)
+		return
+	}
+
+	// Extract position and color from the event (position is Keys[2], color is in Data[1])
+	positionHex := event.Event.Keys[2]
+	position, err := strconv.Atoi(positionHex)
+	if err != nil {
+		PrintIndexerError("processBasicPixelPlacedEventWithMetadata", "Error converting position hex to int", address, positionHex)
+		return
+	}
+
+	colorHex := event.Event.Data[1]
+	color, err := strconv.Atoi(colorHex)
+	if err != nil {
+		PrintIndexerError("processBasicPixelPlacedEventWithMetadata", "Error converting color hex to int", address, colorHex)
+		return
+	}
+
+	// Extract metadata from the last index in Data (metadata is in Data[n])
+	metadata := event.Event.Data[len(event.Event.Data)-1]
+
+	// Unmarshal metadata (if it exists)
+	var metadataMap map[string]interface{}
+	if len(metadata) > 0 {
+		err = json.Unmarshal([]byte(metadata), &metadataMap)
+		if err != nil {
+			PrintIndexerError("processBasicPixelPlacedEventWithMetadata", "Error parsing metadata", address, string(metadata))
+			return
+		}
+	}
+
+	// Prepare SQL statement for inserting pixel info and metadata together
+	metadataJson, err := json.Marshal(metadataMap)
+	if err != nil {
+		PrintIndexerError("processBasicPixelPlacedEventWithMetadata", "Error serializing metadata", address, string(metadata))
+		return
+	}
+
+	// Use a single query to insert the pixel information and metadata into the database
+	_, err = core.AFKBackend.Databases.Postgres.Exec(context.Background(),
+		`INSERT INTO Pixels (address, position, color, time)
+		 VALUES ($1, $2, $3, TO_TIMESTAMP($4))
+		 ON CONFLICT (address, position)
+		 DO UPDATE SET color = $3, time = TO_TIMESTAMP($4),
+		 metadata = COALESCE(metadata, $5)`,
+		address, position, color, timestamp, metadataJson)
+	if err != nil {
+		PrintIndexerError("processBasicPixelPlacedEventWithMetadata", "Error inserting/updating pixel and metadata", address, string(metadataJson))
+		return
+	}
+
+	// Insert or update the last placed time in the LastPlacedTime table
+	_, err = core.AFKBackend.Databases.Postgres.Exec(context.Background(),
+		"INSERT INTO LastPlacedTime (address, time) VALUES ($1, TO_TIMESTAMP($2)) ON CONFLICT (address) DO UPDATE SET time = TO_TIMESTAMP($2)",
+		address, timestamp)
+	if err != nil {
+		PrintIndexerError("processBasicPixelPlacedEventWithMetadata", "Error inserting last placed time into postgres", address, timestampHex)
+		return
+	}
+}
+
+func revertBasicPixelPlacedEventWithMetadata(event IndexerEvent) {
+	address := event.Event.Keys[1][2:] // Remove 0x prefix
+	posHex := event.Event.Keys[2]
+
+	// Convert hex to int for position
+	position, err := strconv.ParseInt(posHex, 0, 64)
+	if err != nil {
+		PrintIndexerError("revertPixelPlacedEvent", "Error converting position hex to int", address, posHex)
+		return
+	}
+
+	// We can also retrieve the metadata from the event if needed
+	metadata := event.Event.Data[len(event.Event.Data)-1]
+	var metadataMap map[string]interface{}
+	if len(metadata) > 0 {
+		err = json.Unmarshal([]byte(metadata), &metadataMap) // Unmarshal from metadata (which is a string) to map
+		if err != nil {
+			PrintIndexerError("revertPixelPlacedEvent", "Error parsing metadata", address, string(metadata))
+			return
+		}
+	}
+
+	// Delete the pixel entry (including metadata) from the PostgreSQL database
+	_, err = core.AFKBackend.Databases.Postgres.Exec(context.Background(), `
+		DELETE FROM Pixels
+		WHERE address = $1 AND position = $2
+		ORDER BY time LIMIT 1`, address, position)
+	if err != nil {
+		PrintIndexerError("revertPixelPlacedEvent", "Error deleting pixel from postgres", address, posHex)
+		return
+	}
+
+	// Optionally, you can also delete the metadata from the database,
+	// but usually deleting the pixel entry will automatically take care of it since metadata is part of the same row.
+
+	// Delete the pixel's associated last placed time entry from the LastPlacedTime table
+	_, err = core.AFKBackend.Databases.Postgres.Exec(context.Background(),
+		"DELETE FROM LastPlacedTime WHERE address = $1", address)
+	if err != nil {
+		PrintIndexerError("revertPixelPlacedEvent", "Error deleting last placed time from postgres", address, posHex)
+		return
+	}
+
+	// Optionally log the event if needed
+	fmt.Printf("Pixel at position %d for address %s has been reverted.\n", position, address)
+}

backend/routes/pixel.go

@@ -2,16 +2,27 @@ package routes
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"net/http"
 	"os"
 	"os/exec"
 	"strconv"
+	"time"
 
 	"github.com/AFK-AlignedFamKernel/afk_monorepo/backend/core"
 	routeutils "github.com/AFK-AlignedFamKernel/afk_monorepo/backend/routes/utils"
 )
 
+// Define a struct to represent a Pixel record
+type Pixel struct {
+	Address  string    `json:"address"`
+	Position int       `json:"position"`
+	Day      int       `json:"day"`
+	Color    int       `json:"color"`
+	Time     time.Time `json:"time"`
+}
+
 func InitPixelRoutes() {
 	http.HandleFunc("/get-pixel", getPixel)
 	http.HandleFunc("/get-pixel-info", getPixelInfo)
@@ -53,32 +64,78 @@ func getPixel(w http.ResponseWriter, r *http.Request) {
 }
 
 type PixelInfo struct {
-	Address string `json:"address"`
-	Name    string `json:"username"`
+	Address  string          `json:"address"`
+	Name     string          `json:"username"`
+	Metadata json.RawMessage `json:"metadata,omitempty"`
 }
 
+// func getPixelInfo(w http.ResponseWriter, r *http.Request) {
+// 	position, err := strconv.Atoi(r.URL.Query().Get("position"))
+// 	if err != nil {
+// 		routeutils.WriteErrorJson(w, http.StatusBadRequest, "Invalid query position")
+// 		return
+// 	}
+
+// 	queryRes, err := core.PostgresQueryOne[PixelInfo](`
+//     SELECT p.address, COALESCE(u.name, '') as name FROM Pixels p
+//     LEFT JOIN Users u ON p.address = u.address WHERE p.position = $1
+//     ORDER BY p.time DESC LIMIT 1`, position)
+// 	if err != nil {
+// 		routeutils.WriteDataJson(w, "\"0x0000000000000000000000000000000000000000000000000000000000000000\"")
+// 		return
+// 	}
+
+// 	if queryRes.Name == "" {
+// 		routeutils.WriteDataJson(w, "\"0x"+queryRes.Address+"\"")
+// 	} else {
+// 		routeutils.WriteDataJson(w, "\""+queryRes.Name+"\"")
+// 	}
+// }
+
+// New implmentation with metadata
 func getPixelInfo(w http.ResponseWriter, r *http.Request) {
 	position, err := strconv.Atoi(r.URL.Query().Get("position"))
 	if err != nil {
 		routeutils.WriteErrorJson(w, http.StatusBadRequest, "Invalid query position")
 		return
 	}
 
+	// Update the query to include metadata
 	queryRes, err := core.PostgresQueryOne[PixelInfo](`
-    SELECT p.address, COALESCE(u.name, '') as name FROM Pixels p
-    LEFT JOIN Users u ON p.address = u.address WHERE p.position = $1
-    ORDER BY p.time DESC LIMIT 1`, position)
+        SELECT
+            p.address,
+            COALESCE(u.name, '') as name,
+            p.metadata  -- Fetch the metadata column as well
+        FROM Pixels p
+        LEFT JOIN Users u ON p.address = u.address
+        WHERE p.position = $1
+        ORDER BY p.time DESC
+        LIMIT 1`, position)
 	if err != nil {
 		routeutils.WriteDataJson(w, "\"0x0000000000000000000000000000000000000000000000000000000000000000\"")
 		return
 	}
 
+	// If queryRes.Name is empty, return the address, else return the name
 	if queryRes.Name == "" {
-		routeutils.WriteDataJson(w, "\"0x"+queryRes.Address+"\"")
+		response := "\"0x" + queryRes.Address + "\""
+		if queryRes.Metadata != nil {
+			// If metadata exists, include it in the response
+			metadataJson, _ := json.Marshal(queryRes.Metadata)
+			response = fmt.Sprintf("{\"address\": \"%s\", \"metadata\": %s}", queryRes.Address, string(metadataJson))
+		}
+		routeutils.WriteDataJson(w, response)
 	} else {
-		routeutils.WriteDataJson(w, "\""+queryRes.Name+"\"")
+		response := "\"" + queryRes.Name + "\""
+		if queryRes.Metadata != nil {
+			// If metadata exists, include it in the response
+			metadataJson, _ := json.Marshal(queryRes.Metadata)
+			response = fmt.Sprintf("{\"name\": \"%s\", \"metadata\": %s}", queryRes.Name, string(metadataJson))
+		}
+		routeutils.WriteDataJson(w, response)
 	}
 }
+
 func getPixelMetadata(w http.ResponseWriter, r *http.Request) {
 	position, err := strconv.Atoi(r.URL.Query().Get("position"))
 	if err != nil {
@@ -102,7 +159,6 @@ func getPixelMetadata(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-
 func placePixelDevnet(w http.ResponseWriter, r *http.Request) {
 	// Disable this in production
 	if routeutils.NonProductionMiddleware(w, r) {
@@ -208,7 +264,7 @@ func placePixelRedis(w http.ResponseWriter, r *http.Request) {
 	}
 
 	jsonBody, err := routeutils.ReadJsonBody[map[string]uint](r)
-	fmt.Println("jsonBody", jsonBody)
+	fmt.Println("jsonBody", r.Body)
 
 	if err != nil {
 		routeutils.WriteErrorJson(w, http.StatusBadRequest, "Invalid JSON request body")
@@ -218,6 +274,8 @@ func placePixelRedis(w http.ResponseWriter, r *http.Request) {
 	position := (*jsonBody)["position"]
 	color := (*jsonBody)["color"]
 
+	fmt.Println("jsonBody", position)
+
 	canvasWidth := core.AFKBackend.CanvasConfig.Canvas.Width
 	canvasHeight := core.AFKBackend.CanvasConfig.Canvas.Height
 
@@ -250,7 +308,5 @@ func placePixelRedis(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	fmt.Println("Error redis insert pixel", err.Error())
-
 	routeutils.WriteResultJson(w, "Pixel placed on redis")
 }