Skip to content Search Apps Documentation Source Content Run Reset Eval Playground File Folder Download Copy Actions State String Boolean Number Struct Map Slice Pointer Function Closure Reference Nil Package Type Interface Unknown

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
}