feat(grc20-launchpad): UI implementation

gno/r/launchpad_grc20/airdrop_grc20.gno

@@ -3,17 +3,20 @@ package launchpad_grc20
 import (
 	"encoding/hex"
 	"std"
+	"strconv"
 	"time"
 
 	"gno.land/p/demo/avl"
 	"gno.land/p/demo/json"
 	"gno.land/p/demo/merkle"
 	"gno.land/p/demo/seqid"
+	"gno.land/p/demo/ufmt"
 	"gno.land/p/teritori/jsonutil"
 )
 
 type Airdrop struct {
 	token          *Token
+	id             seqid.ID
 	merkleRoot     string
 	startTimestamp int64
 	endTimestamp   int64
@@ -52,16 +55,18 @@ func NewAirdrop(tokenName, merkleRoot string, amountPerAddr uint64, startTimesta
 		panic("invalid timestamps, start must be before end")
 	}
 
+	airdropID := nextAirdropID.Next()
+
 	airdrop := Airdrop{
 		token:          token,
+		id:             airdropID,
 		merkleRoot:     merkleRoot,
 		startTimestamp: startTimestamp,
 		endTimestamp:   endTimestamp,
 		amountPerAddr:  amountPerAddr,
 		alreadyClaimed: avl.NewTree(),
 	}
 
-	airdropID := nextAirdropID.Next()
 	token.AirdropsIDs = append(token.AirdropsIDs, airdropID)
 
 	airdrops.Set(airdropID.String(), &airdrop)
@@ -110,6 +115,27 @@ func Claim(airdropID uint64, proofs []merkle.Node) {
 	airdrop.alreadyClaimed.Set(caller.String(), true)
 }
 
+func (a *Airdrop) hasAlreadyClaimed(caller std.Address) bool {
+	return a.alreadyClaimed.Has(caller.String())
+}
+
+func (a *Airdrop) isOnGoing() bool {
+	now := time.Now().Unix()
+	return (a.startTimestamp == 0 || a.startTimestamp <= now) &&
+		(a.endTimestamp == 0 || now < a.endTimestamp)
+}
+
+func (a *Airdrop) ToJSON() *json.Node {
+	return json.ObjectNode("", map[string]*json.Node{
+		"id":             json.StringNode("", ufmt.Sprintf("%d", uint64(a.id))),
+		"tokenName":      json.StringNode("", a.token.banker.GetName()),
+		"tokenSymbol":    json.StringNode("", a.token.banker.GetSymbol()),
+		"amountPerAddr":  json.StringNode("", strconv.FormatUint(a.amountPerAddr, 10)),
+		"startTimestamp": json.StringNode("", strconv.FormatInt(a.startTimestamp, 10)),
+		"endTimestamp":   json.StringNode("", strconv.FormatInt(a.endTimestamp, 10)),
+	})
+}
+
 func mustGetAirdrop(airdropID uint64) *Airdrop {
 	id := seqid.ID(airdropID)
 	airdropRaw, exists := airdrops.Get(id.String())
@@ -120,12 +146,16 @@ func mustGetAirdrop(airdropID uint64) *Airdrop {
 	return airdropRaw.(*Airdrop)
 }
 
-func (a *Airdrop) hasAlreadyClaimed(caller std.Address) bool {
-	return a.alreadyClaimed.Has(caller.String())
-}
+func GetLastAirdropsJSON() string {
+	nodes := make([]*json.Node, 0, 10)
+	for i := int(nextAirdropID); i > int(nextAirdropID)-10; i-- {
+		airdropRaw, exists := airdrops.Get(seqid.ID(i).String())
+		if !exists {
+			continue
+		}
 
-func (a *Airdrop) isOnGoing() bool {
-	now := time.Now().Unix()
-	return (a.startTimestamp == 0 || a.startTimestamp <= now) &&
-		(a.endTimestamp == 0 || now < a.endTimestamp)
+		airdrop := airdropRaw.(*Airdrop)
+		nodes = append(nodes, airdrop.ToJSON())
+	}
+	return json.ArrayNode("", nodes).String()
 }

gno/r/launchpad_grc20/render.gno

@@ -48,16 +48,15 @@ func renderTokenPage(res *mux.ResponseWriter, req *mux.Request) {
 	res.Write("## Usage\n")
 	res.Write("You can create your own token by referring to the help section in the documentation and using the NewToken function.\nAfter creating your token, you can manage it easily through the provided interface.\nTo view details of any token created by this factory, simply visit the page ``:token/{name}``, replacing ``{name}`` with the token's name.\n")
 
-	if len(lastTokensIDcreated) > 0 {
+	if len(lastTokensCreated) > 0 {
 		res.Write("## Last tokens created\n")
 
-		for _, tokenIDs := range lastTokensIDcreated {
-			token := mustGetToken(tokenIDs)
+		for _, token := range lastTokensCreated {
 			res.Write(ufmt.Sprintf("### Name: %s - Symbol: %s\n", token.banker.GetName(), token.banker.GetSymbol()))
 			res.Write(ufmt.Sprintf("#### Total Supply: %d %s\n", token.banker.TotalSupply(), token.banker.GetSymbol()))
 			res.Write(ufmt.Sprintf("#### Decimals: %d\n", token.banker.GetDecimals()))
 			res.Write(ufmt.Sprintf("#### Admin: %s\n\n", token.admin.Owner().String()))
-			res.Write(ufmt.Sprintf("> Link: [:token/%s](launchpad_grc20:token/%s)\n\n", tokenIDs, tokenIDs))
+			res.Write(ufmt.Sprintf("> Link: [:token/%s](launchpad_grc20:token/%s)\n\n", token.banker.GetName(), token.banker.GetName()))
 		}
 	}
 	renderFooter(res, "")

gno/r/launchpad_grc20/sale_grc20.gno

@@ -3,6 +3,7 @@ package launchpad_grc20
 import (
 	"encoding/hex"
 	"std"
+	"strconv"
 	"time"
 
 	"gno.land/p/demo/avl"
@@ -15,6 +16,7 @@ import (
 
 type Sale struct {
 	token          *Token
+	id             seqid.ID
 	startTimestamp int64
 	endTimestamp   int64
 	pricePerToken  uint64
@@ -66,6 +68,10 @@ func NewSale(tokenName, merkleRoot string, startTimestamp, endTimestamp int64, p
 		panic("price per token must be greater than 0")
 	}
 
+	if limitPerAddr == 0 {
+		panic("limit per address must be greater than 0")
+	}
+
 	realmAddr := std.CurrentRealm().Addr()
 	if mintToken {
 		token.banker.Mint(realmAddr, maxGoal)
@@ -76,8 +82,11 @@ func NewSale(tokenName, merkleRoot string, startTimestamp, endTimestamp int64, p
 		}
 	}
 
+	saleID := nextSaleID.Next()
+
 	sale := Sale{
 		token:          token,
+		id:             saleID,
 		startTimestamp: startTimestamp,
 		endTimestamp:   endTimestamp,
 		pricePerToken:  pricePerToken,
@@ -90,7 +99,6 @@ func NewSale(tokenName, merkleRoot string, startTimestamp, endTimestamp int64, p
 		merkleRoot:     merkleRoot,
 	}
 
-	saleID := nextSaleID.Next()
 	token.SalesIDs = append(token.SalesIDs, saleID)
 
 	sales.Set(saleID.String(), &sale)
@@ -157,15 +165,6 @@ func Finalize(saleID uint64) {
 	sale.finalized = true
 }
 
-func mustGetSale(saleID uint64) *Sale {
-	id := seqid.ID(saleID)
-	sale, exists := sales.Get(id.String())
-	if !exists {
-		panic("sale not found")
-	}
-	return sale.(*Sale)
-}
-
 func (s *Sale) isOnGoing() bool {
 	return s.startTimestamp <= time.Now().Unix() && (s.endTimestamp == 0 || time.Now().Unix() < s.endTimestamp)
 }
@@ -267,3 +266,39 @@ func (s *Sale) payAllBuyers() {
 		return false
 	})
 }
+
+func (s *Sale) ToJSON() *json.Node {
+	return json.ObjectNode("", map[string]*json.Node{
+		"id":             json.StringNode("", ufmt.Sprintf("%d", uint64(s.id))),
+		"tokenName":      json.StringNode("", s.token.banker.GetName()),
+		"pricePerToken":  json.StringNode("", strconv.FormatUint(s.pricePerToken, 10)),
+		"limitPerAddr":   json.StringNode("", strconv.FormatUint(s.limitPerAddr, 10)),
+		"minGoal":        json.StringNode("", strconv.FormatUint(s.minGoal, 10)),
+		"maxGoal":        json.StringNode("", strconv.FormatUint(s.maxGoal, 10)),
+		"startTimestamp": json.StringNode("", strconv.FormatInt(s.startTimestamp, 10)),
+		"endTimestamp":   json.StringNode("", strconv.FormatInt(s.endTimestamp, 10)),
+	})
+}
+
+func mustGetSale(saleID uint64) *Sale {
+	id := seqid.ID(saleID)
+	sale, exists := sales.Get(id.String())
+	if !exists {
+		panic("sale not found")
+	}
+	return sale.(*Sale)
+}
+
+func GetLastSalesJSON() string {
+	nodes := make([]*json.Node, 0, 10)
+	for i := int(nextSaleID); i > int(nextSaleID)-10; i-- {
+		saleRaw, exists := sales.Get(seqid.ID(i).String())
+		if !exists {
+			continue
+		}
+
+		sale := saleRaw.(*Sale)
+		nodes = append(nodes, sale.ToJSON())
+	}
+	return json.ArrayNode("", nodes).String()
+}

gno/r/launchpad_grc20/token_factory_grc20.gno

@@ -2,13 +2,17 @@ package launchpad_grc20
 
 import (
 	"std"
+	"strconv"
 
 	"gno.land/p/demo/avl"
 	"gno.land/p/demo/grc/grc20"
+	"gno.land/p/demo/json"
 	"gno.land/p/demo/ownable"
 	"gno.land/p/demo/seqid"
 )
 
+const LENGTH_LAST_TOKENS_CACHE = 10
+
 type Token struct {
 	banker         *grc20.Banker
 	admin          *ownable.Ownable
@@ -22,12 +26,11 @@ type Token struct {
 
 var _ grc20.Token = (*Token)(nil)
 
-var lastTokensIDcreated = []string{}
-
 var (
-	tokens       *avl.Tree // name -> token
-	factoryAdmin *ownable.Ownable
-	factoryVault std.Address
+	tokens            *avl.Tree // name -> token
+	factoryAdmin      *ownable.Ownable
+	factoryVault      std.Address
+	lastTokensCreated = []*Token{}
 )
 
 // Initialize tori address as admin & vault for fees
@@ -75,10 +78,10 @@ func NewToken(name, symbol, image string, decimals uint, initialSupply, totalSup
 
 	tokens.Set(name, &inst)
 
-	if len(lastTokensIDcreated) == 5 {
-		lastTokensIDcreated = lastTokensIDcreated[:4]
+	if len(lastTokensCreated) == LENGTH_LAST_TOKENS_CACHE {
+		lastTokensCreated = lastTokensCreated[:(LENGTH_LAST_TOKENS_CACHE - 1)]
 	}
-	lastTokensIDcreated = append([]string{name}, lastTokensIDcreated...)
+	lastTokensCreated = append([]*Token{&inst}, lastTokensCreated...)
 }
 
 func Mint(name string, to std.Address, amount uint64) {
@@ -160,11 +163,33 @@ func (token Token) TransferFrom(from, to std.Address, amount uint64) error {
 	return token.Token().TransferFrom(from, to, amount)
 }
 
+func (token Token) ToJSON() *json.Node {
+	return json.ObjectNode("", map[string]*json.Node{
+		"name":           json.StringNode("", token.banker.GetName()),
+		"symbol":         json.StringNode("", token.banker.GetSymbol()),
+		"decimals":       json.StringNode("", strconv.FormatUint(uint64(token.banker.GetDecimals()), 10)),
+		"admin":          json.StringNode("", token.admin.Owner().String()),
+		"image":          json.StringNode("", token.image),
+		"totalSupply":    json.StringNode("", strconv.FormatInt(int64(token.TotalSupply()), 10)),
+		"totalSupplyCap": json.StringNode("", strconv.FormatInt(int64(token.totalSupplyCap), 10)),
+		"allowMint":      json.BoolNode("", token.allowMint),
+		"allowBurn":      json.BoolNode("", token.allowBurn),
+	})
+}
+
 func SetFactoryVault(vault std.Address) {
 	factoryAdmin.AssertCallerIsOwner()
 	factoryVault = vault
 }
 
+func GetLastTokensJSON() string {
+	nodes := make([]*json.Node, len(lastTokensCreated))
+	for i, token := range lastTokensCreated {
+		nodes[i] = token.ToJSON()
+	}
+	return json.ArrayNode("", nodes).String()
+}
+
 func mustGetToken(name string) *Token {
 	t, exists := tokens.Get(name)
 	if !exists {

go/pkg/networks/features.gen.go

@@ -19,6 +19,7 @@ const (
 	FeatureTypeNFTBridge                 = FeatureType("NFTBridge")
 	FeatureTypeCosmWasmPremiumFeed       = FeatureType("CosmWasmPremiumFeed")
 	FeatureTypeGnoProjectManager         = FeatureType("GnoProjectManager")
+	FeatureTypeLaunchpadERC20            = FeatureType("LaunchpadERC20")
 	FeatureTypeNFTMarketplaceLeaderboard = FeatureType("NFTMarketplaceLeaderboard")
 	FeatureTypeCosmWasmNFTsBurner        = FeatureType("CosmWasmNFTsBurner")
 )
@@ -82,6 +83,26 @@ func (nb *NetworkBase) GetFeatureGnoProjectManager() (*FeatureGnoProjectManager,
 	return feature.(*FeatureGnoProjectManager), nil
 }
 
+type FeatureLaunchpadERC20 struct {
+	*FeatureBase
+	LaunchpadERC20PkgPath string `json:"launchpadERC20PkgPath"`
+	PaymentsDenom         string `json:"paymentsDenom"`
+}
+
+var _ Feature = &FeatureLaunchpadERC20{}
+
+func (f FeatureLaunchpadERC20) Type() FeatureType {
+	return FeatureTypeLaunchpadERC20
+}
+
+func (nb *NetworkBase) GetFeatureLaunchpadERC20() (*FeatureLaunchpadERC20, error) {
+	feature, err := nb.GetFeature(FeatureTypeLaunchpadERC20)
+	if err != nil {
+		return nil, err
+	}
+	return feature.(*FeatureLaunchpadERC20), nil
+}
+
 func UnmarshalFeature(b []byte) (Feature, error) {
 	var base FeatureBase
 	if err := json.Unmarshal(b, &base); err != nil {
@@ -106,6 +127,12 @@ func UnmarshalFeature(b []byte) (Feature, error) {
 			return nil, errors.Wrap(err, "failed to unmarshal feature GnoProjectManager")
 		}
 		return &f, nil
+	case FeatureTypeLaunchpadERC20:
+		var f FeatureLaunchpadERC20
+		if err := json.Unmarshal(b, &f); err != nil {
+			return nil, errors.Wrap(err, "failed to unmarshal feature LaunchpadERC20")
+		}
+		return &f, nil
 	}
 	return nil, errors.Errorf("unknown feature type %s", base.Type)
 }