feat(examples): hall of fame

examples/gno.land/p/demo/fqname/fqname.gno

@@ -4,7 +4,9 @@
 // package-level declaration.
 package fqname
 
-import "strings"
+import (
+	"strings"
+)
 
 // Parse splits a fully qualified identifier into its package path and name
 // components. It handles cases with and without slashes in the package path.
@@ -63,10 +65,26 @@ func RenderLink(pkgPath, slug string) string {
 		if slug != "" {
 			return "[" + pkgPath + "](" + pkgLink + ")." + slug
 		}
+
 		return "[" + pkgPath + "](" + pkgLink + ")"
 	}
+
 	if slug != "" {
 		return pkgPath + "." + slug
 	}
+
 	return pkgPath
 }
+
+// ShortPath returns the part of the pkgpath after the base domain.
+// sp := fqname.ShortPath("gno.land/r/gnoland/home")
+// fmt.Println(sp)
+// // Output: /r/gnoland/home
+func ShortPath(pkgPath string) string {
+	idx := strings.Index(pkgPath, "/")
+	if idx == -1 {
+		return ""
+	}
+
+	return pkgPath[idx:]
+}

examples/gno.land/p/demo/ownable/ownable.gno

@@ -37,8 +37,8 @@ func (o *Ownable) TransferOwnership(newOwner std.Address) error {
 	o.owner = newOwner
 	std.Emit(
 		OwnershipTransferEvent,
-		"from", string(prevOwner),
-		"to", string(newOwner),
+		"from", prevOwner.String(),
+		"to", newOwner.String(),
 	)
 
 	return nil
@@ -58,7 +58,7 @@ func (o *Ownable) DropOwnership() error {
 
 	std.Emit(
 		OwnershipTransferEvent,
-		"from", string(prevOwner),
+		"from", prevOwner.String(),
 		"to", "",
 	)
 

examples/gno.land/p/demo/pausable/pausable.gno

@@ -1,6 +1,10 @@
 package pausable
 
-import "gno.land/p/demo/ownable"
+import (
+	"std"
+
+	"gno.land/p/demo/ownable"
+)
 
 type Pausable struct {
 	*ownable.Ownable
@@ -35,6 +39,8 @@ func (p *Pausable) Pause() error {
 	}
 
 	p.paused = true
+	std.Emit("Paused", "account", p.Owner().String())
+
 	return nil
 }
 
@@ -45,5 +51,7 @@ func (p *Pausable) Unpause() error {
 	}
 
 	p.paused = false
+	std.Emit("Unpaused", "account", p.Owner().String())
+
 	return nil
 }

examples/gno.land/r/demo/hof/administration.gno

@@ -0,0 +1,24 @@
+package hof
+
+import "std"
+
+// Exposing the ownable & pausable APIs
+// Should not be needed as soon as MsgCall supports calling methods on exported variables
+
+func Pause() error {
+	return exhibition.Pause()
+}
+
+func Unpause() error {
+	return exhibition.Unpause()
+}
+
+func GetOwner() std.Address {
+	return owner.Owner()
+}
+
+func TransferOwnership(newOwner std.Address) {
+	if err := owner.TransferOwnership(newOwner); err != nil {
+		panic(err)
+	}
+}

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

@@ -0,0 +1,11 @@
+package hof
+
+import (
+	"errors"
+)
+
+var (
+	ErrNoSuchItem     = errors.New("hof: no such item exists")
+	ErrDoubleUpvote   = errors.New("hof: cannot upvote twice")
+	ErrDoubleDownvote = errors.New("hof: cannot downvote twice")
+)

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

@@ -0,0 +1,15 @@
+module gno.land/r/demo/hof
+
+require (
+	gno.land/p/demo/avl v0.0.0-latest
+	gno.land/p/demo/avl/pager v0.0.0-latest
+	gno.land/p/demo/fqname v0.0.0-latest
+	gno.land/p/demo/ownable v0.0.0-latest
+	gno.land/p/demo/pausable v0.0.0-latest
+	gno.land/p/demo/seqid v0.0.0-latest
+	gno.land/p/demo/testutils v0.0.0-latest
+	gno.land/p/demo/uassert v0.0.0-latest
+	gno.land/p/demo/ufmt v0.0.0-latest
+	gno.land/p/demo/urequire v0.0.0-latest
+	gno.land/p/moul/txlink v0.0.0-latest
+)

examples/gno.land/r/demo/hof/hof.gno

@@ -0,0 +1,132 @@
+// Package hof is the hall of fame realm.
+// The Hall of Fame is an exhibition that holds items. Users can add their realms to the Hall of Fame by
+// importing the Hall of Fame realm and calling hof.Register() from their init function.
+package hof
+
+import (
+	"std"
+
+	"gno.land/p/demo/avl"
+	"gno.land/p/demo/ownable"
+	"gno.land/p/demo/pausable"
+	"gno.land/p/demo/seqid"
+)
+
+var (
+	exhibition *Exhibition
+	owner      *ownable.Ownable
+)
+
+type (
+	Exhibition struct {
+		itemCounter seqid.ID
+		description string
+		items       *avl.Tree // pkgPath > Item
+		itemsSorted *avl.Tree // same data but sorted, storing pointers
+		*pausable.Pausable
+	}
+
+	Item struct {
+		id       seqid.ID
+		pkgpath  string
+		blockNum int64
+		upvote   *avl.Tree // std.Addr > struct{}{}
+		downvote *avl.Tree // std.Addr > struct{}{}
+	}
+)
+
+func init() {
+	exhibition = &Exhibition{
+		items:       avl.NewTree(),
+		itemsSorted: avl.NewTree(),
+	}
+
+	owner = ownable.NewWithAddress(std.Address("g125em6arxsnj49vx35f0n0z34putv5ty3376fg5"))
+	exhibition.Pausable = pausable.NewFromOwnable(owner)
+}
+
+// Register registers your realm to the Hall of Fame
+// Should be called from within code
+func Register() {
+	if exhibition.IsPaused() {
+		return
+	}
+
+	submission := std.PrevRealm()
+	pkgpath := submission.PkgPath()
+
+	// Must be called from code
+	if submission.IsUser() {
+		return
+	}
+
+	// Must not yet exist
+	if exhibition.items.Has(pkgpath) {
+		return
+	}
+
+	id := exhibition.itemCounter.Next()
+	i := &Item{
+		id:       id,
+		pkgpath:  pkgpath,
+		blockNum: std.GetHeight(),
+		upvote:   avl.NewTree(),
+		downvote: avl.NewTree(),
+	}
+
+	exhibition.items.Set(pkgpath, i)
+	exhibition.itemsSorted.Set(id.String(), i)
+
+	std.Emit("Registration")
+}
+
+func Upvote(pkgpath string) {
+	rawItem, ok := exhibition.items.Get(pkgpath)
+	if !ok {
+		panic(ErrNoSuchItem.Error())
+	}
+
+	item := rawItem.(*Item)
+	caller := std.PrevRealm().Addr().String()
+
+	if item.upvote.Has(caller) {
+		panic(ErrDoubleUpvote.Error())
+	}
+
+	item.upvote.Set(caller, struct{}{})
+}
+
+func Downvote(pkgpath string) {
+	rawItem, ok := exhibition.items.Get(pkgpath)
+	if !ok {
+		panic(ErrNoSuchItem.Error())
+	}
+
+	item := rawItem.(*Item)
+	caller := std.PrevRealm().Addr().String()
+
+	if item.downvote.Has(caller) {
+		panic(ErrDoubleDownvote.Error())
+	}
+
+	item.downvote.Set(caller, struct{}{})
+}
+
+func Delete(pkgpath string) {
+	if err := owner.CallerIsOwner(); err != nil {
+		panic(err)
+	}
+
+	i, ok := exhibition.items.Get(pkgpath)
+	if !ok {
+		panic(ErrNoSuchItem.Error())
+	}
+
+	if _, removed := exhibition.itemsSorted.Remove(i.(*Item).id.String()); !removed {
+		panic(ErrNoSuchItem.Error())
+	}
+
+	if _, removed := exhibition.items.Remove(pkgpath); !removed {
+		panic(ErrNoSuchItem.Error())
+	}
+}