feat: token hub

examples/gno.land/p/demo/grc/grc1155/basic_grc1155_token.gno

@@ -345,3 +345,9 @@ func (s *basicGRC1155Token) RenderHome() (str string) {
 
 	return
 }
+
+func (mt *basicGRC1155Token) Getter() MultiTokenGetter {
+	return func() IGRC1155 {
+		return mt
+	}
+}

examples/gno.land/p/demo/grc/grc1155/igrc1155.gno

@@ -38,3 +38,5 @@ type ApprovalForAllEvent struct {
 type UpdateURIEvent struct {
 	URI string
 }
+
+type MultiTokenGetter func() IGRC1155

examples/gno.land/p/demo/grc/grc721/basic_nft.gno

@@ -395,3 +395,10 @@ func (s *basicNFT) RenderHome() (str string) {
 
 	return
 }
+
+// Then add the Getter method to your NFT types
+func (n *basicNFT) Getter() NFTGetter {
+	return func() IGRC721 {
+		return n
+	}
+}

examples/gno.land/p/demo/grc/grc721/igrc721.gno

@@ -26,3 +26,5 @@ const (
 	ApprovalEvent       = "Approval"
 	ApprovalForAllEvent = "ApprovalForAll"
 )
+
+type NFTGetter func() IGRC721

examples/gno.land/r/demo/grc20reg/grc20reg.gno

@@ -4,6 +4,7 @@ import (
 	"std"
 
 	"gno.land/p/demo/avl"
+	"gno.land/p/demo/avl/rotree"
 	"gno.land/p/demo/fqname"
 	"gno.land/p/demo/grc/grc20"
 	"gno.land/p/demo/ufmt"
@@ -22,6 +23,22 @@ func Register(tokenGetter grc20.TokenGetter, slug string) {
 	)
 }
 
+func RegisterWithTokenhub(tokenGetter grc20.TokenGetter, key string) {
+	prevRealmPath := std.PrevRealm().PkgPath()
+	if prevRealmPath != "gno.land/r/demo/tokenhub" {
+		return
+	}
+
+	registry.Set(key, tokenGetter)
+
+	rlmPath, slug := fqname.Parse(key)
+	std.Emit(
+		registerEvent,
+		"pkgpath", rlmPath,
+		"slug", slug,
+	)
+}
+
 func Get(key string) grc20.TokenGetter {
 	tokenGetter, ok := registry.Get(key)
 	if !ok {
@@ -74,3 +91,7 @@ func Render(path string) string {
 }
 
 const registerEvent = "register"
+
+func GetRegistry() *rotree.ReadOnlyTree {
+	return rotree.Wrap(registry, nil)
+}

examples/gno.land/r/demo/tokenhub/errors.gno

@@ -0,0 +1,15 @@
+package tokenhub
+
+import (
+	"errors"
+)
+
+var (
+	ErrNFTAlreadyRegistered = errors.New("NFT already registered")
+	ErrNFTNotFound          = errors.New("NFT not found")
+	ErrMTAlreadyRegistered  = errors.New("multi-token already registered")
+	ErrMTNotFound           = errors.New("multi-token not found")
+	ErrMTInfoNotFound       = errors.New("multi-token info not found")
+	ErrNFTtokIDNotExists    = errors.New("NFT token ID does not exists")
+	ErrNFTNotMetadata       = errors.New("NFT must implement IGRC721CollectionMetadata")
+)

examples/gno.land/r/demo/tokenhub/getters.gno

@@ -0,0 +1,208 @@
+package tokenhub
+
+import (
+	"std"
+	"strings"
+
+	"gno.land/p/demo/grc/grc1155"
+	"gno.land/p/demo/grc/grc20"
+	"gno.land/p/demo/grc/grc721"
+	"gno.land/p/demo/ufmt"
+	"gno.land/r/demo/grc20reg"
+	"gno.land/r/demo/users"
+)
+
+// GetUserTokenBalances returns a string of all the grc20 tokens the user owns
+func GetUserTokenBalances(userNameOrAddress string) string {
+	return getTokenBalances(userNameOrAddress, false)
+}
+
+// GetUserTokenBalancesNonZero returns a string of all the grc20 tokens the user owns, but only the ones that have a balance greater than 0
+func GetUserTokenBalancesNonZero(userNameOrAddress string) string {
+	return getTokenBalances(userNameOrAddress, true)
+}
+
+// GetUserNFTBalances returns a string of all the NFTs the user owns
+func GetUserNFTBalances(userNameOrAddress string) string {
+	return getNFTBalances(userNameOrAddress)
+}
+
+// GetUserMultiTokenBalances returns a string of all the multi-tokens the user owns
+func GetUserMultiTokenBalances(userNameOrAddress string) string {
+	return getMultiTokenBalances(userNameOrAddress, false)
+}
+
+// GetUserMultiTokenBalancesNonZero returns a string of all the multi-tokens the user owns, but only the ones that have a balance greater than 0
+func GetUserMultiTokenBalancesNonZero(userNameOrAddress string) string {
+	return getMultiTokenBalances(userNameOrAddress, true)
+}
+
+// GetToken returns a token instance for a given key
+func GetToken(key string) *grc20.Token {
+	getter := grc20reg.Get(key)
+	return getter()
+}
+
+// MustGetToken returns a token instance for a given key, panics if the token is not found
+func MustGetToken(key string) *grc20.Token {
+	getter := grc20reg.MustGet(key)
+	if getter == nil {
+		panic("unknown token: " + key)
+	}
+	return getter()
+}
+
+// GetNFT returns an NFT instance for a given key
+func GetNFT(key string) grc721.IGRC721 {
+	nftGetter, ok := registeredNFTs.Get(key)
+	if !ok {
+		return nil
+	}
+	return (nftGetter.(grc721.NFTGetter))()
+}
+
+// MustGetNFT returns an NFT instance for a given key, panics if the NFT is not found
+func MustGetNFT(key string) grc721.IGRC721 {
+	nftGetter := GetNFT(key)
+	if nftGetter == nil {
+		panic("unknown NFT: " + key)
+	}
+	return nftGetter
+}
+
+// GetMultiToken returns a multi-token instance for a given key
+func GetMultiToken(key string) grc1155.IGRC1155 {
+	info, ok := registeredMTs.Get(key)
+	if !ok {
+		return nil
+	}
+	mt := info.(GRC1155TokenInfo).Collection
+	return mt()
+}
+
+// MustGetMultiToken returns a multi-token instance for a given key, panics if the multi-token is not found
+func MustGetMultiToken(key string) grc1155.IGRC1155 {
+	info := GetMultiToken(key)
+	if info == nil {
+		panic("unknown multi-token: " + key)
+	}
+	return info
+}
+
+// GetAllNFTs returns a string of all the NFTs registered
+func GetAllNFTs() string {
+	var out string
+	registeredNFTs.Iterate("", "", func(key string, value interface{}) bool {
+		out += ufmt.Sprintf("NFT:%s,", key)
+		return false
+	})
+	return out
+}
+
+// GetAllTokens returns a string of all the tokens registered
+func GetAllTokens() string {
+	var out string
+	grc20reg.GetRegistry().Iterate("", "", func(key string, value interface{}) bool {
+		out += "Token:" + key + ","
+		return false
+	})
+	return out
+}
+
+// GetAllMultiTokens returns a string of all the multi-tokens registered
+func GetAllMultiTokens() string {
+	var out string
+	registeredMTs.Iterate("", "", func(key string, value interface{}) bool {
+		out += "MultiToken:" + key + ","
+		return false
+	})
+	return out
+}
+
+// GetAllRegistered returns a string of all the registered tokens, NFTs and multi-tokens
+func GetAllRegistered() string {
+	return GetAllNFTs() + GetAllTokens() + GetAllMultiTokens()
+}
+
+// getNFTBalances returns a string of all the NFTs the user owns
+func getNFTBalances(input string) string {
+	addr := getAddressForUsername(input)
+	if !addr.IsValid() {
+		panic("invalid address or username: " + input)
+	}
+	var out string
+
+	registeredNFTs.Iterate("", "", func(key string, value interface{}) bool {
+		nftGetter := value.(grc721.NFTGetter)
+		nft := nftGetter()
+		key_parts := strings.Split(key, ".")
+		owner, err := nft.OwnerOf(grc721.TokenID(key_parts[len(key_parts)-1]))
+		if err == nil && addr == owner { // show only the nfts owner owns
+			out += "NFT:" + key + ","
+		}
+		return false
+	})
+
+	return out
+}
+
+// getTokenBalances returns a string of all the tokens the user owns
+func getTokenBalances(input string, nonZero bool) string {
+	addr := getAddressForUsername(input)
+	if !addr.IsValid() {
+		panic("invalid address or username: " + input)
+	}
+	var out string
+	grc20reg.GetRegistry().Iterate("", "", func(key string, value interface{}) bool {
+		tokenGetter := value.(grc20.TokenGetter)
+		token := tokenGetter()
+		balance := token.BalanceOf(addr)
+		if nonZero && balance > 0 {
+			out += ufmt.Sprintf("Token:%s:%d,", key, balance)
+		} else if !nonZero {
+			out += ufmt.Sprintf("Token:%s:%d,", key, balance)
+		}
+		return false
+	})
+
+	return out
+}
+
+// getMultiTokenBalances returns a string of all the multi-tokens the user owns
+func getMultiTokenBalances(input string, nonZero bool) string {
+	addr := getAddressForUsername(input)
+	if !addr.IsValid() {
+		panic("invalid address or username: " + input)
+	}
+	var out string
+
+	registeredMTs.Iterate("", "", func(key string, value interface{}) bool {
+		info := value.(GRC1155TokenInfo)
+		mt := info.Collection()
+		balance, err := mt.BalanceOf(addr, grc1155.TokenID(info.TokenID))
+		if err == nil {
+			if nonZero && balance > 0 {
+				out += ufmt.Sprintf("MultiToken:%s:%d,", key, balance)
+			} else if !nonZero {
+				out += ufmt.Sprintf("MultiToken:%s:%d,", key, balance)
+			}
+		}
+		return false
+	})
+
+	return out
+}
+
+// getAddressForUsername returns an address for a given username or address
+func getAddressForUsername(addrOrName string) std.Address {
+	addr := std.Address(addrOrName)
+	if addr.IsValid() {
+		return addr
+	}
+
+	if user := users.GetUserByName(addrOrName); user != nil {
+		return user.Address
+	}
+
+	return ""
+}

examples/gno.land/r/demo/tokenhub/gno.mod

@@ -0,0 +1 @@
+module gno.land/r/demo/tokenhub