feat(examples): implement r/events, p/authorizable

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

@@ -0,0 +1,70 @@
+// Package authorizable is an extension of p/demo/ownable;
+// It allows the user to instantiate an Authorizable struct, which extends
+// p/demo/ownable with a list of users that are authorized for something.
+// By using authorizable, you have a superuser (ownable), as well as another
+// authorization level, which can be used for adding moderators or similar to your realm.
+package authorizable
+
+import (
+	"std"
+
+	"gno.land/p/demo/ownable"
+)
+
+type Authorizable struct {
+	*ownable.Ownable
+	authorized map[std.Address]struct{}
+}
+
+func NewAuthorizable() *Authorizable {
+	a := &Authorizable{
+		ownable.NewOwnable(),
+		make(map[std.Address]struct{}),
+	}
+
+	// Add owner to auth list
+	a.authorized[a.Owner()] = struct{}{}
+	return a
+}
+
+func NewAuthorizableWithAddress(addr std.Address) *Authorizable {
+	a := &Authorizable{
+		ownable.NewOwnableWithAddress(addr),
+		make(map[std.Address]struct{}),
+	}
+
+	// Add owner to auth list
+	a.authorized[addr] = struct{}{}
+	return a
+}
+
+func (a *Authorizable) AddToAuthList(addr std.Address) error {
+	if err := a.CallerIsOwner(); err != nil {
+		return ErrNotInAuthList
+	}
+
+	if _, exists := a.authorized[addr]; exists {
+		return ErrAlreadyInList
+	}
+
+	a.authorized[addr] = struct{}{}
+	return nil
+}
+
+func (a Authorizable) OnAuthList() error {
+	caller := std.PrevRealm().Addr()
+
+	if _, exists := a.authorized[caller]; exists {
+		return nil
+	}
+
+	return ErrNotInAuthList
+}
+
+func (a Authorizable) AssertOnAuthList() {
+	caller := std.PrevRealm().Addr()
+
+	if _, exists := a.authorized[caller]; !exists {
+		panic(ErrNotInAuthList)
+	}
+}

examples/gno.land/p/demo/ownable/exts/authorizable/authorizable_test.gno

@@ -0,0 +1,50 @@
+package authorizable
+
+import (
+	"std"
+	"testing"
+
+	"gno.land/p/demo/testutils"
+)
+
+var (
+	alice   = testutils.TestAddress("alice")
+	bob     = testutils.TestAddress("bob")
+	charlie = testutils.TestAddress("charlie")
+)
+
+func TestNew(t *testing.T) {
+	std.TestSetRealm(std.NewUserRealm(alice))
+	std.TestSetOrigCaller(alice) // TODO(bug): should not be needed
+
+	a := NewAuthorizable()
+	got := a.Owner()
+
+	if alice != got {
+		t.Fatalf("Expected %s, got: %s", alice, got)
+	}
+}
+
+func TestNewWithAddress(t *testing.T) {
+	a := NewAuthorizableWithAddress(alice)
+
+	got := a.Owner()
+
+	if alice != got {
+		t.Fatalf("Expected %s, got: %s", alice, got)
+	}
+}
+
+//func TestAddToAuthList(t *testing.T) {
+//	a := NewAuthorizable()
+//
+//	if err := a.AddToAuthList(bob); err != nil {
+//		t.Fatalf("Expected AddToAuth to not error, but it did")
+//	}
+//
+//	std.TestSetRealm(std.NewUserRealm(bob))
+//
+//	if err := a.AddToAuthList(charlie); err == nil {
+//		t.Fatalf("Expected AddToAuth to error, did not happen")
+//	}
+//}

examples/gno.land/p/demo/ownable/exts/authorizable/errors.gno

@@ -0,0 +1,8 @@
+package authorizable
+
+import "errors"
+
+var (
+	ErrNotInAuthList = errors.New("unauthorized; caller is not in authorized list")
+	ErrAlreadyInList = errors.New("address is already in authorized list")
+)

examples/gno.land/p/demo/ownable/exts/authorizable/gno.mod

@@ -0,0 +1 @@
+module gno.land/p/demo/ownable/exts/authorizable

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

@@ -1,8 +1,6 @@
 package ownable
 
-import (
-	"std"
-)
+import "std"
 
 const OwnershipTransferEvent = "OwnershipTransfer"
 
@@ -12,14 +10,16 @@ type Ownable struct {
 	owner std.Address
 }
 
