feat: add permissions & voting power per roles per features (#1443)

Signed-off-by: Norman Meier <norman@samourai.coop>
Co-authored-by: n0izn0iz <n0izn0iz@users.noreply.github.com>
Co-authored-by: Norman Meier <norman@samourai.coop>

Author: 3 people

gno/p/dao_core/dao_core.gno

@@ -48,16 +48,17 @@ func NewDAOCore(
 		proposalModules:           make([]dao_interfaces.ActivableProposalModule, len(proposalModulesFactories)),
 	}
 
-	core.votingModule = votingModuleFactory(core)
-	if core.votingModule == nil {
-		panic("voting module factory returned nil")
-	}
-
+	// important to keep this order since voting module might depend on roles module
 	core.rolesModule = rolesModuleFactory(core)
 	if core.rolesModule == nil {
 		panic("roles module factory returned nil")
 	}
 
+	core.votingModule = votingModuleFactory(core)
+	if core.votingModule == nil {
+		panic("voting module factory returned nil")
+	}
+
 	for i, modFactory := range proposalModulesFactories {
 		mod := modFactory(core)
 		if mod == nil {
@@ -157,7 +158,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, []string{})
 }
 
 func (d *daoCore) ActiveProposalModuleCount() int {

gno/p/dao_core/dao_core_test.gno

@@ -38,7 +38,7 @@ func (vm *votingModule) Render(path string) string {
 	return "# Test Voting Module"
 }
 
-func (vm *votingModule) VotingPowerAtHeight(address std.Address, height int64) uint64 {
+func (vm *votingModule) VotingPowerAtHeight(address std.Address, height int64, resources []string) uint64 {
 	return 0
 }
 
@@ -73,7 +73,7 @@ func (rm *rolesModule) HasRole(address std.Address, role string) bool {
 	return false
 }
 
-func (rm *rolesModule) NewRole(roleName string) {
+func (rm *rolesModule) NewRoleJSON(roleName, resourcesJSON string) {
 	panic("not implemented")
 }
 
@@ -93,6 +93,10 @@ func (rm *rolesModule) GetMemberRoles(address std.Address) []string {
 	return []string{}
 }
 
+func (rm *rolesModule) GetMemberResourceVPower(address std.Address, resource string) uint64 {
+	return 0
+}
+
 type proposalModule struct {
 	core dao_interfaces.IDAOCore
 }

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, resources []string) (power uint64)
 	TotalPowerAtHeight(height int64) uint64
 }
 
@@ -43,8 +43,9 @@ type IRolesModule interface {
 	ConfigJSON() string
 	Render(path string) string
 	GetMemberRoles(address std.Address) []string
+	GetMemberResourceVPower(address std.Address, resource string) uint64
 	HasRole(address std.Address, role string) bool
-	NewRole(roleName string)
+	NewRoleJSON(roleName, resourcesJSON 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,12 @@ func (d *DAOProposalSingle) VoteJSON(proposalID int, voteJSON string) {
 		panic("proposal is expired")
 	}
 
-	votePower := d.core.VotingModule().VotingPowerAtHeight(voter, proposal.StartHeight)
+	resources := make([]string, len(proposal.Messages))
+	for i, m := range proposal.Messages {
+		resources[i] = m.Type()
+	}
+
+	votePower := d.core.VotingModule().VotingPowerAtHeight(voter, proposal.StartHeight, resources)
 	if votePower == 0 {
 		panic("not registered")
 	}

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,12 +13,19 @@ import (
 type RolesGroup struct {
 	dao_interfaces.IRolesModule
 
-	rm *role_manager.RoleManager
+	rm              *role_manager.RoleManager
+	resourcesVPower *avl.Tree // roles -> ResourceVPower[]
+}
+
+type ResourceVPower struct {
+	Resource string
+	Power    uint64
 }
 
 func NewRolesGroup() *RolesGroup {
 	return &RolesGroup{
-		rm: role_manager.NewWithAddress(std.PrevRealm().Addr()),
+		rm:              role_manager.NewWithAddress(std.PrevRealm().Addr()),
+		resourcesVPower: avl.NewTree(),
 	}
 }
 
@@ -42,8 +50,25 @@ 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) NewRoleJSON(roleName, resourcesJSON string) {
+	node := json.Must(json.Unmarshal([]byte(resourcesJSON)))
+	arr := node.MustArray()
+	resources := make([]ResourceVPower, len(arr))
+	for i, n := range arr {
+		node := n.MustObject()
+		resources[i] = ResourceVPower{
+			Resource: node["resource"].MustString(),
+			Power:    jsonutil.MustUint64(node["power"]),
+		}
+	}
+	r.NewRole(roleName, resources)
+}
+
+func (r *RolesGroup) NewRole(roleName string, resources []ResourceVPower) {
 	r.rm.CreateNewRole(roleName, []string{})
+	if len(resources) > 0 {
+		r.resourcesVPower.Set(roleName, resources)
+	}
 }
 
 func (r *RolesGroup) DeleteRole(roleName string) {
@@ -61,3 +86,21 @@ func (r *RolesGroup) RevokeRole(address std.Address, role string) {
 func (r *RolesGroup) GetMemberRoles(address std.Address) []string {
 	return r.rm.GetUserRoles(address)
 }
+
+func (r *RolesGroup) GetMemberResourceVPower(address std.Address, resource string) uint64 {
+	roles := r.rm.GetUserRoles(address)
+	power := uint64(0)
+	for _, role := range roles {
+		resourcesRaw, exists := r.resourcesVPower.Get(role)
+		if !exists {
+			continue
+		}
+		resources := resourcesRaw.([]ResourceVPower)
+		for _, r := range resources {
+			if r.Resource == resource && r.Power > power {
+				power = r.Power
+			}
+		}
+	}
+	return power
+}

gno/p/dao_roles_voting_group/gno.mod

@@ -0,0 +1 @@
+module gno.land/p/teritori/dao_roles_voting_group

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{}
+}