add nft assets endpoint (#298)

2026-01-16 04:54:42 +00:00 · 2021-12-08 14:04:19 +00:00
parent 22ce7074a0
commit cc0a59aaf7
9 changed files with 1829 additions and 108 deletions
--- a/nft/handler/nft.go
+++ b/nft/handler/nft.go
@@ -2,49 +2,14 @@ package handler

 import (
 	"context"
-	"sync"
-	"time"


-	"github.com/micro/services/pkg/tenant"
-	"github.com/micro/micro/v3/service/store"
 	pb "github.com/micro/services/nft/proto"
 )

 type Nft struct{}

-var (
-	mtx sync.RWMutex
-
-	voteKey = "votes/"
-)
-
-type Vote struct {
-	Id string `json:"id"`
-	Message string `json:"message"`
-	VotedAt time.Time `json:"voted_at"`
-}
-
-func (n *Nft) Vote(ctx context.Context, req *pb.VoteRequest, rsp *pb.VoteResponse) error {
-	mtx.Lock()
-	defer mtx.Unlock()
-
-	id, ok := tenant.FromContext(ctx)
-	if !ok {
-		id = "micro"
-	}
-
-	rec := store.NewRecord(voteKey + id, &Vote{
-		Id: id,
-		Message: req.Message,
-		VotedAt: time.Now(),
-	})
-
-	// we don't need to check the error
-	store.Write(rec)
-
-	rsp.Message = "Thanks for the vote!"

+func (n *Nft) Assets(ctx context.Context, req *pb.AssetsRequest, rsp *pb.AssetsResponse) error {
 	return nil
 }
-
--- a/nft/handler/opensea.go
+++ b/nft/handler/opensea.go
@@ -0,0 +1,227 @@
+package handler
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/micro/services/pkg/api"
+	"github.com/micro/services/nft/domain"
+	"github.com/micro/micro/v3/service/config"
+	"github.com/micro/micro/v3/service/logger"
+	"github.com/micro/micro/v3/service/errors"
+	pb "github.com/micro/services/nft/proto"
+)
+
+// OpenSea handler
+type OpenSea struct {
+	apiKey string
+	// embed nft api
+	*Nft
+}
+
+var (
+	openseaURL = "https://api.opensea.io/api/v1"
+)
+
+
+func New() *OpenSea {
+        v, err := config.Get("nft.key")
+        if err != nil {
+                logger.Fatal("nft.key config not found: %v", err)
+        }
+
+        key := v.String("")
+        if len(key) == 0 {
+                logger.Fatal("nft.key config not found")
+        }
+
+	// set the api key
+	api.SetKey("X-API-KEY", key)
+
+	return &OpenSea {
+		apiKey: key,
+		Nft: new(Nft),
+	}
+}
+
+func (o *OpenSea) Assets(ctx context.Context, req *pb.AssetsRequest, rsp *pb.AssetsResponse) error {
+	uri := openseaURL + "/assets"
+	params := "?"
+
+	limit := int32(20)
+	offset := int32(0)
+	order := "desc"
+	orderBy := ""
+
+	if req.Limit > 0 {
+		limit = req.Limit
+	}
+
+	if req.Offset > 0 {
+		offset = req.Offset
+	}
+
+	if req.Order == "asc" {
+		order = "asc"
+	}
+
+	switch req.OrderBy {
+	case "sale_date", "sale_count", "sale_price", "total_price":
+		orderBy = req.OrderBy
+	}
+
+	params += fmt.Sprintf("limit=%d&offset=%d&order_direction=%s",
+		limit, offset, order)
+
+	if len(orderBy) > 0 {
+		params += "&order_by=" + orderBy
+	}
+
+	if len(req.Collection) > 0 {
+		params += "&collection=" + req.Collection
+	}
+
+	var resp domain.AssetResponse
+
+	if err := api.Get(uri + params, &resp); err != nil {
+		return errors.InternalServerError("nft.assets", "failed to get assets: %v", err)
+	}
+
+	for _, asset := range resp.Assets {
+		if asset.Creator == nil {
+			asset.Creator = &domain.User{
+				User: &domain.Username{},
+			}
+		}
+		if asset.Creator.User == nil {
+			asset.Creator.User = &domain.Username{}
+		}
+		if asset.Owner == nil {
+			asset.Owner = &domain.User{
+				User: &domain.Username{},
+			}
+		}
+		if asset.Owner.User == nil {
+			asset.Owner.User = &domain.Username{}
+		}
+		if asset.Collection == nil {
+			asset.Collection = new(domain.Collection)
+		}
+		if asset.Contract == nil {
+			asset.Contract = new(domain.Contract)
+		}
+
+		lastSale := new(pb.Sale)
+
+		if asset.LastSale != nil {
+			if asset.LastSale.Transaction == nil {
+				asset.LastSale.Transaction = &domain.Transaction{
+					FromAccount: &domain.User{User: new(domain.Username)},
+					ToAccount: &domain.User{User: new(domain.Username)},
+				}
+			}
+			if asset.LastSale.Transaction.FromAccount == nil {
+				asset.LastSale.Transaction.FromAccount = &domain.User{User: new(domain.Username)}
+			}
+			if asset.LastSale.Transaction.FromAccount.User == nil {
+				asset.LastSale.Transaction.FromAccount.User = new(domain.Username)
+			}
+			if asset.LastSale.Transaction.ToAccount == nil {
+				asset.LastSale.Transaction.ToAccount = &domain.User{User: new(domain.Username)}
+			}
+			if asset.LastSale.Transaction.ToAccount.User == nil {
+				asset.LastSale.Transaction.ToAccount.User = new(domain.Username)
+			}
+			if asset.LastSale.PaymentToken == nil {
+				asset.LastSale.PaymentToken = new(domain.Token)
+			}
+
+			lastSale = &pb.Sale{
+				AssetTokenId: asset.LastSale.Asset.TokenId,
+				AssetDecimals: asset.LastSale.Asset.Decimals,
+				EventType: asset.LastSale.EventType,
+				EventTimestamp: asset.LastSale.EventTimestamp,
+				TotalPrice: asset.LastSale.TotalPrice,
+				Quantity: asset.LastSale.Quantity,
+				CreatedAt: asset.LastSale.CreatedAt,
+				Transaction: &pb.Transaction{
+					Id: asset.LastSale.Transaction.Id,
+					Timestamp: asset.LastSale.Transaction.Timestamp,
+					BlockHash: asset.LastSale.Transaction.BlockHash,
+					BlockNumber: asset.LastSale.Transaction.BlockNumber,
+					FromAccount: &pb.User{
+						Username: asset.LastSale.Transaction.FromAccount.User.Username,
+						ProfileUrl: asset.LastSale.Transaction.FromAccount.ProfileUrl,
+						Address: asset.LastSale.Transaction.FromAccount.Address,
+					},
+					ToAccount: &pb.User{
+						Username: asset.LastSale.Transaction.ToAccount.User.Username,
+						ProfileUrl: asset.LastSale.Transaction.ToAccount.ProfileUrl,
+						Address: asset.LastSale.Transaction.ToAccount.Address,
+					},
+					TransactionHash: asset.LastSale.Transaction.TransactionHash,
+					TransactionIndex: asset.LastSale.Transaction.TransactionIndex,
+				},
+				PaymentToken: &pb.Token{
+					Id: asset.LastSale.PaymentToken.Id,
+					Name: asset.LastSale.PaymentToken.Name,
+					Symbol: asset.LastSale.PaymentToken.Symbol,
+					Address: asset.LastSale.PaymentToken.Address,
+					ImageUrl: asset.LastSale.PaymentToken.ImageUrl,
+					Decimals: asset.LastSale.PaymentToken.Decimals,
+					EthPrice: asset.LastSale.PaymentToken.EthPrice,
+					UsdPrice: asset.LastSale.PaymentToken.UsdPrice,
+				},
+			}
+		}
+
+		rsp.Assets = append(rsp.Assets, &pb.Asset{
+			Name: asset.Name,
+			Description: asset.Description,
+			Id: asset.Id,
+			TokenId: asset.TokenId,
+			ImageUrl: asset.ImageUrl,
+			Sales: asset.Sales,
+			Permalink: asset.Permalink,
+			Contract: &pb.Contract{
+				Name: asset.Contract.Name,
+				Description: asset.Contract.Description,
+				Address: asset.Contract.Address,
+				Type: asset.Contract.Type,
+				CreatedAt: asset.Contract.CreatedAt,
+				Owner: asset.Contract.Owner,
+				Schema: asset.Contract.Schema,
+				Symbol: asset.Contract.Symbol,
+				PayoutAddress: asset.Contract.PayoutAddress,
+				SellerFees: asset.Contract.SellerFees,
+			},
+			Collection: &pb.Collection{
+				Name: asset.Collection.Name,
+				Description: asset.Collection.Description,
+				Slug: asset.Collection.Slug,
+				ImageUrl: asset.Collection.ImageUrl,
+				CreatedAt: asset.Collection.CreatedAt,
+				PayoutAddress: asset.Collection.PayoutAddress,
+			},
+			Owner: &pb.User{
+				Username: asset.Owner.User.Username,
+				ProfileUrl: asset.Owner.ProfileUrl,
+				Address: asset.Owner.Address,
+			},
+			Creator: &pb.User{
+				Username: asset.Creator.User.Username,
+				ProfileUrl: asset.Creator.ProfileUrl,
+				Address: asset.Creator.Address,
+			},
+			LastSale: lastSale,
+			Presale: asset.Presale,
+			ListingDate: asset.ListingDate,
+		})
+	}
+
+	return nil
+}
+
+func (o *OpenSea) Create(ctx context.Context, req *pb.CreateRequest, rsp *pb.CreateResponse) error {
+	return errors.BadRequest("nft.create", "coming soon")
+}