Playground
gnomod.toml
module = "gno.land/r/gov/dao/memberstore/v0" gno = "0.9" [addpkg] creator = "g1g73v2anukg4ej7axwqpthsatzrxjsh0wk797da"
memberstore.gno
package memberstore
import (
"strings"
"gno.land/p/moul/md/v0"
"gno.land/p/nt/bptree/v0"
"gno.land/p/nt/mux/v0"
"gno.land/p/nt/svg/v0"
"gno.land/p/nt/ufmt/v0"
"gno.land/r/gov/dao"
)
var (
members MembersByTier
tiers TiersByName // private to prevent external modification
router *mux.Router
)
const (
T1 = "T1"
T2 = "T2"
T3 = "T3"
)
func init() {
members = NewMembersByTier()
tiers = TiersByName{bptree.NewBPTree32()}
tiers.Set(T1, Tier{
InvitationPoints: 3,
MinSize: func(membersByTier MembersByTier, tiersByName TiersByName) int {
return 70
},
MaxSize: func(membersByTier MembersByTier, tiersByName TiersByName) int {
return 0
},
BasePower: 3,
PowerHandler: func(membersByTier MembersByTier, tiersByName TiersByName) float64 {
return 3
},
})
tiers.Set(T2, Tier{
InvitationPoints: 2,
MaxSize: func(membersByTier MembersByTier, tiersByName TiersByName) int {
return membersByTier.GetTierSize(T1) * 2
},
MinSize: func(membersByTier MembersByTier, tiersByName TiersByName) int {
return membersByTier.GetTierSize(T1) / 4
},
BasePower: 2,
PowerHandler: func(membersByTier MembersByTier, tiersByName TiersByName) float64 {
t1ms := float64(membersByTier.GetTierSize(T1))
t1, _ := tiersByName.GetTier(T1)
t2ms := float64(membersByTier.GetTierSize(T2))
t2, _ := tiersByName.GetTier(T2)
t1p := t1.BasePower * t1ms
t2p := t2.BasePower * t2ms
// capped to 2/3 of tier 1
t1ptreshold := t1p * (2.0 / 3.0)
if t2p > t1ptreshold {
return t1ptreshold / t2ms
}
return t2.BasePower
},
})
tiers.Set(T3, Tier{
InvitationPoints: 1,
MaxSize: func(membersByTier MembersByTier, tiersByName TiersByName) int {
return 0
},
MinSize: func(membersByTier MembersByTier, tiersByName TiersByName) int {
return 0
},
BasePower: 1,
PowerHandler: func(membersByTier MembersByTier, tiersByName TiersByName) float64 {
t1ms := float64(membersByTier.GetTierSize(T1))
t1, _ := tiersByName.GetTier(T1)
t3ms := float64(membersByTier.GetTierSize(T3))
t3, _ := tiersByName.GetTier(T3)
t1p := t1.BasePower * t1ms
t3p := t3.BasePower * t3ms
// capped to 1/3 of tier 1
t1ptreshold := t1p * (1.0 / 3.0)
if t3p > t1ptreshold {
return t1ptreshold / t3ms
}
return t3.BasePower
},
})
initRouter()
}
// initRouter initializes the router for the memberstore.
func initRouter() {
router = mux.NewRouter()
router.HandleFunc("", renderHome)
router.HandleFunc("members", renderMembers)
router.NotFoundHandler = renderNotFound
}
// renderHome displays the tiers data (Number of members and powers) and tiers charts.
func renderHome(res *mux.ResponseWriter, req *mux.Request) {
var sb strings.Builder
sb.WriteString(md.Link("> Go to Members list <", "/r/gov/dao/memberstore/v0:members") + "\n")
members.Iterate("", "", func(tn string, ti interface{}) bool {
tree, ok := ti.(*bptree.BPTree)
if !ok {
return false
}
tier, ok := tiers.GetTier(tn)
if !ok {
return false
}
tp := (tier.PowerHandler(members, tiers) * float64(members.GetTierSize(tn)))
sb.WriteString(ufmt.Sprintf("- %v Tier %v contains %v members with power: %v\n", tierColoredChip(tn), tn, tree.Size(), tp))
return false
})
sb.WriteString("\n" + RenderCharts(members))
res.Write(sb.String())
}
// renderMembers displays the members list.
func renderMembers(res *mux.ResponseWriter, req *mux.Request) {
path := strings.Replace(req.RawPath, "members", "", 1) // We have to clean the path
res.Write(RenderMembers(path, members))
}
func renderNotFound(res *mux.ResponseWriter, req *mux.Request) {
res.Write("# 404\n\nThat page was not found. Would you like to [**go home**?](/r/gov/dao/memberstore/v0)")
}
func tierColor(tn string) string {
switch tn {
case T1:
return "#329175"
case T2:
return "#21577A"
case T3:
return "#F3D3BC"
default:
return "#FFF"
}
}
// tierColoredChip returns a colored chip svg for the given tier name.
func tierColoredChip(tn string) string {
canvas := svg.NewCanvas(16, 16)
canvas.Append(svg.NewRectangle(0, 0, 16, 16, tierColor(tn)))
return canvas.Render(tn + " colored chip")
}
func Render(path string) string {
var sb strings.Builder
sb.WriteString(md.H1("Memberstore Govdao v0"))
sb.WriteString(router.Render(path))
return sb.String()
}
// Get gets the Members store.
//
// rlm is the cur of an in-scope crossing frame, threaded by the caller.
// The IsCurrent() check rejects stale or stashed realm values — a
// malicious realm cannot replay an old cur to claim allowed-DAO
// identity. After the check, rlm.PkgPath() is the authentic immediate
// caller's realm.
func Get(_ int, rlm realm) MembersByTier {
if !rlm.IsCurrent() {
panic("memberstore.Get: rlm is not the caller's live cur (stale capture or sibling frame)")
}
currealm := rlm.PkgPath()
if !dao.InAllowedDAOs(currealm) {
panic("this Realm is not allowed to get the Members data: " + currealm)
}
return members
}
// GetTier returns a tier by name. This is a read-only accessor.
func GetTier(name string) (Tier, bool) {
return tiers.GetTier(name)
}
// IterateTiers iterates over all tiers in order. This is a read-only accessor.
// The callback receives the tier name and tier data.
// Return true from the callback to stop iteration.
func IterateTiers(fn func(name string, tier Tier) bool) {
tiers.Iterate("", "", func(name string, value interface{}) bool {
tier, ok := value.(Tier)
if !ok {
return false
}
return fn(name, tier)
})
}
// setTiers replaces the tiers configuration.
// This is internal and should only be called via governance proposal execution.
func setTiers(newTiers TiersByName) {
tiers = newTiers
}
// GetTierPower calculates the effective voting power for a tier given the current members.
// This is a safe accessor that uses the internal tiers configuration.
func GetTierPower(tierName string, members MembersByTier) float64 {
tier, ok := tiers.GetTier(tierName)
if !ok {
return 0
}
return tier.PowerHandler(members, tiers)
}
memberstore_test.gno
package memberstore
import (
"strconv"
"testing"
"gno.land/p/nt/urequire/v0"
)
func TestPower(t *testing.T) {
ms := NewMembersByTier()
addMembers(ms, 100, T1)
addMembers(ms, 100, T2)
addMembers(ms, 100, T3)
tiers.Iterate("", "", func(key string, value interface{}) bool {
po := value.(Tier).PowerHandler(ms, tiers)
if key == T1 && po != 3.0 {
t.Fatal("wrong value for T1")
}
if key == T2 && po != 2.0 {
t.Fatal("wrong value for T2")
}
if key == T3 && po != 1.0 {
t.Fatal("wrong value for T3")
}
return false
})
ms = NewMembersByTier()
addMembers(ms, 100, T1)
addMembers(ms, 50, T2)
addMembers(ms, 10, T3)
tiers.Iterate("", "", func(key string, value interface{}) bool {
po := value.(Tier).PowerHandler(ms, tiers)
if key == T1 && po != 3.0 {
t.Fatal("wrong value for T1")
}
if key == T2 && po != 2.0 {
t.Fatal("wrong value for T2")
}
if key == T3 && po != 1.0 {
t.Fatal("wrong value for T3")
}
return false
})
ms = NewMembersByTier()
addMembers(ms, 100, T1)
addMembers(ms, 200, T2)
addMembers(ms, 100, T3)
tiers.Iterate("", "", func(key string, value interface{}) bool {
po := value.(Tier).PowerHandler(ms, tiers)
if key == T1 && po != 3.0 {
t.Fatal("wrong value for T1")
}
if key == T2 && po != 1.0 {
t.Fatal("wrong value for T2")
}
if key == T3 && po != 1.0 {
t.Fatal("wrong value for T3")
}
return false
})
ms = NewMembersByTier()
addMembers(ms, 100, T1)
addMembers(ms, 200, T2)
addMembers(ms, 1000, T3)
tiers.Iterate("", "", func(key string, value interface{}) bool {
po := value.(Tier).PowerHandler(ms, tiers)
if key == T1 && po != 3.0 {
t.Fatal("wrong value for T1")
}
if key == T2 && po != 1.0 {
t.Fatal("wrong value for T2")
}
if key == T3 && po != 0.1 {
t.Fatal("wrong value for T3")
}
return false
})
}
func TestCreateMembers(t *testing.T) {
ms := NewMembersByTier()
println("adding members...")
addMembers(ms, 10, "T1")
println("added T1")
addMembers(ms, 100, "T2")
println("added T2")
addMembers(ms, 1000, "T3")
println("added T3")
m, tier := ms.GetMember(address("11T3"))
urequire.Equal(t, "T3", tier)
m, tier = ms.GetMember(address("2000T1"))
urequire.Equal(t, "", tier)
if m != nil {
t.Fatal("member must be nil if not found")
}
tier = ms.RemoveMember(address("1T1"))
urequire.Equal(t, "T1", tier)
}
func addMembers(ms MembersByTier, c int, tier string) {
// mt := avl.NewTree() XXX
ms.SetTier(tier)
for i := 0; i < c; i++ {
addr := address(strconv.Itoa(i) + tier)
if err := ms.SetMember(tier, addr, &Member{}); err != nil {
panic(err.Error())
}
}
}
func TestRenderMembersToleratesMalformedPath(t *testing.T) {
ms := NewMembersByTier()
addMembers(ms, 3, T1)
// A control byte makes url.Parse reject the path; RenderMembers must
// degrade to the first page rather than nil-deref / panic (Render is an
// unauthenticated, read-only path).
out := RenderMembers("?\x01", ms)
urequire.True(t, len(out) > 0, "malformed path must render, not panic")
}
prop_requests.gno
package memberstore
import (
"chain/runtime/unsafe"
"gno.land/p/nt/bptree/v0"
"gno.land/r/gov/dao"
)
func NewChangeTiersRequest(cur realm, tiers map[string]Tier) dao.ProposalRequest {
if len(tiers) == 0 {
panic("tiers list is empty")
}
member, _ := Get(0, cur).GetMember(unsafe.OriginCaller())
if member == nil {
panic("proposer is not a member")
}
newTiers := TiersByName{bptree.NewBPTree32()}
for name, tier := range tiers {
newTiers.Set(name, tier)
}
callback := func(cur realm) error {
setTiers(newTiers)
return nil
}
e := dao.NewSimpleExecutor(0, cur, callback, "New set of tiers proposed.")
return dao.NewProposalRequest("Change Tiers Proposal", "This proposal is looking to change the existing Tiers in memberstore", e)
}
rendercharts.gno
package memberstore
import (
"strings"
"gno.land/p/samcrew/piechart/v0"
)
// RenderCharts generates two pie charts for member tiers:
// 1) distribution of member counts per tier
// 2) distribution of power per tier
func RenderCharts(members MembersByTier) string {
var sb strings.Builder
tierNames := []string{T1, T2, T3}
pieSlicesTs := make([]piechart.PieSlice, 0, len(tierNames))
pieSlicesTp := make([]piechart.PieSlice, 0, len(tierNames))
for _, tn := range tierNames {
tier, ok := tiers.GetTier(tn)
if !ok {
return ""
}
ts := float64(members.GetTierSize(tn))
tp := tier.PowerHandler(members, tiers) * ts
pieSlicesTs = append(pieSlicesTs, piechart.PieSlice{
Value: ts,
Color: tierColor(tn),
Label: tn,
})
pieSlicesTp = append(pieSlicesTp, piechart.PieSlice{
Value: tp,
Color: tierColor(tn),
Label: tn,
})
}
// Render pie charts for members count and power distribution
resultPieChartTs := piechart.Render(pieSlicesTs, "Members distribution:")
resultPieChartTp := piechart.Render(pieSlicesTp, "Power distribution:")
sb.WriteString(resultPieChartTs + "\n")
sb.WriteString(resultPieChartTp + "\n")
return sb.String()
}
rendermembers.gno
package memberstore
import (
"net/url"
"strings"
"gno.land/p/moul/md/v0"
"gno.land/p/nt/bptree/pager/v0"
"gno.land/p/nt/bptree/v0"
"gno.land/p/nt/ufmt/v0"
"gno.land/p/samcrew/tablesort/v0"
"gno.land/p/samcrew/urlfilter/v0"
)
// RenderMembers returns the members list with tier filters and pagination.
func RenderMembers(path string, members MembersByTier) string {
u, err := url.Parse(path)
if err != nil {
// A path url.Parse rejects (e.g. a control byte) is the caller's own
// malformed input. Degrade to the unfiltered first page instead of
// nil-derefing in ApplyFilters or panicking in MustGetPageByPath below
// — this is a read-only, unauthenticated render.
u, _ = url.Parse("")
path = ""
}
mdFilters, items := urlfilter.ApplyFilters(u, members.BPTree, "filter")
var sb strings.Builder
sb.WriteString(md.Link("> Go to Tiers summary <", "/r/gov/dao/memberstore/v0") + "\n\n")
sb.WriteString(md.Bold("Filter members by tiers:"))
sb.WriteString(mdFilters + "\n")
const pageSize = 14
pager := pager.NewPager(items, pageSize, false)
page := pager.MustGetPageByPath(path)
sb.WriteString(renderMembersPages(u, page, items) + "\n")
sb.WriteString(renderPagination(u, page))
return sb.String()
}
// renderMembersPages returns the members of each page.
func renderMembersPages(u *url.URL, page *pager.Page, members *bptree.BPTree) string {
var sb strings.Builder
table := &tablesort.Table{
Headings: []string{"Tier", "Address"},
Rows: [][]string{},
}
for _, item := range page.Items {
addr := item.Key
tn := members.Get(addr)
tnStr, _ := tn.(string)
tierCell := ufmt.Sprintf("%s %s", tierColoredChip(tnStr), tn)
table.Rows = append(table.Rows, []string{tierCell, addr})
}
sb.WriteString(tablesort.Render(u, table, ""))
return sb.String()
}
// renderPagination returns the pagination UI for the current page.
func renderPagination(u *url.URL, page *pager.Page) string {
q := u.Query()
q.Del("page")
u.RawQuery = q.Encode()
var sb strings.Builder
sb.WriteString(page.Picker(u.String()))
return sb.String()
}
types.gno
package memberstore
import (
"errors"
"gno.land/p/nt/bptree/v0"
)
type ErrMemberAlreadyExists struct {
Tier string
}
func (e *ErrMemberAlreadyExists) Error() string {
return "member already exists on tier " + e.Tier
}
type Member struct {
InvitationPoints int
}
func NewMember(invitationPoints int) *Member {
return &Member{InvitationPoints: invitationPoints}
}
func (m *Member) RemoveInvitationPoint() {
if m.InvitationPoints <= 0 {
panic("not enough invitation points")
}
m.InvitationPoints = m.InvitationPoints - 1
}
// MembersByTier contains all `Member`s indexed by their Address.
type MembersByTier struct {
*bptree.BPTree // tier name -> address -> member
}
func NewMembersByTier() MembersByTier {
return MembersByTier{BPTree: bptree.NewBPTree32()}
}
func (mbt MembersByTier) DeleteAll() {
mbt.Iterate("", "", func(tn string, msv interface{}) bool {
mbt.Remove(tn)
return false
})
}
func (mbt MembersByTier) SetTier(tier string) error {
if ok := mbt.Has(tier); ok {
return errors.New("tier already exist: " + tier)
}
mbt.Set(tier, bptree.NewBPTree32())
return nil
}
// GetTierSize tries to get how many members are on the specified tier. If the tier does not exists, it returns 0.
func (mbt MembersByTier) GetTierSize(tn string) int {
tv := mbt.Get(tn)
if tv == nil {
return 0
}
tree, ok := tv.(*bptree.BPTree)
if !ok {
return 0
}
return tree.Size()
}
// SetMember adds a new member to the specified tier. The tier index is created on the fly if it does not exists.
func (mbt MembersByTier) SetMember(tier string, addr address, member *Member) error {
_, t := mbt.GetMember(addr)
if t != "" {
return &ErrMemberAlreadyExists{Tier: t}
}
if ok := mbt.Has(tier); !ok {
return errors.New("tier does not exist: " + tier)
}
ms := mbt.Get(tier)
mst := ms.(*bptree.BPTree)
mst.Set(string(addr), member)
return nil
}
// GetMember iterate over all tiers to try to find a member by its address. The tier ID is also returned if the Member is found.
func (mbt MembersByTier) GetMember(addr address) (m *Member, t string) {
mbt.Iterate("", "", func(tn string, msv interface{}) bool {
mst, ok := msv.(*bptree.BPTree)
if !ok {
panic("MembersByTier values can only be bptree.BPTree")
}
mv := mst.Get(string(addr))
if mv == nil {
return false
}
mm, ok := mv.(*Member)
if !ok {
panic("MembersByTier values can only be *Member")
}
m = mm
t = tn
return true
})
return
}
// RemoveMember removes a member from any tier
func (mbt MembersByTier) RemoveMember(addr address) (t string) {
mbt.Iterate("", "", func(tn string, msv interface{}) bool {
mst, ok := msv.(*bptree.BPTree)
if !ok {
panic("MembersByTier values can only be bptree.BPTree")
}
_, removed := mst.Remove(string(addr))
if removed {
t = tn
}
return removed
})
return
}
// GetTotalPower obtains the total voting power from all the specified tiers.
func (mbt MembersByTier) GetTotalPower() float64 {
var out float64
mbt.Iterate("", "", func(tn string, msv interface{}) bool {
tier, ok := tiers.GetTier(tn)
if !ok {
// tier does not exists, so we cannot count power from this tier
return false
}
out = out + (tier.PowerHandler(mbt, tiers) * float64(mbt.GetTierSize(tn)))
return false
})
return out
}
type Tier struct {
// BasePower defines the standard voting power for the members on this tier.
BasePower float64
// InvitationPoints defines how many invitation points users on that tier will receive.
InvitationPoints int
// MaxSize calculates the max amount of members expected to be on this tier.
MaxSize func(membersByTier MembersByTier, tiersByName TiersByName) int
// MinSize calculates the min amount of members expected to be on this tier.
MinSize func(membersByTier MembersByTier, tiersByName TiersByName) int
// PowerHandler calculates what is the final power of this tier after taking into account Members by other tiers.
PowerHandler func(membersByTier MembersByTier, tiersByName TiersByName) float64
}
// TiersByName contains all tier objects indexed by its name.
type TiersByName struct {
*bptree.BPTree // *bptree.BPTree[string]Tier
}
// GetTier obtains a Tier struct by its name. It returns false if the Tier is not found.
func (tbn TiersByName) GetTier(tn string) (Tier, bool) {
val := tbn.Get(tn)
if val == nil {
return Tier{}, false
}
t, ok := val.(Tier)
if !ok {
panic("TiersByName must contains only Tier types")
}
return t, true
}