feat: add permissions & voting power per roles per features

gno/p/dao_core/dao_core.gno

@@ -157,7 +157,7 @@ func (d *daoCore) GetMembersJSON(start, end string, limit uint64, height int64)
 }
 
 func (d *daoCore) VotingPowerAtHeight(address std.Address, height int64) uint64 {
-	return d.VotingModule().VotingPowerAtHeight(address, height)
+	return d.VotingModule().VotingPowerAtHeight(address, height, "")
 }
 
 func (d *daoCore) ActiveProposalModuleCount() int {

gno/p/dao_interfaces/modules.gno

@@ -18,7 +18,7 @@ type IVotingModule interface {
 	ConfigJSON() string
 	GetMembersJSON(start, end string, limit uint64, height int64) string
 	Render(path string) string
-	VotingPowerAtHeight(address std.Address, height int64) (power uint64)
+	VotingPowerAtHeight(address std.Address, height int64, feature string) (power uint64)
 	TotalPowerAtHeight(height int64) uint64
 }
 
@@ -44,7 +44,7 @@ type IRolesModule interface {
 	Render(path string) string
 	GetMemberRoles(address std.Address) []string
 	HasRole(address std.Address, role string) bool
-	NewRole(roleName string)
+	NewRole(roleName string, permissionsJSON string)
 	DeleteRole(roleName string)
 	GrantRole(address std.Address, role string)
 	RevokeRole(address std.Address, role string)

gno/p/dao_proposal_single/dao_proposal_single.gno

@@ -331,7 +331,7 @@ func (d *DAOProposalSingle) VoteJSON(proposalID int, voteJSON string) {
 		panic("proposal is expired")
 	}
 
-	votePower := d.core.VotingModule().VotingPowerAtHeight(voter, proposal.StartHeight)
+	votePower := d.core.VotingModule().VotingPowerAtHeight(voter, proposal.StartHeight, "")
 	if votePower == 0 {
 		panic("not registered")
 	}

gno/p/dao_roles_group/gno.mod

@@ -5,4 +5,5 @@ require (
 	gno.land/p/teritori/dao_interfaces v0.0.0-latest
 	gno.land/p/teritori/jsonutil v0.0.0-latest
 	gno.land/p/teritori/role_manager v0.0.0-latest
+	gno.land/p/demo/avl v0.0.0-latest
 )

gno/p/dao_roles_group/roles_group.gno

@@ -3,6 +3,7 @@ package dao_roles_group
 import (
 	"std"
 
+	"gno.land/p/demo/avl"
 	"gno.land/p/demo/json"
 	dao_interfaces "gno.land/p/teritori/dao_interfaces"
 	"gno.land/p/teritori/jsonutil"
@@ -12,7 +13,13 @@ import (
 type RolesGroup struct {
 	dao_interfaces.IRolesModule
 
-	rm *role_manager.RoleManager
+	rm               *role_manager.RoleManager
+	permissionsPower *avl.Tree // roles -> PermissionPower
+}
+
+type PermissionPower struct {
+	Permission string
+	Power      uint64
 }
 
 func NewRolesGroup() *RolesGroup {
@@ -42,7 +49,12 @@ func (r *RolesGroup) HasRole(address std.Address, role string) bool {
 	return r.rm.HasRole(address, role)
 }
 
-func (r *RolesGroup) NewRole(roleName string) {
+func (r *RolesGroup) NewRole(roleName string, permissionsJSON string) {
+	// TODO:
+	// 1. Parse permissionsJSON
+	// 2. Create a new role with the parsed permissions
+	// 3. Create a new array of PermissionPower and store it in r.permissionsPower
+	_ = permissionsJSON
 	r.rm.CreateNewRole(roleName, []string{})
 }
 
@@ -61,3 +73,7 @@ func (r *RolesGroup) RevokeRole(address std.Address, role string) {
 func (r *RolesGroup) GetMemberRoles(address std.Address) []string {
 	return r.rm.GetUserRoles(address)
 }
+
+// TODO:
+// 1. Add GetUserPower(address std.Address, permission string) uint64
+// 2. Add SetRolePower(role string, permission string, power uint64)

gno/p/dao_roles_voting_group/gno.mod

@@ -0,0 +1,8 @@
+module gno.land/p/teritori/dao_roles_voting_group
+
+require (
+	gno.land/p/demo/json v0.0.0-latest
+	gno.land/p/teritori/dao_interfaces v0.0.0-latest
+	gno.land/p/teritori/havl v0.0.0-latest
+	gno.land/p/teritori/jsonutil v0.0.0-latest
+)

gno/p/dao_roles_voting_group/messages.gno

@@ -0,0 +1,62 @@
+package dao_roles_voting_group
+
+import (
+	"gno.land/p/demo/json"
+	"gno.land/p/teritori/dao_interfaces"
+)
+
+const updateMembersType = "gno.land/p/teritori/dao_voting_group.UpdateMembers"
+
+type UpdateMembersExecutableMessage []Member
+
+var _ dao_interfaces.ExecutableMessage = (*UpdateMembersExecutableMessage)(nil)
+
+func (m *UpdateMembersExecutableMessage) FromJSON(ast *json.Node) {
+	changes := ast.MustArray()
+	*m = make([]Member, len(changes))
+	for i, change := range changes {
+		(*m)[i].FromJSON(change)
+	}
+}
+
+func (m *UpdateMembersExecutableMessage) ToJSON() *json.Node {
+	changes := make([]*json.Node, len(*m))
+	for i, change := range *m {
+		changes[i] = change.ToJSON()
+	}
+
+	return json.ArrayNode("", changes)
+}
+
+func (m *UpdateMembersExecutableMessage) String() string {
+	return m.ToJSON().String()
+}
+
+func (m *UpdateMembersExecutableMessage) Type() string {
+	return updateMembersType
+}
+
+type updateMembersHandler struct {
+	vg *RolesVotingGroup
+}
+
+var _ dao_interfaces.MessageHandler = (*updateMembersHandler)(nil)
+
+func (h *updateMembersHandler) Type() string {
+	return updateMembersType
+}
+
+func (h *updateMembersHandler) Execute(msg dao_interfaces.ExecutableMessage) {
+	m, ok := msg.(*UpdateMembersExecutableMessage)
+	if !ok {
+		panic("unexpected message type")
+	}
+
+	for _, change := range *m {
+		h.vg.SetMemberPower(change.Address, change.Power)
+	}
+}
+
+func (h *updateMembersHandler) Instantiate() dao_interfaces.ExecutableMessage {
+	return &UpdateMembersExecutableMessage{}
+}

gno/p/dao_roles_voting_group/roles_voting_group.gno

@@ -0,0 +1,186 @@
+package dao_roles_voting_group
+
+import (
+	"std"
+	"strconv"
+	"strings"
+
+	"gno.land/p/demo/json"
+	dao_interfaces "gno.land/p/teritori/dao_interfaces"
+	"gno.land/p/teritori/havl"
+	"gno.land/p/teritori/jsonutil"
+)
+
+type Member struct {
+	Address std.Address
+	Power   uint64
+}
+
+func (m Member) ToJSON() *json.Node {
+	return json.ObjectNode("", map[string]*json.Node{
+		"address": jsonutil.AddressNode(m.Address),
+		"power":   jsonutil.Uint64Node(m.Power),
+	})
+}
+
+func (m *Member) FromJSON(ast *json.Node) {
+	obj := ast.MustObject()
+	m.Address = jsonutil.MustAddress(obj["address"])
+	m.Power = jsonutil.MustUint64(obj["power"])
+}
+
+type RolesVotingGroup struct {
+	dao_interfaces.IVotingModule
+
+	powerByAddr *havl.Tree // std.Address -> uint64
+	totalPower  *havl.Tree // "" -> uint64
+	memberCount *havl.Tree // "" -> uint32
+}
+
+func NewRolesVotingGroup() *RolesVotingGroup {
+	return &RolesVotingGroup{
+		powerByAddr: havl.NewTree(),
+		totalPower:  havl.NewTree(),
+		memberCount: havl.NewTree(),
+	}
+}
+
+func (v *RolesVotingGroup) Info() dao_interfaces.ModuleInfo {
+	return dao_interfaces.ModuleInfo{
+		Kind:    "gno.land/p/teritori/dao_voting_group",
+		Version: "0.1.0",
+	}
+}
+
+func (v *RolesVotingGroup) ConfigJSON() string {
+	return json.ObjectNode("", map[string]*json.Node{
+		"totalPower": jsonutil.Uint64Node(v.TotalPowerAtHeight(havl.Latest)),
+		"members":    jsonutil.Uint32Node(v.MemberCount(havl.Latest)),
+	}).String()
+}
+
+func (v *RolesVotingGroup) GetMembersJSON(start, end string, limit uint64, height int64) string {
+	members := v.GetMembers(start, end, limit, height)
+	membersJSON := make([]*json.Node, len(members))
+	for i, m := range members {
+		membersJSON[i] = m.ToJSON()
+	}
+	return json.ArrayNode("", membersJSON).String()
+}
+
+func (v *RolesVotingGroup) VotingPowerAtHeight(addr std.Address, height int64, feature string) uint64 {
+	_ = feature
+	// TODO:
+	// 1. Ask dao roles group module to see if the user have a role that give him more power on the feature
+	// 2. If not, return the power of the user
+	p, ok := v.powerByAddr.Get(addr.String(), height)
+	if !ok {
+		return 0
+	}
+
+	return p.(uint64)
+}
+
+func (v *RolesVotingGroup) TotalPowerAtHeight(height int64) uint64 {
+	p, ok := v.totalPower.Get("", height)
+	if !ok {
+		return 0
+	}
+
+	return p.(uint64)
+}
+
+func (g *RolesVotingGroup) SetMemberPower(addr std.Address, power uint64) {
+	if power == 0 {
+		g.RemoveMember(addr)
+		return
+	}
+
+	iprevious, ok := g.powerByAddr.Get(addr.String(), havl.Latest)
+	if !ok {
+		g.memberCount.Set("", g.MemberCount(havl.Latest)+1)
+	}
+
+	previous := uint64(0)
+	if ok {
+		previous = iprevious.(uint64)
+	}
+
+	if power == previous {
+		return
+	}
+
+	g.powerByAddr.Set(addr.String(), power)
+
+	ipreviousTotal, ok := g.totalPower.Get("", havl.Latest)
+	previousTotal := uint64(0)
+	if ok {
+		previousTotal = ipreviousTotal.(uint64)
+	}
+
+	g.totalPower.Set("", (previousTotal+power)-previous)
+}
+
+func (g *RolesVotingGroup) RemoveMember(addr std.Address) (uint64, bool) {
+	p, removed := g.powerByAddr.Remove(addr.String())
+	if !removed {
+		return 0, false
+	}
+
+	g.memberCount.Set("", g.MemberCount(havl.Latest)-1)
+	power := p.(uint64)
+	g.totalPower.Set("", g.TotalPowerAtHeight(havl.Latest)-power)
+	return power, true
+}
+
+func (g *RolesVotingGroup) UpdateMembersHandler() dao_interfaces.MessageHandler {
+	return &updateMembersHandler{vg: g}
+}
+
+func (g *RolesVotingGroup) MemberCount(height int64) uint32 {
+	val, ok := g.memberCount.Get("", height)
+	if !ok {
+		return 0
+	}
+
+	return val.(uint32)
+}
+
+func (g *RolesVotingGroup) GetMembers(start, end string, limit uint64, height int64) []Member {
+	var members []Member
+	g.powerByAddr.Iterate(start, end, height, func(k string, v interface{}) bool {
+		if limit > 0 && uint64(len(members)) >= limit {
+			return true
+		}
+
+		members = append(members, Member{
+			Address: std.Address(k),
+			Power:   v.(uint64),
+		})
+
+		return false
+	})
+	return members
+}
+
+func (v *RolesVotingGroup) Render(path string) string {
+	sb := strings.Builder{}
+	sb.WriteString("Member count: ")
+	sb.WriteString(strconv.FormatUint(uint64(v.MemberCount(havl.Latest)), 10))
+	sb.WriteString("\n\n")
+	sb.WriteString("Total power: ")
+	sb.WriteString(strconv.FormatUint(v.TotalPowerAtHeight(havl.Latest), 10))
+	sb.WriteString("\n\n")
+	sb.WriteString("Members:\n")
+	v.powerByAddr.Iterate("", "", havl.Latest, func(k string, v interface{}) bool {
+		sb.WriteString("- ")
+		sb.WriteString(k)
+		sb.WriteString(": ")
+		sb.WriteString(strconv.FormatUint(v.(uint64), 10))
+		sb.WriteRune('\n')
+		return false
+	})
+
+	sb.WriteRune('\n')
+	return sb.String()
+}

gno/p/dao_roles_voting_group/roles_voting_group_test.gno

@@ -0,0 +1,29 @@
+package dao_roles_voting_group
+
+import (
+	"testing"
+
+	dao_interfaces "gno.land/p/teritori/dao_interfaces"
+)
+
+func TestRolesVotingGroup(t *testing.T) {
+	rv := NewRolesVotingGroup()
+	var i dao_interfaces.IVotingModule
+	i = rv
+
+	{
+		got := i.TotalPowerAtHeight(0)
+		expected := uint64(0)
+		if got != expected {
+			t.Fatalf("expected %s, got %s.", expected, got)
+		}
+	}
+
+	{
+		conf := rv.ConfigJSON()
+		expected := `{"totalPower":"0","members":"0"}`
+		if conf != expected {
+			t.Fatalf("expected %s, got %s.", expected, conf)
+		}
+	}
+}

gno/p/dao_voting_group/voting_group.gno

@@ -68,7 +68,8 @@ func (v *VotingGroup) GetMembersJSON(start, end string, limit uint64, height int
 	return json.ArrayNode("", membersJSON).String()
 }
 
-func (v *VotingGroup) VotingPowerAtHeight(addr std.Address, height int64) uint64 {
+func (v *VotingGroup) VotingPowerAtHeight(addr std.Address, height int64, feature string) uint64 {
+	_ = feature
 	p, ok := v.powerByAddr.Get(addr.String(), height)
 	if !ok {
 		return 0

gno/p/role_manager/role_manager.gno

@@ -163,7 +163,7 @@ func (rm *RoleManager) HasRole(user std.Address, roleName string) bool {
 	return userRoles.Has(roleName)
 }
 
-func (rm *RoleManager) IsRoleExist(roleName string) bool {
+func (rm *RoleManager) RoleExists(roleName string) bool {
 	return rm.roles.Has(roleName)
 }