-func New() *Ownable {
+func NewOwnable() *Ownable {
 	return &Ownable{
 		owner: std.PrevRealm().Addr(),
 	}
 }
 
-func NewWithAddress(addr std.Address) *Ownable {
-	return &Ownable{owner: addr}
+func NewOwnableWithAddress(addr std.Address) *Ownable {
+	return &Ownable{
+		owner: addr,
+	}
 }
 
 // TransferOwnership transfers ownership of the Ownable struct to a new address
@@ -40,6 +40,7 @@ func (o *Ownable) TransferOwnership(newOwner std.Address) error {
 		"from", string(prevOwner),
 		"to", string(newOwner),
 	)
+
 	return nil
 }
 
@@ -64,6 +65,7 @@ func (o *Ownable) DropOwnership() error {
 	return nil
 }
 
+// Owner returns the owner address from Ownable
 func (o Ownable) Owner() std.Address {
 	return o.owner
 }
@@ -73,9 +75,11 @@ func (o Ownable) CallerIsOwner() error {
 	if std.PrevRealm().Addr() == o.owner {
 		return nil
 	}
+
 	return ErrUnauthorized
 }
 
+// AssertCallerIsOwner panics if the caller is not the owner
 func (o Ownable) AssertCallerIsOwner() {
 	if std.PrevRealm().Addr() != o.owner {
 		panic(ErrUnauthorized)

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

@@ -3,65 +3,67 @@ package ownable
 import (
 	"std"
 	"testing"
+
+	"gno.land/p/demo/testutils"
 )
 
 var (
-	firstCaller  = std.Address("g1l9aypkr8xfvs82zeux486ddzec88ty69lue9de")
-	secondCaller = std.Address("g127jydsh6cms3lrtdenydxsckh23a8d6emqcvfa")
+	alice = testutils.TestAddress("alice")
+	bob   = testutils.TestAddress("bob")
 )
 
 func TestNew(t *testing.T) {
-	std.TestSetRealm(std.NewUserRealm(firstCaller))
-	std.TestSetOrigCaller(firstCaller) // TODO(bug): should not be needed
+	std.TestSetRealm(std.NewUserRealm(alice))
+	std.TestSetOrigCaller(alice) // TODO(bug): should not be needed
 
-	o := New()
+	o := NewOwnable()
 	got := o.Owner()
-	if firstCaller != got {
-		t.Fatalf("Expected %s, got: %s", firstCaller, got)
+	if alice != got {
+		t.Fatalf("Expected %s, got: %s", alice, got)
 	}
 }
 
 func TestNewWithAddress(t *testing.T) {
-	o := NewWithAddress(firstCaller)
+	o := NewOwnableWithAddress(alice)
 
 	got := o.Owner()
-	if firstCaller != got {
-		t.Fatalf("Expected %s, got: %s", firstCaller, got)
+	if alice != got {
+		t.Fatalf("Expected %s, got: %s", alice, got)
 	}
 }
 
 func TestOwner(t *testing.T) {
-	std.TestSetRealm(std.NewUserRealm(firstCaller))
+	std.TestSetRealm(std.NewUserRealm(alice))
 
-	o := New()
-	expected := firstCaller
+	o := NewOwnable()
+	expected := alice
 	got := o.Owner()
 	if expected != got {
 		t.Fatalf("Expected %s, got: %s", expected, got)
 	}
 }
 
 func TestTransferOwnership(t *testing.T) {
-	std.TestSetRealm(std.NewUserRealm(firstCaller))
+	std.TestSetRealm(std.NewUserRealm(alice))
 
-	o := New()
+	o := NewOwnable()
 
-	err := o.TransferOwnership(secondCaller)
+	err := o.TransferOwnership(bob)
 	if err != nil {
 		t.Fatalf("TransferOwnership failed, %v", err)
 	}
 
 	got := o.Owner()
-	if secondCaller != got {
-		t.Fatalf("Expected: %s, got: %s", secondCaller, got)
+	if bob != got {
+		t.Fatalf("Expected: %s, got: %s", bob, got)
 	}
 }
 
 func TestCallerIsOwner(t *testing.T) {
-	std.TestSetRealm(std.NewUserRealm(firstCaller))
+	std.TestSetRealm(std.NewUserRealm(alice))
 
-	o := New()
-	unauthorizedCaller := secondCaller
+	o := NewOwnable()
+	unauthorizedCaller := bob
 
 	std.TestSetRealm(std.NewUserRealm(unauthorizedCaller))
 	std.TestSetOrigCaller(unauthorizedCaller) // TODO(bug): should not be needed
@@ -73,9 +75,9 @@ func TestCallerIsOwner(t *testing.T) {
 }
 
 func TestDropOwnership(t *testing.T) {
-	std.TestSetRealm(std.NewUserRealm(firstCaller))
+	std.TestSetRealm(std.NewUserRealm(alice))
 
-	o := New()
+	o := NewOwnable()
 
 	err := o.DropOwnership()
 	if err != nil {
@@ -91,15 +93,15 @@ func TestDropOwnership(t *testing.T) {
 // Errors
 
 func TestErrUnauthorized(t *testing.T) {
-	std.TestSetRealm(std.NewUserRealm(firstCaller))
-	std.TestSetOrigCaller(firstCaller) // TODO(bug): should not be needed
+	std.TestSetRealm(std.NewUserRealm(alice))
+	std.TestSetOrigCaller(alice) // TODO(bug): should not be needed
 
-	o := New()
+	o := NewOwnable()
 
-	std.TestSetRealm(std.NewUserRealm(secondCaller))
-	std.TestSetOrigCaller(secondCaller) // TODO(bug): should not be needed
+	std.TestSetRealm(std.NewUserRealm(bob))
+	std.TestSetOrigCaller(bob) // TODO(bug): should not be needed
 
-	err := o.TransferOwnership(firstCaller)
+	err := o.TransferOwnership(alice)
 	if err != ErrUnauthorized {
 		t.Fatalf("Should've been ErrUnauthorized, was %v", err)
 	}
@@ -111,9 +113,9 @@ func TestErrUnauthorized(t *testing.T) {
 }
 
 func TestErrInvalidAddress(t *testing.T) {
-	std.TestSetRealm(std.NewUserRealm(firstCaller))
+	std.TestSetRealm(std.NewUserRealm(alice))
 
-	o := New()
+	o := NewOwnable()
 
 	err := o.TransferOwnership("")
 	if err != ErrInvalidAddress {

examples/gno.land/r/gnoland/events/errors.gno

@@ -0,0 +1,9 @@
+package events
+
+import "errors"
+
+var (
+	errEmptyName        = errors.New("event name cannot be empty")
+	errInvalidStartTime = errors.New("event start time cannot be less than 0")
+	errDescTooLong      = errors.New("event description cannot be more than 80 chars")
+)