From 56df907b05d4c989e70254daf5679a689e82afbe Mon Sep 17 00:00:00 2001
From: hthieu1110 <tronghieu.ha@gmail.com>
Date: Mon, 21 Aug 2023 09:31:27 +0700
Subject: [PATCH] chore: add daodao pkg

---
 .../p/demo/daodao/core_v3/dao_core.gno        |  70 ++++
 .../gno.land/p/demo/daodao/core_v3/gno.mod    |   6 +
 .../daodao/interfaces_v3/dao_interfaces.gno   | 172 ++++++++++
 .../daodao/interfaces_v3/dao_messages.gno     |  66 ++++
 .../p/demo/daodao/interfaces_v3/gno.mod       |   1 +
 .../daodao/interfaces_v3/proposal_test.gno    |  59 ++++
 .../p/demo/daodao/interfaces_v3/threshold.gno |  36 +++
 .../p/demo/daodao/jsonutil_v2/jsonutil.gno    | 180 +++++++++++
 .../p/demo/daodao/jsonutil_v2/tables.gno      | 216 +++++++++++++
 .../dao_proposal_single.gno                   | 305 ++++++++++++++++++
 .../p/demo/daodao/proposal_single_v4/gno.mod  |   7 +
 .../proposal_single_v4/update_settings.gno    | 114 +++++++
 .../p/demo/daodao/voting_group_v5/gno.mod     |   7 +
 .../daodao/voting_group_v5/voting_group.gno   |  42 +++
 .../voting_group_v5/voting_group_test.gno     |  19 ++
 .../r/demo/dao_registry_v5/dao_registry.gno   | 177 ++++++++++
 .../dao_registry_v5/dao_registry_test.gno     |  54 ++++
 .../gno.land/r/demo/dao_registry_v5/gno.mod   |   1 +
 .../r/demo/dao_registry_v5/tables.gno         | 216 +++++++++++++
 examples/gno.land/r/demo/groups_v6/gno.mod    |   1 +
 examples/gno.land/r/demo/groups_v6/group.gno  | 115 +++++++
 examples/gno.land/r/demo/groups_v6/groups.gno |  21 ++
 examples/gno.land/r/demo/groups_v6/member.gno |  40 +++
 .../gno.land/r/demo/groups_v6/messages.gno    | 138 ++++++++
 examples/gno.land/r/demo/groups_v6/misc.gno   |  96 ++++++
 examples/gno.land/r/demo/groups_v6/public.gno | 116 +++++++
 examples/gno.land/r/demo/groups_v6/render.gno |  40 +++
 examples/gno.land/r/demo/groups_v6/role.gno   |   8 +
 28 files changed, 2323 insertions(+)
 create mode 100644 examples/gno.land/p/demo/daodao/core_v3/dao_core.gno
 create mode 100644 examples/gno.land/p/demo/daodao/core_v3/gno.mod
 create mode 100644 examples/gno.land/p/demo/daodao/interfaces_v3/dao_interfaces.gno
 create mode 100644 examples/gno.land/p/demo/daodao/interfaces_v3/dao_messages.gno
 create mode 100644 examples/gno.land/p/demo/daodao/interfaces_v3/gno.mod
 create mode 100644 examples/gno.land/p/demo/daodao/interfaces_v3/proposal_test.gno
 create mode 100644 examples/gno.land/p/demo/daodao/interfaces_v3/threshold.gno
 create mode 100644 examples/gno.land/p/demo/daodao/jsonutil_v2/jsonutil.gno
 create mode 100644 examples/gno.land/p/demo/daodao/jsonutil_v2/tables.gno
 create mode 100644 examples/gno.land/p/demo/daodao/proposal_single_v4/dao_proposal_single.gno
 create mode 100644 examples/gno.land/p/demo/daodao/proposal_single_v4/gno.mod
 create mode 100644 examples/gno.land/p/demo/daodao/proposal_single_v4/update_settings.gno
 create mode 100644 examples/gno.land/p/demo/daodao/voting_group_v5/gno.mod
 create mode 100644 examples/gno.land/p/demo/daodao/voting_group_v5/voting_group.gno
 create mode 100644 examples/gno.land/p/demo/daodao/voting_group_v5/voting_group_test.gno
 create mode 100644 examples/gno.land/r/demo/dao_registry_v5/dao_registry.gno
 create mode 100644 examples/gno.land/r/demo/dao_registry_v5/dao_registry_test.gno
 create mode 100644 examples/gno.land/r/demo/dao_registry_v5/gno.mod
 create mode 100644 examples/gno.land/r/demo/dao_registry_v5/tables.gno
 create mode 100644 examples/gno.land/r/demo/groups_v6/gno.mod
 create mode 100644 examples/gno.land/r/demo/groups_v6/group.gno
 create mode 100644 examples/gno.land/r/demo/groups_v6/groups.gno
 create mode 100644 examples/gno.land/r/demo/groups_v6/member.gno
 create mode 100644 examples/gno.land/r/demo/groups_v6/messages.gno
 create mode 100644 examples/gno.land/r/demo/groups_v6/misc.gno
 create mode 100644 examples/gno.land/r/demo/groups_v6/public.gno
 create mode 100644 examples/gno.land/r/demo/groups_v6/render.gno
 create mode 100644 examples/gno.land/r/demo/groups_v6/role.gno

diff --git a/examples/gno.land/p/demo/daodao/core_v3/dao_core.gno b/examples/gno.land/p/demo/daodao/core_v3/dao_core.gno
new file mode 100644
index 00000000000..4a72bbfd7e7
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/core_v3/dao_core.gno
@@ -0,0 +1,70 @@
+package core
+
+import (
+	"std"
+	"strings"
+
+	dao_interfaces "gno.land/p/demo/daodao/interfaces_v3"
+	"gno.land/p/demo/markdown_utils"
+)
+
+// TODO: add wrapper message handler to handle multiple proposal modules messages
+
+type IDAOCore interface {
+	AddProposalModule(proposalMod dao_interfaces.IProposalModule)
+
+	VotingModule() dao_interfaces.IVotingModule
+	ProposalModules() []dao_interfaces.IProposalModule
+
+	Render(path string) string
+}
+
+type daoCore struct {
+	IDAOCore
+
+	votingModule    dao_interfaces.IVotingModule
+	proposalModules []dao_interfaces.IProposalModule
+}
+
+func NewDAOCore(
+	votingModule dao_interfaces.IVotingModule,
+	proposalModules []dao_interfaces.IProposalModule,
+) IDAOCore {
+	return &daoCore{
+		votingModule:    votingModule,
+		proposalModules: proposalModules,
+	}
+}
+
+func (d *daoCore) VotingModule() dao_interfaces.IVotingModule {
+	return d.votingModule
+}
+
+func (d *daoCore) ProposalModules() []dao_interfaces.IProposalModule {
+	return d.proposalModules
+}
+
+func (d *daoCore) AddProposalModule(proposalMod dao_interfaces.IProposalModule) {
+	d.proposalModules = append(d.proposalModules, proposalMod)
+}
+
+func (d *daoCore) Render(path string) string {
+	s := "# DAO Core\n"
+	s += "This is a port of [DA0-DA0 contracts](https://github.com/DA0-DA0/dao-contracts)\n"
+	s += markdown_utils.Indent(d.votingModule.Render(path)) + "\n"
+	for _, propMod := range d.proposalModules {
+		s += markdown_utils.Indent(propMod.Render(path)) + "\n"
+	}
+	return s
+}
+
+func GetProposalModule(core IDAOCore, moduleIndex int) dao_interfaces.IProposalModule {
+	if moduleIndex < 0 {
+		panic("Module index must be >= 0")
+	}
+	mods := core.ProposalModules()
+	if moduleIndex >= len(mods) {
+		panic("invalid module index")
+	}
+	return mods[moduleIndex]
+}
diff --git a/examples/gno.land/p/demo/daodao/core_v3/gno.mod b/examples/gno.land/p/demo/daodao/core_v3/gno.mod
new file mode 100644
index 00000000000..810ec7e040c
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/core_v3/gno.mod
@@ -0,0 +1,6 @@
+module gno.land/p/demo/daodao/core_v3
+
+require (
+    "gno.land/p/demo/daodao/interfaces_v3" v0.0.0-latest
+    "gno.land/p/demo/markdown_utils" v0.0.0-latest
+)
\ No newline at end of file
diff --git a/examples/gno.land/p/demo/daodao/interfaces_v3/dao_interfaces.gno b/examples/gno.land/p/demo/daodao/interfaces_v3/dao_interfaces.gno
new file mode 100644
index 00000000000..7ffab4650a8
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/interfaces_v3/dao_interfaces.gno
@@ -0,0 +1,172 @@
+package dao_interfaces
+
+import (
+	"std"
+	"strconv"
+
+	"gno.land/p/demo/avl"
+	"gno.land/p/demo/jsonutil_v2"
+)
+
+type IVotingModule interface {
+	VotingPower(addr std.Address) uint64
+	TotalPower() uint64
+	Render(path string) string
+}
+
+type Ballot struct {
+	Power     uint64
+	Vote      Vote
+	Rationale string
+}
+
+func (b Ballot) ToJSON() string {
+	return jsonutil.FormatObject([]jsonutil.KeyValue{
+		{Key: "power", Value: b.Power},
+		{Key: "vote", Value: b.Vote},
+		{Key: "rationale", Value: b.Rationale},
+	})
+}
+
+type Votes struct {
+	Yes     uint64
+	No      uint64
+	Abstain uint64
+}
+
+func (v *Votes) Add(vote Vote, power uint64) {
+	switch vote {
+	case VoteYes:
+		v.Yes += power
+	case VoteNo:
+		v.No += power
+	case VoteAbstain:
+		v.Abstain += power
+	default:
+		panic("unknown vote kind")
+	}
+}
+
+func (v *Votes) Remove(vote Vote, power uint64) {
+	switch vote {
+	case VoteYes:
+		v.Yes -= power
+	case VoteNo:
+		v.No -= power
+	case VoteAbstain:
+		v.Abstain -= power
+	default:
+		panic("unknown vote kind")
+	}
+}
+
+func (v *Votes) Total() uint64 {
+	return v.Yes + v.No + v.Abstain
+}
+
+func (v Votes) ToJSON() string {
+	return jsonutil.FormatObject([]jsonutil.KeyValue{
+		{Key: "yes", Value: v.Yes},
+		{Key: "no", Value: v.No},
+		{Key: "abstain", Value: v.Abstain},
+	})
+}
+
+type Proposal struct {
+	ID          int
+	Title       string
+	Description string
+	Proposer    std.Address
+	Messages    []ExecutableMessage
+	Ballots     *avl.Tree // dev
+	// Ballots *avl.MutTree // test3
+	Votes  Votes
+	Status ProposalStatus
+}
+
+var _ jsonutil.JSONAble = (*Proposal)(nil)
+
+func (p Proposal) ToJSON() string {
+	return jsonutil.FormatObject([]jsonutil.KeyValue{
+		{Key: "id", Value: p.ID},
+		{Key: "title", Value: p.Title},
+		{Key: "description", Value: p.Description},
+		{Key: "proposer", Value: p.Proposer},
+		{Key: "messages", Value: jsonutil.FormatSlice(p.Messages), Raw: true},
+		{Key: "ballots", Value: p.Ballots},
+		{Key: "votes", Value: p.Votes},
+		{Key: "status", Value: p.Status},
+	})
+}
+
+type ProposalStatus int
+
+const (
+	ProposalStatusOpen ProposalStatus = iota
+	ProposalStatusPassed
+	ProposalStatusExecuted
+)
+
+func (p ProposalStatus) ToJSON() string {
+	return jsonutil.FormatString(p.String())
+}
+
+func (p ProposalStatus) String() string {
+	switch p {
+	case ProposalStatusOpen:
+		return "Open"
+	case ProposalStatusPassed:
+		return "Passed"
+	case ProposalStatusExecuted:
+		return "Executed"
+	default:
+		return "Unknown(" + strconv.Itoa(int(p)) + ")"
+	}
+}
+
+type Vote int
+
+const (
+	VoteYes Vote = iota
+	VoteNo
+	VoteAbstain
+)
+
+func (v Vote) ToJSON() string {
+	return jsonutil.FormatString(v.String())
+}
+
+func (v Vote) String() string {
+	switch v {
+	case VoteYes:
+		return "Yes"
+	case VoteNo:
+		return "No"
+	case VoteAbstain:
+		return "Abstain"
+	default:
+		return "Unknown(" + strconv.Itoa(int(v)) + ")"
+	}
+}
+
+type IProposalModule interface {
+	Propose(
+		title string,
+		description string,
+		actions []ExecutableMessage,
+	)
+	Vote(proposalId int, vote Vote, rationale string)
+	Execute(proposalId int)
+	Threshold() Threshold
+
+	Proposals() []Proposal
+	GetBallot(proposalId int, addr std.Address) Ballot
+
+	Render(path string) string
+}
+
+type ExecutableMessage interface {
+	String() string
+	Binary() []byte
+	Type() string
+}
diff --git a/examples/gno.land/p/demo/daodao/interfaces_v3/dao_messages.gno b/examples/gno.land/p/demo/daodao/interfaces_v3/dao_messages.gno
new file mode 100644
index 00000000000..8ab887157dd
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/interfaces_v3/dao_messages.gno
@@ -0,0 +1,66 @@
+package dao_interfaces
+
+import (
+	"encoding/base64"
+	"encoding/binary"
+	"strings"
+
+	"gno.land/p/demo/avl"
+)
+
+type MessageHandler interface {
+	Execute(message ExecutableMessage)
+	FromBinary(b []byte) ExecutableMessage
+	Type() string
+}
+
+type MessagesRegistry struct {
+	handlers *avl.Tree
+}
+
+func NewMessagesRegistry() *MessagesRegistry {
+	return &MessagesRegistry{handlers: avl.NewTree()}
+}
+
+func (r *MessagesRegistry) Register(handler MessageHandler) {
+	r.handlers.Set(handler.Type(), handler)
+}
+
+func (r *MessagesRegistry) FromBinary(b []byte) ExecutableMessage {
+	if len(b) < 2 {
+		panic("invalid ExecutableMessage: invalid length")
+	}
+	l := binary.BigEndian.Uint16(b[:2])
+	if len(b) < int(l+2) {
+		panic("invalid ExecutableMessage: invalid length")
+	}
+	t := string(b[2 : l+2])
+
+	h, ok := r.handlers.Get(t)
+	if !ok {
+		panic("invalid ExecutableMessage: invalid message type")
+	}
+	return h.(MessageHandler).FromBinary(b)
+}
+
+func (r *MessagesRegistry) FromBase64String(s string) ExecutableMessage {
+	b, err := base64.RawURLEncoding.DecodeString(s)
+	if err != nil {
+		panic("invalid ExecutableMessage: invalid base64 string")
+	}
+	return r.FromBinary(b)
+}
+
+func (r *MessagesRegistry) Execute(msg ExecutableMessage) {
+	h, ok := r.handlers.Get(msg.Type())
+	if !ok {
+		panic("invalid ExecutableMessage: invalid message type")
+	}
+	return h.(MessageHandler).Execute(msg)
+}
+
+func (r *MessagesRegistry) ExecuteMessages(msgs []ExecutableMessage) {
+	for _, msg := range msgs {
+		r.Execute(msg)
+	}
+}
diff --git a/examples/gno.land/p/demo/daodao/interfaces_v3/gno.mod b/examples/gno.land/p/demo/daodao/interfaces_v3/gno.mod
new file mode 100644
index 00000000000..1d1fcc9450e
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/interfaces_v3/gno.mod
@@ -0,0 +1 @@
+module gno.land/p/demo/daodao/interfaces_v3
diff --git a/examples/gno.land/p/demo/daodao/interfaces_v3/proposal_test.gno b/examples/gno.land/p/demo/daodao/interfaces_v3/proposal_test.gno
new file mode 100644
index 00000000000..efc31fa1a08
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/interfaces_v3/proposal_test.gno
@@ -0,0 +1,59 @@
+package dao_interfaces
+
+import (
+	"testing"
+
+	"gno.land/p/demo/avl"
+	"gno.land/p/demo/jsonutil_v2"
+)
+
+type NoopMessage struct{}
+
+var _ ExecutableMessage = (*NoopMessage)(nil)
+
+func (m NoopMessage) String() string {
+	return "noop"
+}
+
+func (m NoopMessage) Binary() []byte {
+	return nil
+}
+
+func (m NoopMessage) Type() string {
+	return "noop-type"
+}
+
+func (m NoopMessage) ToJSON() string {
+	return jsonutil.FormatString(m.String())
+}
+
+func TestProposalJSON(t *testing.T) {
+	props := []Proposal{
+		{
+			ID:          0,
+			Title:       "Prop #0",
+			Description: "Wolol0\n\t\r",
+			Proposer:    "0x1234567890",
+			Votes: Votes{
+				Yes:     7,
+				No:      21,
+				Abstain: 42,
+			},
+			Ballots: avl.NewTree(),
+		},
+		{
+			ID:          1,
+			Title:       "Prop #1",
+			Description: `Wolol1\"`,
+			Proposer:    "0x1234567890",
+			Status:      ProposalStatusExecuted,
+			Messages:    []ExecutableMessage{NoopMessage{}, NoopMessage{}, NoopMessage{}},
+		},
+	}
+	props[0].Ballots.Set("0x1234567890", Ballot{Power: 1, Vote: VoteYes, Rationale: "test"})
+	str := jsonutil.FormatSlice(props)
+	expected := `[{"id":0,"title":"Prop #0","description":"Wolol0\n\t\r","proposer":"0x1234567890","messages":[],"ballots":{"0x1234567890":{"power":1,"vote":"Yes","rationale":"test"}},"votes":{"yes":7,"no":21,"abstain":42},"status":"Open"},{"id":1,"title":"Prop #1","description":"Wolol1\\\"","proposer":"0x1234567890","messages":["noop","noop","noop"],"ballots":{},"votes":{"yes":0,"no":0,"abstain":0},"status":"Executed"}]`
+	if expected != str {
+		t.Fatalf("JSON does not match, expected %s, got %s", expected, str)
+	}
+}
diff --git a/examples/gno.land/p/demo/daodao/interfaces_v3/threshold.gno b/examples/gno.land/p/demo/daodao/interfaces_v3/threshold.gno
new file mode 100644
index 00000000000..7b34ba7b4d2
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/interfaces_v3/threshold.gno
@@ -0,0 +1,36 @@
+package dao_interfaces
+
+import (
+	"strconv"
+)
+
+type Percent uint16 // 4 decimals fixed point
+
+type PercentageThreshold struct {
+	Percent *Percent
+}
+
+func (p *PercentageThreshold) String() string {
+	if p == nil || p.Percent == nil {
+		return "nil"
+	}
+	return p.Percent.String()
+}
+
+type ThresholdQuorum struct {
+	Threshold PercentageThreshold
+	Quorum    PercentageThreshold
+}
+
+type Threshold struct {
+	ThresholdQuorum *ThresholdQuorum
+}
+
+func (p Percent) String() string {
+	s := strconv.FormatUint(uint64(p)/100, 10)
+	decPart := uint64(p) % 100
+	if decPart != 0 {
+		s += "." + strconv.FormatUint(decPart, 10)
+	}
+	return s + "%"
+}
diff --git a/examples/gno.land/p/demo/daodao/jsonutil_v2/jsonutil.gno b/examples/gno.land/p/demo/daodao/jsonutil_v2/jsonutil.gno
new file mode 100644
index 00000000000..51fdc369b0e
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/jsonutil_v2/jsonutil.gno
@@ -0,0 +1,180 @@
+package jsonutil
+
+// This package strives to have the same behavior as json.Marshal but has no support for nested slices and returns strings
+
+import (
+	"std"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+
+	"gno.land/p/demo/avl"
+	"gno.land/p/demo/ufmt"
+)
+
+type JSONAble interface {
+	ToJSON() string
+}
+
+type KeyValue struct {
+	Key   string
+	Value interface{}
+	Raw   bool
+}
+
+// does not work for slices, use FormatSlice instead
+func FormatAny(p interface{}) string {
+	switch p.(type) {
+	case std.Address:
+		return FormatString(string(p.(std.Address)))
+	case *avl.Tree:
+		return FormatAVLTree(p.(*avl.Tree))
+	case avl.Tree:
+		return FormatAVLTree(&p.(avl.Tree))
+	case JSONAble:
+		return p.(JSONAble).ToJSON()
+	case string:
+		return FormatString(p.(string))
+	case uint64:
+		return FormatUint64(p.(uint64))
+	case uint32:
+		return FormatUint64(uint64(p.(uint32)))
+	case uint:
+		return FormatUint64(uint64(p.(uint)))
+	case int64:
+		return FormatInt64(p.(int64))
+	case int32:
+		return FormatInt64(int64(p.(int32)))
+	case int:
+		return FormatInt64(int64(p.(int)))
+	case bool:
+		return FormatBool(p.(bool))
+	default:
+		return "null"
+	}
+}
+
+// Ported from https://cs.opensource.google/go/go/+/refs/tags/go1.20.6:src/encoding/json/encode.go
+func FormatString(s string) string {
+	const escapeHTML = true
+	e := `"` // e.WriteByte('"')
+	start := 0
+	for i := 0; i < len(s); {
+		if b := s[i]; b < utf8.RuneSelf {
+			if htmlSafeSet[b] || (!escapeHTML && safeSet[b]) {
+				i++
+				continue
+			}
+			if start < i {
+				e += s[start:i] // e.WriteString(s[start:i])
+			}
+			e += "\\" // e.WriteByte('\\')
+			switch b {
+			case '\\', '"':
+				e += string(b) // e.WriteByte(b)
+			case '\n':
+				e += "n" // e.WriteByte('n')
+			case '\r':
+				e += "r" // e.WriteByte('r')
+			case '\t':
+				e += "t" // e.WriteByte('t')
+			default:
+				// This encodes bytes < 0x20 except for \t, \n and \r.
+				// If escapeHTML is set, it also escapes <, >, and &
+				// because they can lead to security holes when
+				// user-controlled strings are rendered into JSON
+				// and served to some browsers.
+				e += `u00`              // e.WriteString(`u00`)
+				e += string(hex[b>>4])  // e.WriteByte(hex[b>>4])
+				e += string(hex[b&0xF]) // e.WriteByte(hex[b&0xF])
+			}
+			i++
+			start = i
+			continue
+		}
+		c, size := utf8.DecodeRuneInString(s[i:])
+		if c == utf8.RuneError && size == 1 {
+			if start < i {
+				e += s[start:i] // e.WriteString(s[start:i])
+			}
+			e += `\ufffd` // e.WriteString(`\ufffd`)
+			i += size
+			start = i
+			continue
+		}
+		// U+2028 is LINE SEPARATOR.
+		// U+2029 is PARAGRAPH SEPARATOR.
+		// They are both technically valid characters in JSON strings,
+		// but don't work in JSONP, which has to be evaluated as JavaScript,
+		// and can lead to security holes there. It is valid JSON to
+		// escape them, so we do so unconditionally.
+		// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
+		if c == '\u2028' || c == '\u2029' {
+			if start < i {
+				e += s[start:i] // e.WriteString(s[start:i])
+			}
+			e += `\u202`            // e.WriteString(`\u202`)
+			e += string(hex[c&0xF]) // e.WriteByte(hex[c&0xF])
+			i += size
+			start = i
+			continue
+		}
+		i += size
+	}
+	if start < len(s) {
+		e += s[start:] // e.WriteString(s[start:])
+	}
+	e += `"` // e.WriteByte('"')
+	return e
+}
+
+func FormatUint64(i uint64) string {
+	return strconv.FormatUint(i, 10)
+}
+
+func FormatInt64(i int64) string {
+	return strconv.FormatInt(i, 10)
+}
+
+func FormatSlice(s []interface{}) string {
+	elems := make([]string, len(s))
+	for i, elem := range s {
+		elems[i] = FormatAny(elem)
+	}
+	return "[" + strings.Join(elems, ",") + "]"
+}
+
+func FormatObject(kv []KeyValue) string {
+	elems := make([]string, len(kv))
+	i := 0
+	for _, elem := range kv {
+		var val string
+		if elem.Raw {
+			val = elem.Value.(string)
+		} else {
+			val = FormatAny(elem.Value)
+		}
+		elems[i] = FormatString(elem.Key) + ":" + val
+		i++
+	}
+	return "{" + strings.Join(elems, ",") + "}"
+}
+
+func FormatBool(b bool) string {
+	if b {
+		return "true"
+	}
+	return "false"
+}
+
+func FormatAVLTree(t *avl.Tree) string {
+	if t == nil {
+		return "{}"
+	}
+	kv := make([]KeyValue, 0, t.Size())
+	t.Iterate("", "", func(key string, value interface{}) bool {
+		kv = append(kv, KeyValue{key, value, false})
+		return false
+	})
+	return FormatObject(kv)
+}
diff --git a/examples/gno.land/p/demo/daodao/jsonutil_v2/tables.gno b/examples/gno.land/p/demo/daodao/jsonutil_v2/tables.gno
new file mode 100644
index 00000000000..e761c1faa2f
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/jsonutil_v2/tables.gno
@@ -0,0 +1,216 @@
+package jsonutil
+
+import "unicode/utf8"
+
+var hex = "0123456789abcdef"
+
+// safeSet holds the value true if the ASCII character with the given array
+// position can be represented inside a JSON string without any further
+// escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), and the backslash character ("\").
+var safeSet = [utf8.RuneSelf]bool{
+	' ':      true,
+	'!':      true,
+	'"':      false,
+	'#':      true,
+	'$':      true,
+	'%':      true,
+	'&':      true,
+	'\'':     true,
+	'(':      true,
+	')':      true,
+	'*':      true,
+	'+':      true,
+	',':      true,
+	'-':      true,
+	'.':      true,
+	'/':      true,
+	'0':      true,
+	'1':      true,
+	'2':      true,
+	'3':      true,
+	'4':      true,
+	'5':      true,
+	'6':      true,
+	'7':      true,
+	'8':      true,
+	'9':      true,
+	':':      true,
+	';':      true,
+	'<':      true,
+	'=':      true,
+	'>':      true,
+	'?':      true,
+	'@':      true,
+	'A':      true,
+	'B':      true,
+	'C':      true,
+	'D':      true,
+	'E':      true,
+	'F':      true,
+	'G':      true,
+	'H':      true,
+	'I':      true,
+	'J':      true,
+	'K':      true,
+	'L':      true,
+	'M':      true,
+	'N':      true,
+	'O':      true,
+	'P':      true,
+	'Q':      true,
+	'R':      true,
+	'S':      true,
+	'T':      true,
+	'U':      true,
+	'V':      true,
+	'W':      true,
+	'X':      true,
+	'Y':      true,
+	'Z':      true,
+	'[':      true,
+	'\\':     false,
+	']':      true,
+	'^':      true,
+	'_':      true,
+	'`':      true,
+	'a':      true,
+	'b':      true,
+	'c':      true,
+	'd':      true,
+	'e':      true,
+	'f':      true,
+	'g':      true,
+	'h':      true,
+	'i':      true,
+	'j':      true,
+	'k':      true,
+	'l':      true,
+	'm':      true,
+	'n':      true,
+	'o':      true,
+	'p':      true,
+	'q':      true,
+	'r':      true,
+	's':      true,
+	't':      true,
+	'u':      true,
+	'v':      true,
+	'w':      true,
+	'x':      true,
+	'y':      true,
+	'z':      true,
+	'{':      true,
+	'|':      true,
+	'}':      true,
+	'~':      true,
+	'\u007f': true,
+}
+
+// htmlSafeSet holds the value true if the ASCII character with the given
+// array position can be safely represented inside a JSON string, embedded
+// inside of HTML <script> tags, without any additional escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), the backslash character ("\"), HTML opening and closing
+// tags ("<" and ">"), and the ampersand ("&").
+var htmlSafeSet = [utf8.RuneSelf]bool{
+	' ':      true,
+	'!':      true,
+	'"':      false,
+	'#':      true,
+	'$':      true,
+	'%':      true,
+	'&':      false,
+	'\'':     true,
+	'(':      true,
+	')':      true,
+	'*':      true,
+	'+':      true,
+	',':      true,
+	'-':      true,
+	'.':      true,
+	'/':      true,
+	'0':      true,
+	'1':      true,
+	'2':      true,
+	'3':      true,
+	'4':      true,
+	'5':      true,
+	'6':      true,
+	'7':      true,
+	'8':      true,
+	'9':      true,
+	':':      true,
+	';':      true,
+	'<':      false,
+	'=':      true,
+	'>':      false,
+	'?':      true,
+	'@':      true,
+	'A':      true,
+	'B':      true,
+	'C':      true,
+	'D':      true,
+	'E':      true,
+	'F':      true,
+	'G':      true,
+	'H':      true,
+	'I':      true,
+	'J':      true,
+	'K':      true,
+	'L':      true,
+	'M':      true,
+	'N':      true,
+	'O':      true,
+	'P':      true,
+	'Q':      true,
+	'R':      true,
+	'S':      true,
+	'T':      true,
+	'U':      true,
+	'V':      true,
+	'W':      true,
+	'X':      true,
+	'Y':      true,
+	'Z':      true,
+	'[':      true,
+	'\\':     false,
+	']':      true,
+	'^':      true,
+	'_':      true,
+	'`':      true,
+	'a':      true,
+	'b':      true,
+	'c':      true,
+	'd':      true,
+	'e':      true,
+	'f':      true,
+	'g':      true,
+	'h':      true,
+	'i':      true,
+	'j':      true,
+	'k':      true,
+	'l':      true,
+	'm':      true,
+	'n':      true,
+	'o':      true,
+	'p':      true,
+	'q':      true,
+	'r':      true,
+	's':      true,
+	't':      true,
+	'u':      true,
+	'v':      true,
+	'w':      true,
+	'x':      true,
+	'y':      true,
+	'z':      true,
+	'{':      true,
+	'|':      true,
+	'}':      true,
+	'~':      true,
+	'\u007f': true,
+}
diff --git a/examples/gno.land/p/demo/daodao/proposal_single_v4/dao_proposal_single.gno b/examples/gno.land/p/demo/daodao/proposal_single_v4/dao_proposal_single.gno
new file mode 100644
index 00000000000..df42e49f7aa
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/proposal_single_v4/dao_proposal_single.gno
@@ -0,0 +1,305 @@
+package dao_proposal_single
+
+import (
+	"std"
+	"strconv"
+	"time"
+
+	"gno.land/p/demo/avl"
+	dao_core "gno.land/p/demo/daodao/core_v3"
+	dao_interfaces "gno.land/p/demo/daodao/interfaces_v3"
+	"gno.land/p/demo/jsonutil_v2"
+)
+
+type DAOProposalSingleOpts struct {
+	/// The threshold a proposal must reach to complete.
+	Threshold dao_interfaces.Threshold
+	/// The default maximum amount of time a proposal may be voted on
+	/// before expiring.
+	MaxVotingPeriod time.Duration
+	/// The minimum amount of time a proposal must be open before
+	/// passing. A proposal may fail before this amount of time has
+	/// elapsed, but it will not pass. This can be useful for
+	/// preventing governance attacks wherein an attacker aquires a
+	/// large number of tokens and forces a proposal through.
+	MinVotingPeriod time.Duration // 0 means no minimum
+	/// If set to true only members may execute passed
+	/// proposals. Otherwise, any address may execute a passed
+	/// proposal.
+	OnlyMembersExecute bool
+	/// Allows changing votes before the proposal expires. If this is
+	/// enabled proposals will not be able to complete early as final
+	/// vote information is not known until the time of proposal
+	/// expiration.
+	AllowRevoting bool
+	/// Information about what addresses may create proposals.
+	// preProposeInfo PreProposeInfo
+	/// If set to true proposals will be closed if their execution
+	/// fails. Otherwise, proposals will remain open after execution
+	/// failure. For example, with this enabled a proposal to send 5
+	/// tokens out of a DAO's treasury with 4 tokens would be closed when
+	/// it is executed. With this disabled, that same proposal would
+	/// remain open until the DAO's treasury was large enough for it to be
+	/// executed.
+	CloseProposalOnExecutionFailure bool
+
+	Registry *dao_interfaces.MessagesRegistry
+}
+
+type daoProposalSingle struct {
+	dao_interfaces.IProposalModule
+
+	core      dao_core.IDAOCore
+	opts      *DAOProposalSingleOpts
+	proposals []dao_interfaces.Proposal
+}
+
+func NewDAOProposalSingle(core dao_core.IDAOCore, opts *DAOProposalSingleOpts) *daoProposalSingle {
+	if core == nil {
+		panic("core cannot be nil")
+	}
+
+	if opts == nil {
+		panic("opts cannot be nil")
+	}
+
+	if opts.Registry == nil {
+		panic("opts.Registry cannot be nil")
+	}
+
+	if opts.AllowRevoting {
+		panic("allow revoting not implemented")
+	}
+
+	if opts.OnlyMembersExecute {
+		panic("only members execute not implemented")
+	}
+
+	if opts.CloseProposalOnExecutionFailure {
+		panic("close proposal on execution failure not implemented")
+	}
+
+	// TODO: support other threshold types
+	threshold := opts.Threshold.ThresholdQuorum
+	if threshold == nil {
+		panic("opts.Threshold must be of type ThresholdQuorum")
+	}
+
+	thresholdPercent := threshold.Threshold.Percent
+	if thresholdPercent == nil {
+		panic("opts.Threshold.Threshold must be of type Percent")
+	}
+	if *thresholdPercent > 10000 {
+		panic("opts.Threshold.Threshold must be <= 100%")
+	}
+
+	quorumPercent := threshold.Quorum.Percent
+	if quorumPercent == nil {
+		panic("opts.Threshold.Quorum must be of type Percent")
+	}
+	if *quorumPercent > 10000 {
+		panic("opts.Threshold.Quorum must be <= 100%")
+	}
+
+	return &daoProposalSingle{core: core, opts: opts}
+}
+
+func (d *daoProposalSingle) Render(path string) string {
+	minVotingPeriodStr := "No minimum voting period"
+	if d.opts.MinVotingPeriod != 0 {
+		minVotingPeriodStr = "Min voting period: " + d.opts.MinVotingPeriod.String()
+	}
+
+	executeStr := "Any address may execute passed proposals"
+	if d.opts.OnlyMembersExecute {
+		executeStr = "Only members may execute passed proposals"
+	}
+
+	revotingStr := "Revoting is not allowed"
+	if d.opts.AllowRevoting {
+		revotingStr = "Revoting is allowed"
+	}
+
+	closeOnExecFailureStr := "Proposals will remain open after execution failure"
+	if d.opts.CloseProposalOnExecutionFailure {
+		closeOnExecFailureStr = "Proposals will be closed if their execution fails"
+	}
+
+	thresholdStr := ""
+	if threshold := d.opts.Threshold.ThresholdQuorum; threshold != nil {
+		thresholdStr = "Threshold: " + threshold.Threshold.Percent.String() + "\n\n" +
+			"Quorum: " + threshold.Quorum.Percent.String()
+	}
+
+	proposalsStr := "## Proposals\n"
+	for _, p := range d.proposals {
+		messagesStr := ""
+		for _, m := range p.Messages {
+			messagesStr += "- " + m.(dao_interfaces.ExecutableMessage).String() + "\n"
+		}
+
+		proposalsStr += "### #" + strconv.Itoa(p.ID) + " " + p.Title + "\n" +
+			"Status: " + p.Status.String() + "\n\n" +
+			"Proposed by " + p.Proposer.String() + "\n\n" +
+			p.Description + "\n\n" +
+			"Votes summary:" + "\n\n" +
+			"- Yes: " + strconv.FormatUint(p.Votes.Yes, 10) + "\n" +
+			"- No: " + strconv.FormatUint(p.Votes.No, 10) + "\n" +
+			"- Abstain: " + strconv.FormatUint(p.Votes.Abstain, 10) + "\n\n" +
+			"Total: " + strconv.FormatUint(p.Votes.Total(), 10) + "\n" +
+			"#### Messages\n" +
+			messagesStr +
+			"#### Votes\n"
+
+		// /* dev
+		p.Ballots.Iterate("", "", func(k string, v interface{}) bool {
+			ballot := v.(dao_interfaces.Ballot)
+			proposalsStr += "- " + k + " voted " + ballot.Vote.String() + "\n"
+			return false
+		})
+		// */
+
+		/* test3
+		ballotsCount := p.Ballots.Size()
+		for i := 0; i < ballotsCount; i++ {
+			k, v := p.Ballots.GetByIndex(i)
+			ballot := v.(dao_interfaces.Ballot)
+			proposalsStr += "- " + k + " voted " + ballot.Vote.String() + "\n"
+		}
+		*/
+
+		proposalsStr += "\n"
+	}
+
+	return "# Single choice proposals module" + "\n" +
+		"## Summary" + "\n" +
+		"Max voting period: " + d.opts.MaxVotingPeriod.String() + "\n\n" +
+		minVotingPeriodStr + "\n\n" +
+		executeStr + "\n\n" +
+		revotingStr + "\n\n" +
+		closeOnExecFailureStr + "\n\n" +
+		thresholdStr + "\n\n" +
+		proposalsStr
+}
+
+func (d *daoProposalSingle) Propose(title string, description string, messages []dao_interfaces.ExecutableMessage) {
+	// TODO: auth
+	d.proposals = append(d.proposals, dao_interfaces.Proposal{
+		ID:          len(d.proposals),
+		Title:       title,
+		Description: description,
+		Messages:    messages,
+		Proposer:    std.GetOrigCaller(),
+		Ballots:     avl.NewTree(), // dev
+		// Ballots: avl.NewMutTree(), // test3
+		Status: dao_interfaces.ProposalStatusOpen,
+	})
+}
+
+func (d *daoProposalSingle) GetBallot(proposalID int, memberAddress std.Address) dao_interfaces.Ballot {
+	if len(d.proposals) <= proposalID || proposalID < 0 {
+		panic("proposal does not exist")
+	}
+	proposal := d.proposals[proposalID]
+	ballot, has := proposal.Ballots.Get(memberAddress.String())
+	if !has {
+		panic("ballot does not exist")
+	}
+	return ballot.(dao_interfaces.Ballot)
+}
+
+func (d *daoProposalSingle) Vote(proposalID int, vote dao_interfaces.Vote, rationale string) {
+	voter := std.GetOrigCaller()
+
+	if len(d.proposals) <= proposalID || proposalID < 0 {
+		panic("proposal does not exist")
+	}
+	proposal := d.proposals[proposalID]
+	// TODO: check proposal expiration
+
+	votePower := d.core.VotingModule().VotingPower(voter)
+	if votePower == 0 {
+		panic("you're not a member")
+	}
+
+	// TODO: handle revoting
+	if ok := proposal.Ballots.Has(voter.String()); ok {
+		panic("you already voted")
+	}
+	proposal.Ballots.Set(voter.String(), dao_interfaces.Ballot{
+		Vote:      vote,
+		Power:     votePower,
+		Rationale: rationale,
+	})
+
+	proposal.Votes.Add(vote, votePower)
+
+	d.updateStatus(proposalID)
+}
+
+func (d *daoProposalSingle) Execute(proposalID int) {
+	executer := std.GetOrigCaller()
+
+	if len(d.proposals) <= proposalID || proposalID < 0 {
+		panic("proposal does not exist")
+	}
+	prop := d.proposals[proposalID]
+
+	d.updateStatus(proposalID)
+	if prop.Status != dao_interfaces.ProposalStatusPassed {
+		panic("proposal is not passed")
+	}
+
+	d.opts.Registry.ExecuteMessages(prop.Messages)
+
+	d.proposals[proposalID].Status = dao_interfaces.ProposalStatusExecuted
+}
+
+// FIXME: should probably return a copy for safety
+func (d *daoProposalSingle) Proposals() []dao_interfaces.Proposal {
+	return d.proposals
+}
+
+func (d *daoProposalSingle) ProposalsJSON() string {
+	return jsonutil.FormatSlice(d.proposals)
+}
+
+func (d *daoProposalSingle) Threshold() dao_interfaces.Threshold {
+	return d.opts.Threshold
+}
+
+func (d *daoProposalSingle) updateStatus(proposalID int) {
+	proposal := d.proposals[proposalID]
+	if proposal.Status == dao_interfaces.ProposalStatusOpen && d.isPassed(proposalID) {
+		d.proposals[proposalID].Status = dao_interfaces.ProposalStatusPassed
+		return
+	}
+}
+
+func (d *daoProposalSingle) isPassed(proposalID int) bool {
+	proposal := d.proposals[proposalID]
+
+	// TODO: support other threshold types
+	threshold := d.opts.Threshold.ThresholdQuorum.Threshold
+	quorum := d.opts.Threshold.ThresholdQuorum.Quorum
+
+	totalPower := d.core.VotingModule().TotalPower()
+
+	if !doesVoteCountPass(proposal.Votes.Total(), totalPower, quorum) {
+		return false
+	}
+
+	// TODO: handle expiration
+	options := totalPower - proposal.Votes.Abstain
+	return doesVoteCountPass(proposal.Votes.Yes, options, threshold)
+}
+
+func doesVoteCountPass(yesVotes uint64, options uint64, percent dao_interfaces.PercentageThreshold) bool {
+	if options == 0 {
+		return false
+	}
+	percentValue := uint64(*percent.Percent)
+	votes := yesVotes * 10000
+	threshold := options * percentValue
+	return votes >= threshold
+}
diff --git a/examples/gno.land/p/demo/daodao/proposal_single_v4/gno.mod b/examples/gno.land/p/demo/daodao/proposal_single_v4/gno.mod
new file mode 100644
index 00000000000..713b57f4ded
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/proposal_single_v4/gno.mod
@@ -0,0 +1,7 @@
+module gno.land/p/demo/daodao/proposal_single_v4
+
+require (
+    "gno.land/p/demo/avl" v0.0.0-latest
+    "gno.land/p/demo/daodao/interfaces_v3" v0.0.0-latest
+    "gno.land/p/demo/daodao/core_v3" v0.0.0-latest
+)
\ No newline at end of file
diff --git a/examples/gno.land/p/demo/daodao/proposal_single_v4/update_settings.gno b/examples/gno.land/p/demo/daodao/proposal_single_v4/update_settings.gno
new file mode 100644
index 00000000000..ee9fccef75a
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/proposal_single_v4/update_settings.gno
@@ -0,0 +1,114 @@
+package dao_proposal_single
+
+import (
+	"encoding/binary"
+	"strings"
+
+	"gno.land/p/demo/daodao/interfaces_v3"
+)
+
+type UpdateSettingsMessage struct {
+	dao_interfaces.ExecutableMessage
+
+	Threshold *dao_interfaces.Threshold
+}
+
+func (usm *UpdateSettingsMessage) Type() string {
+	return "UpdateSettings"
+}
+
+func (usm *UpdateSettingsMessage) String() string {
+	ss := []string{usm.Type()}
+	if usm.Threshold != nil {
+		ss = append(ss, "Threshold type: ThresholdQuorum\nThreshold: "+usm.Threshold.ThresholdQuorum.Threshold.String()+"\nQuorum: "+usm.Threshold.ThresholdQuorum.Quorum.String())
+	}
+	return strings.Join(ss, "\n--\n")
+}
+
+func (usm *UpdateSettingsMessage) Binary() []byte {
+	b := []byte{}
+
+	t := usm.Type()
+	b = binary.BigEndian.AppendUint16(b, uint16(len(t)))
+	b = append(b, []byte(t)...)
+
+	if usm.Threshold != nil {
+		b = append(b, 1)
+		b = binary.BigEndian.AppendUint16(b, uint16(usm.Threshold.ThresholdQuorum.Threshold.Percent))
+		b = binary.BigEndian.AppendUint16(b, uint16(usm.Threshold.ThresholdQuorum.Quorum.Percent))
+	} else {
+		b = append(b, 0)
+	}
+
+	return b
+}
+
+func UpdateSettingsMessageFromBinary(b []byte) *UpdateSettingsMessage {
+	usm := UpdateSettingsMessage{}
+
+	if len(b) < 2 {
+		panic("invalid length - less than 2")
+	}
+	l := binary.BigEndian.Uint16(b[:2])
+	b = b[2:]
+	if len(b) < int(l) {
+		panic("invalid length - less than expected")
+	}
+	t := string(b[:l])
+	if t != usm.Type() {
+		panic("invalid type")
+	}
+	b = b[l:]
+
+	hasThreshold := b[0] == 1
+	b = b[1:]
+	if hasThreshold {
+		if len(b) < 4 {
+			panic("invalid length - less than 4")
+		}
+		threshold := binary.BigEndian.Uint16(b[:2])
+		b = b[2:]
+		quorum := binary.BigEndian.Uint16(b[:2])
+		b = b[2:]
+
+		// TODO: validate threshold and quorum
+
+		pt := dao_interfaces.Percent(threshold)
+		pq := dao_interfaces.Percent(quorum)
+
+		usm.Threshold = &dao_interfaces.Threshold{
+			ThresholdQuorum: &dao_interfaces.ThresholdQuorum{
+				Threshold: dao_interfaces.PercentageThreshold{Percent: &pt},
+				Quorum:    dao_interfaces.PercentageThreshold{Percent: &pq},
+			},
+		}
+	}
+
+	return &usm
+}
+
+func NewUpdateSettingsHandler(mod *daoProposalSingle) dao_interfaces.MessageHandler {
+	return &updateSettingsHandler{mod: mod}
+}
+
+type updateSettingsHandler struct {
+	dao_interfaces.MessageHandler
+
+	mod *daoProposalSingle
+}
+
+func (h *updateSettingsHandler) Execute(message dao_interfaces.ExecutableMessage) {
+	usm := message.(*UpdateSettingsMessage)
+
+	if usm.Threshold != nil {
+		h.mod.opts.Threshold = *usm.Threshold
+	}
+}
+
+func (h *updateSettingsHandler) Type() string {
+	return UpdateSettingsMessage{}.Type()
+}
+
+func (h *updateSettingsHandler) FromBinary(b []byte) dao_interfaces.ExecutableMessage {
+	return UpdateSettingsMessageFromBinary(b)
+}
diff --git a/examples/gno.land/p/demo/daodao/voting_group_v5/gno.mod b/examples/gno.land/p/demo/daodao/voting_group_v5/gno.mod
new file mode 100644
index 00000000000..8e7ffd2d909
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/voting_group_v5/gno.mod
@@ -0,0 +1,7 @@
+module gno.land/p/demo/daodao/
+
+require (
+    "gno.land/p/demo/daodao/interfaces_v3" v0.0.0-latest
+	"gno.land/p/demo/markdown_utils" v0.0.0-latest
+	"gno.land/r/demo/groups_v6" v0.0.0-latest
+)
\ No newline at end of file
diff --git a/examples/gno.land/p/demo/daodao/voting_group_v5/voting_group.gno b/examples/gno.land/p/demo/daodao/voting_group_v5/voting_group.gno
new file mode 100644
index 00000000000..0606d288b7b
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/voting_group_v5/voting_group.gno
@@ -0,0 +1,42 @@
+package dao_voting_group
+
+import (
+	"std"
+
+	dao_interfaces "gno.land/p/demo/daodao/interfaces_v3"
+	"gno.land/p/demo/markdown_utils"
+	"gno.land/r/demo/groups_v6"
+)
+
+type GRC4Voting struct {
+	dao_interfaces.IVotingModule
+
+	groupID groups.GroupID
+}
+
+func NewGRC4Voting(groupID groups.GroupID) dao_interfaces.IVotingModule {
+	return &GRC4Voting{groupID: groupID}
+}
+
+func (v *GRC4Voting) VotingPower(addr std.Address) uint64 {
+	return uint64(groups.GetMemberWeightByAddress(v.groupID, addr))
+}
+
+func (v *GRC4Voting) TotalPower() uint64 {
+	return uint64(groups.GetGroupTotalWeight(v.groupID))
+}
+
+func (v *GRC4Voting) Render(path string) string {
+	s := "# Group Voting Module\n"
+	if groupName, found := groups.GetGroupNameFromID(v.groupID); found {
+		s = "# [Group](/r/demo/groups:" + groupName + ") Voting Module\n"
+		s += markdown_utils.Indent(groups.Render(groupName))
+	} else {
+		s += "Group not found"
+	}
+	return s
+}
+
+func (v *GRC4Voting) GetGroupID() groups.GroupID {
+	return v.groupID
+}
diff --git a/examples/gno.land/p/demo/daodao/voting_group_v5/voting_group_test.gno b/examples/gno.land/p/demo/daodao/voting_group_v5/voting_group_test.gno
new file mode 100644
index 00000000000..2cad8a2e287
--- /dev/null
+++ b/examples/gno.land/p/demo/daodao/voting_group_v5/voting_group_test.gno
@@ -0,0 +1,19 @@
+package grc4
+
+import (
+	"std"
+	"testing"
+)
+
+func Test(t *testing.T) {
+	{
+		admin := "g14u5eaheavy0ux4dmpykg2gvxpvqvexm9cyg58a"
+		g := grc4.NewGRC4Group(std.Address(admin), nil)
+		v := NewGRC4Voting(g)
+		got := v.TotalPower()
+		expected := uint64(0)
+		if got != expected {
+			t.Fatalf("expected %q, got %q.", expected, got)
+		}
+	}
+}
diff --git a/examples/gno.land/r/demo/dao_registry_v5/dao_registry.gno b/examples/gno.land/r/demo/dao_registry_v5/dao_registry.gno
new file mode 100644
index 00000000000..8d118d1fd35
--- /dev/null
+++ b/examples/gno.land/r/demo/dao_registry_v5/dao_registry.gno
@@ -0,0 +1,177 @@
+package dao_registry
+
+import (
+	"encoding/binary"
+	"std"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"gno.land/p/demo/avl"
+)
+
+type Registration struct {
+	PkgPath     string      `json:"pkgPath"`
+	Addr        std.Address `json:"addr"`
+	CreatedAt   uint64      `json:"createdAt"`
+	Name        string      `json:"name"`
+	Description string      `json:"description"`
+	ImageURI    string      `json:"imageURI"`
+}
+
+var (
+	byCreatedAt = avl.NewTree()
+	byPkgPath   = avl.NewTree()
+)
+
+func Register(name string, description string, imageURI string) {
+	realm := std.PrevRealm()
+	pkgPath := realm.PkgPath()
+	if pkgPath == "" {
+		panic("no pkg path in prev realm")
+	}
+	doRegister(pkgPath, realm.Addr(), name, description, imageURI)
+}
+
+// splitted for tests
+func doRegister(pkgPath string, addr std.Address, name string, description string, imageURI string) {
+	if byPkgPath.Has(pkgPath) {
+		panic("already registered")
+	}
+	registration := &Registration{
+		PkgPath:     pkgPath,
+		Addr:        addr,
+		CreatedAt:   uint64(time.Now().UnixMilli()),
+		Name:        name,
+		Description: description,
+		ImageURI:    imageURI,
+	}
+	byPkgPath.Set(pkgPath, registration)
+
+	keyBytes := []byte{}
+	keyBytes = binary.BigEndian.AppendUint64(keyBytes, uint64(registration.CreatedAt))
+	keyBytes = append(keyBytes, []byte(pkgPath)...)
+	key := string(keyBytes)
+	byCreatedAt.Set(key, registration)
+}
+
+func GetJSON(pkgPath string) string {
+	r, ok := byPkgPath.Get(pkgPath)
+	if !ok {
+		panic("not found")
+	}
+	return r.(*Registration).JSON()
+}
+
+func List(start string, end string, limit int, reverse bool) []Registration {
+	regs := []Registration{}
+	cb := func(key string, value interface{}) bool {
+		regs = append(regs, *value.(*Registration))
+		if limit == 0 {
+			return false
+		}
+		return len(regs) >= limit
+	}
+	if reverse {
+		byCreatedAt.ReverseIterate(start, end, cb)
+	} else {
+		byCreatedAt.Iterate(start, end, cb)
+	}
+	return regs
+}
+
+func ListJSON(start string, end string, limit int, reverse bool) string {
+	regs := List(start, end, limit, reverse)
+	elems := make([]string, len(regs))
+	for i, reg := range regs {
+		elems[i] = reg.JSON()
+	}
+	return "[" + strings.Join(elems, ",") + "]"
+}
+
+func (r *Registration) JSON() string {
+	fields := []string{
+		`"pkgPath":` + JSONString(r.PkgPath),
+		`"addr":` + JSONString(r.Addr.String()),
+		`"createdAt":` + strconv.FormatUint(r.CreatedAt, 10),
+		`"name":` + JSONString(r.Name),
+		`"description":` + JSONString(r.Description),
+		`"imageURI":` + JSONString(r.ImageURI),
+	}
+	return "{" + strings.Join(fields, ",") + "}"
+}
+
+// ported from https://cs.opensource.google/go/go/+/refs/tags/go1.20.6:src/encoding/json/encode.go
+func JSONString(s string) string {
+	const escapeHTML = true
+	e := `"` // e.WriteByte('"')
+	start := 0
+	for i := 0; i < len(s); {
+		if b := s[i]; b < utf8.RuneSelf {
+			if htmlSafeSet[b] || (!escapeHTML && safeSet[b]) {
+				i++
+				continue
+			}
+			if start < i {
+				e += s[start:i] // e.WriteString(s[start:i])
+			}
+			e += "\\" // e.WriteByte('\\')
+			switch b {
+			case '\\', '"':
+				e += string(b) // e.WriteByte(b)
+			case '\n':
+				e += "n" // e.WriteByte('n')
+			case '\r':
+				e += "r" // e.WriteByte('r')
+			case '\t':
+				e += "t" // e.WriteByte('t')
+			default:
+				// This encodes bytes < 0x20 except for \t, \n and \r.
+				// If escapeHTML is set, it also escapes <, >, and &
+				// because they can lead to security holes when
+				// user-controlled strings are rendered into JSON
+				// and served to some browsers.
+				e += `u00`              // e.WriteString(`u00`)
+				e += string(hex[b>>4])  // e.WriteByte(hex[b>>4])
+				e += string(hex[b&0xF]) // e.WriteByte(hex[b&0xF])
+			}
+			i++
+			start = i
+			continue
+		}
+		c, size := utf8.DecodeRuneInString(s[i:])
+		if c == utf8.RuneError && size == 1 {
+			if start < i {
+				e += s[start:i] // e.WriteString(s[start:i])
+			}
+			e += `\ufffd` // e.WriteString(`\ufffd`)
+			i += size
+			start = i
+			continue
+		}
+		// U+2028 is LINE SEPARATOR.
+		// U+2029 is PARAGRAPH SEPARATOR.
+		// They are both technically valid characters in JSON strings,
+		// but don't work in JSONP, which has to be evaluated as JavaScript,
+		// and can lead to security holes there. It is valid JSON to
+		// escape them, so we do so unconditionally.
+		// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
+		if c == '\u2028' || c == '\u2029' {
+			if start < i {
+				e += s[start:i] // e.WriteString(s[start:i])
+			}
+			e += `\u202`            // e.WriteString(`\u202`)
+			e += string(hex[c&0xF]) // e.WriteByte(hex[c&0xF])
+			i += size
+			start = i
+			continue
+		}
+		i += size
+	}
+	if start < len(s) {
+		e += s[start:] // e.WriteString(s[start:])
+	}
+	e += `"` // e.WriteByte('"')
+	return e
+}
diff --git a/examples/gno.land/r/demo/dao_registry_v5/dao_registry_test.gno b/examples/gno.land/r/demo/dao_registry_v5/dao_registry_test.gno
new file mode 100644
index 00000000000..c5827ca5c03
--- /dev/null
+++ b/examples/gno.land/r/demo/dao_registry_v5/dao_registry_test.gno
@@ -0,0 +1,54 @@
+package dao_registry
+
+import (
+	"std"
+	"testing"
+	"time"
+
+	"gno.land/p/demo/ufmt"
+	"gno.land/r/demo/dao_registry"
+)
+
+func TestRegistry(t *testing.T) {
+	registrations := List("", "", 0, false)
+	if len(registrations) != 0 {
+		t.Fatal("expected 0 registrations")
+	}
+
+	registrationsJSON := ListJSON("", "", 0, false)
+	if registrationsJSON != "[]" {
+		t.Fatal("expected empty JSON array")
+	}
+
+	pkgPath := "gno.land/r/demo/test_dao"
+	addr := std.DerivePkgAddr(pkgPath)
+	createdAt := time.Now().UnixMilli()
+	doRegister(pkgPath, addr, "Test DAO", `This is a test DAO"\n\r\t\`+"\n\r\t", "https://example.com/image.png")
+
+	registrations = List("", "", 0, false)
+	if len(registrations) != 1 {
+		t.Fatal("expected 1 registration")
+	}
+	reg := registrations[0]
+	if reg.PkgPath != pkgPath {
+		t.Fatal("expected pkgPath to match")
+	}
+	if reg.Addr != addr {
+		t.Fatal("expected addr to match")
+	}
+	if reg.CreatedAt != createdAt {
+		t.Fatal("expected createdAt to match")
+	}
+
+	registrationsJSON = ListJSON("", "", 0, false)
+	expected := ufmt.Sprintf(`[{"pkgPath":"gno.land/r/demo/test_dao","addr":"g1m56y6xlx95sykjchn9h9q4e7k5u2zte4as9rdr","createdAt":%d,"name":"Test DAO","description":"This is a test DAO\"\\n\\r\\t\\\n\r\t","imageURI":"https://example.com/image.png"}]`, createdAt)
+	if registrationsJSON != expected {
+		t.Fatal("expected JSON to match, got:\n" + registrationsJSON + "\nexpected:\n" + expected)
+	}
+
+	registrationJSON := GetJSON(pkgPath)
+	expected = ufmt.Sprintf(`{"pkgPath":"gno.land/r/demo/test_dao","addr":"g1m56y6xlx95sykjchn9h9q4e7k5u2zte4as9rdr","createdAt":%d,"name":"Test DAO","description":"This is a test DAO\"\\n\\r\\t\\\n\r\t","imageURI":"https://example.com/image.png"}`, createdAt)
+	if registrationJSON != expected {
+		t.Fatal("expected JSON to match, got:\n" + registrationJSON + "\nexpected:\n" + expected)
+	}
+}
diff --git a/examples/gno.land/r/demo/dao_registry_v5/gno.mod b/examples/gno.land/r/demo/dao_registry_v5/gno.mod
new file mode 100644
index 00000000000..f578b9eba19
--- /dev/null
+++ b/examples/gno.land/r/demo/dao_registry_v5/gno.mod
@@ -0,0 +1 @@
+module gno.land/r/demo/dao_registry_v5
\ No newline at end of file
diff --git a/examples/gno.land/r/demo/dao_registry_v5/tables.gno b/examples/gno.land/r/demo/dao_registry_v5/tables.gno
new file mode 100644
index 00000000000..27c3f83887f
--- /dev/null
+++ b/examples/gno.land/r/demo/dao_registry_v5/tables.gno
@@ -0,0 +1,216 @@
+package dao_registry
+
+import "unicode/utf8"
+
+var hex = "0123456789abcdef"
+
+// safeSet holds the value true if the ASCII character with the given array
+// position can be represented inside a JSON string without any further
+// escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), and the backslash character ("\").
+var safeSet = [utf8.RuneSelf]bool{
+	' ':      true,
+	'!':      true,
+	'"':      false,
+	'#':      true,
+	'$':      true,
+	'%':      true,
+	'&':      true,
+	'\'':     true,
+	'(':      true,
+	')':      true,
+	'*':      true,
+	'+':      true,
+	',':      true,
+	'-':      true,
+	'.':      true,
+	'/':      true,
+	'0':      true,
+	'1':      true,
+	'2':      true,
+	'3':      true,
+	'4':      true,
+	'5':      true,
+	'6':      true,
+	'7':      true,
+	'8':      true,
+	'9':      true,
+	':':      true,
+	';':      true,
+	'<':      true,
+	'=':      true,
+	'>':      true,
+	'?':      true,
+	'@':      true,
+	'A':      true,
+	'B':      true,
+	'C':      true,
+	'D':      true,
+	'E':      true,
+	'F':      true,
+	'G':      true,
+	'H':      true,
+	'I':      true,
+	'J':      true,
+	'K':      true,
+	'L':      true,
+	'M':      true,
+	'N':      true,
+	'O':      true,
+	'P':      true,
+	'Q':      true,
+	'R':      true,
+	'S':      true,
+	'T':      true,
+	'U':      true,
+	'V':      true,
+	'W':      true,
+	'X':      true,
+	'Y':      true,
+	'Z':      true,
+	'[':      true,
+	'\\':     false,
+	']':      true,
+	'^':      true,
+	'_':      true,
+	'`':      true,
+	'a':      true,
+	'b':      true,
+	'c':      true,
+	'd':      true,
+	'e':      true,
+	'f':      true,
+	'g':      true,
+	'h':      true,
+	'i':      true,
+	'j':      true,
+	'k':      true,
+	'l':      true,
+	'm':      true,
+	'n':      true,
+	'o':      true,
+	'p':      true,
+	'q':      true,
+	'r':      true,
+	's':      true,
+	't':      true,
+	'u':      true,
+	'v':      true,
+	'w':      true,
+	'x':      true,
+	'y':      true,
+	'z':      true,
+	'{':      true,
+	'|':      true,
+	'}':      true,
+	'~':      true,
+	'\u007f': true,
+}
+
+// htmlSafeSet holds the value true if the ASCII character with the given
+// array position can be safely represented inside a JSON string, embedded
+// inside of HTML <script> tags, without any additional escaping.
+//
+// All values are true except for the ASCII control characters (0-31), the
+// double quote ("), the backslash character ("\"), HTML opening and closing
+// tags ("<" and ">"), and the ampersand ("&").
+var htmlSafeSet = [utf8.RuneSelf]bool{
+	' ':      true,
+	'!':      true,
+	'"':      false,
+	'#':      true,
+	'$':      true,
+	'%':      true,
+	'&':      false,
+	'\'':     true,
+	'(':      true,
+	')':      true,
+	'*':      true,
+	'+':      true,
+	',':      true,
+	'-':      true,
+	'.':      true,
+	'/':      true,
+	'0':      true,
+	'1':      true,
+	'2':      true,
+	'3':      true,
+	'4':      true,
+	'5':      true,
+	'6':      true,
+	'7':      true,
+	'8':      true,
+	'9':      true,
+	':':      true,
+	';':      true,
+	'<':      false,
+	'=':      true,
+	'>':      false,
+	'?':      true,
+	'@':      true,
+	'A':      true,
+	'B':      true,
+	'C':      true,
+	'D':      true,
+	'E':      true,
+	'F':      true,
+	'G':      true,
+	'H':      true,
+	'I':      true,
+	'J':      true,
+	'K':      true,
+	'L':      true,
+	'M':      true,
+	'N':      true,
+	'O':      true,
+	'P':      true,
+	'Q':      true,
+	'R':      true,
+	'S':      true,
+	'T':      true,
+	'U':      true,
+	'V':      true,
+	'W':      true,
+	'X':      true,
+	'Y':      true,
+	'Z':      true,
+	'[':      true,
+	'\\':     false,
+	']':      true,
+	'^':      true,
+	'_':      true,
+	'`':      true,
+	'a':      true,
+	'b':      true,
+	'c':      true,
+	'd':      true,
+	'e':      true,
+	'f':      true,
+	'g':      true,
+	'h':      true,
+	'i':      true,
+	'j':      true,
+	'k':      true,
+	'l':      true,
+	'm':      true,
+	'n':      true,
+	'o':      true,
+	'p':      true,
+	'q':      true,
+	'r':      true,
+	's':      true,
+	't':      true,
+	'u':      true,
+	'v':      true,
+	'w':      true,
+	'x':      true,
+	'y':      true,
+	'z':      true,
+	'{':      true,
+	'|':      true,
+	'}':      true,
+	'~':      true,
+	'\u007f': true,
+}
diff --git a/examples/gno.land/r/demo/groups_v6/gno.mod b/examples/gno.land/r/demo/groups_v6/gno.mod
new file mode 100644
index 00000000000..e25e3e341fd
--- /dev/null
+++ b/examples/gno.land/r/demo/groups_v6/gno.mod
@@ -0,0 +1 @@
+module gno.land/r/demo/groups_v6
\ No newline at end of file
diff --git a/examples/gno.land/r/demo/groups_v6/group.gno b/examples/gno.land/r/demo/groups_v6/group.gno
new file mode 100644
index 00000000000..8caf16be48f
--- /dev/null
+++ b/examples/gno.land/r/demo/groups_v6/group.gno
@@ -0,0 +1,115 @@
+package groups
+
+import (
+	"std"
+	"strconv"
+	"time"
+
+	"gno.land/p/demo/avl"
+)
+
+type GroupID uint64
+
+func (gid GroupID) String() string {
+	return strconv.Itoa(int(gid))
+}
+
+type Group struct {
+	id               GroupID
+	url              string
+	name             string
+	lastMemberID     MemberID
+	members          avl.Tree
+	membersByAddress avl.Tree
+	creator          std.Address
+	createdAt        time.Time
+	totalWeight      int
+}
+
+func newGroup(url string, name string, creator std.Address) *Group {
+	if !reName.MatchString(name) {
+		panic("invalid name: " + name)
+	}
+	if gGroupsByName.Has(name) {
+		panic("Group with such name already exists")
+	}
+	return &Group{
+		id:        incGetGroupID(),
+		url:       url,
+		name:      name,
+		creator:   creator,
+		members:   avl.Tree{},
+		createdAt: time.Now(),
+	}
+}
+
+func (group *Group) newMember(id MemberID, address std.Address, weight int, metadata string) *Member {
+	if group.members.Has(address.String()) {
+		panic("this member for this group already exists")
+	}
+	if group.membersByAddress.Has(address.String()) {
+		panic("this address is already in this group")
+	}
+	return &Member{
+		id:        id,
+		address:   address,
+		weight:    weight,
+		metadata:  metadata,
+		createdAt: time.Now(),
+	}
+}
+
+func (group *Group) HasPermission(addr std.Address, perm Permission) bool {
+	if group.creator != addr {
+		return false
+	}
+	return isValidPermission(perm)
+}
+
+func (group *Group) RenderGroup() string {
+	str := "Group ID: " + groupIDKey(group.id) + "\n\n" +
+		"Group Name: " + group.name + "\n\n" +
+		"Group Creator: " + string(group.creator) + "\n\n" +
+		"Group createdAt: " + group.createdAt.String() + "\n\n" +
+		"Group Last MemberID: " + memberIDKey(group.lastMemberID) + "\n\n" +
+		"Total Weight: " + strconv.Itoa(group.totalWeight) + "\n\n"
+
+	str += "Group Members: \n\n"
+	group.members.Iterate("", "", func(key string, value interface{}) bool {
+		member := value.(*Member)
+		str += member.getMemberStr()
+		return false
+	})
+	return str
+}
+
+func (group *Group) GetMembers() *avl.Tree {
+	return &group.members
+}
+
+func (group *Group) deleteGroup() {
+	gidkey := groupIDKey(group.id)
+	_, gGroupsRemoved := gGroups.Remove(gidkey)
+	if !gGroupsRemoved {
+		panic("group does not exist with id " + group.id.String())
+	}
+	gGroupsByName.Remove(group.name)
+}
+
+func (group *Group) deleteMember(mid MemberID) {
+	gidkey := groupIDKey(group.id)
+	if !gGroups.Has(gidkey) {
+		panic("group does not exist with id " + group.id.String())
+	}
+
+	g := getGroup(group.id)
+	midkey := memberIDKey(mid)
+	imember, ok := g.members.Get(midkey)
+	if !ok {
+		return
+	}
+	member := imember.(*Member)
+	g.members.Remove(midkey)
+	g.membersByAddress.Remove(member.address.String())
+	group.totalWeight -= member.weight
+}
diff --git a/examples/gno.land/r/demo/groups_v6/groups.gno b/examples/gno.land/r/demo/groups_v6/groups.gno
new file mode 100644
index 00000000000..b1f618c30b5
--- /dev/null
+++ b/examples/gno.land/r/demo/groups_v6/groups.gno
@@ -0,0 +1,21 @@
+package groups
+
+import (
+	"regexp"
+
+	"gno.land/p/demo/avl"
+)
+
+//----------------------------------------
+// Realm (package) state
+
+var (
+	gGroups       avl.Tree // id -> *Group
+	gGroupsCtr    int      // increments Group.id
+	gGroupsByName avl.Tree // name -> *Group
+)
+
+//----------------------------------------
+// Constants
+
+var reName = regexp.MustCompile(`^[a-z]+[_a-z0-9]{2,29}$`)
diff --git a/examples/gno.land/r/demo/groups_v6/member.gno b/examples/gno.land/r/demo/groups_v6/member.gno
new file mode 100644
index 00000000000..d6b47522011
--- /dev/null
+++ b/examples/gno.land/r/demo/groups_v6/member.gno
@@ -0,0 +1,40 @@
+package groups
+
+import (
+	"encoding/binary"
+	"std"
+	"strconv"
+	"time"
+
+	"gno.land/p/demo/binutils"
+)
+
+type MemberID uint64
+
+type Member struct {
+	id        MemberID
+	address   std.Address
+	weight    int
+	metadata  string
+	createdAt time.Time
+}
+
+func (mid MemberID) String() string {
+	return strconv.Itoa(int(mid))
+}
+
+func (member *Member) getMemberStr() string {
+	memberDataStr := ""
+	memberDataStr += "\t\t\t[" + memberIDKey(member.id) + ", " + member.address.String() + ", " + strconv.Itoa(member.weight) + ", " + member.metadata + ", " + member.createdAt.String() + "],\n\n"
+	return memberDataStr
+}
+
+func (member *Member) Bytes() []byte {
+	b := []byte{}
+	b = binary.BigEndian.AppendUint64(b, uint64(member.id))
+	b = append(b, binutils.EncodeLengthPrefixedStringUint16BE(member.address.String())...)
+	b = binary.BigEndian.AppendUint32(b, uint32(member.weight))
+	b = append(b, binutils.EncodeLengthPrefixedStringUint16BE(member.metadata)...)
+	b = binary.BigEndian.AppendUint64(b, uint64(member.createdAt.UnixNano()))
+	return b
+}
diff --git a/examples/gno.land/r/demo/groups_v6/messages.gno b/examples/gno.land/r/demo/groups_v6/messages.gno
new file mode 100644
index 00000000000..812ba2ebfb5
--- /dev/null
+++ b/examples/gno.land/r/demo/groups_v6/messages.gno
@@ -0,0 +1,138 @@
+package groups
+
+import (
+	"encoding/binary"
+	"std"
+	"strconv"
+	"strings"
+
+	"gno.land/p/demo/binutils"
+	"gno.land/p/demo/daodao/interfaces_v3"
+)
+
+type ExecutableMessageAddMember struct {
+	dao_interfaces.ExecutableMessage
+
+	GroupID  GroupID
+	Address  string
+	Weight   int
+	Metadata string
+}
+
+func (msg *ExecutableMessageAddMember) Type() string {
+	return "AddMember"
+}
+
+func (msg *ExecutableMessageAddMember) String() string {
+	var ss []string
+	ss = append(ss, msg.Type())
+	s := "GroupID: " + msg.GroupID.String() + "\n"
+	s += "Address: " + msg.Address + "\n"
+	s += "Weight: " + strconv.Itoa(msg.Weight) + "\n"
+	s += "Metadata: " + msg.Metadata
+	ss = append(ss, s)
+	return strings.Join(ss, "\n---\n")
+}
+
+func (msg *ExecutableMessageAddMember) Binary() []byte {
+	b := []byte{}
+	b = append(b, binutils.EncodeLengthPrefixedStringUint16BE(msg.Type())...)
+	b = binary.BigEndian.AppendUint64(b, uint64(msg.GroupID))
+	b = append(b, binutils.EncodeLengthPrefixedStringUint16BE(msg.Address)...)
+	b = binary.BigEndian.AppendUint32(b, uint32(msg.Weight))
+	b = append(b, binutils.EncodeLengthPrefixedStringUint16BE(msg.Metadata)...)
+	return b
+}
+
+func ExecutableMessageAddMemberFromBinary(b []byte) *ExecutableMessageAddMember {
+	msg := &ExecutableMessageAddMember{}
+	t, b := binutils.MustDecodeLengthPrefixedStringUint16BE(b)
+	if t != msg.Type() {
+		panic("invalid type")
+	}
+	msg.GroupID, b = GroupID(binary.BigEndian.Uint64(b)), b[8:]
+	msg.Address, b = binutils.MustDecodeLengthPrefixedStringUint16BE(b)
+	msg.Weight, b = int(binary.BigEndian.Uint32(b)), b[4:]
+	msg.Metadata, b = binutils.MustDecodeLengthPrefixedStringUint16BE(b)
+	return msg
+}
+
+type AddMemberHandler struct {
+	dao_interfaces.MessageHandler
+}
+
+func NewAddMemberHandler() *AddMemberHandler {
+	return &AddMemberHandler{}
+}
+
+func (h *AddMemberHandler) Execute(imsg dao_interfaces.ExecutableMessage) {
+	msg := imsg.(*ExecutableMessageAddMember)
+	AddMember(msg.GroupID, msg.Address, msg.Weight, msg.Metadata)
+}
+
+func (h *AddMemberHandler) Type() string {
+	return ExecutableMessageAddMember{}.Type()
+}
+
+func (h *AddMemberHandler) FromBinary(b []byte) dao_interfaces.ExecutableMessage {
+	return ExecutableMessageAddMemberFromBinary(b)
+}
+
+type ExecutableMessageDeleteMember struct {
+	dao_interfaces.ExecutableMessage
+
+	GroupID  GroupID
+	MemberID MemberID
+}
+
+func (msg *ExecutableMessageDeleteMember) Type() string {
+	return "DeleteMember"
+}
+
+func (msg *ExecutableMessageDeleteMember) String() string {
+	var ss []string
+	ss = append(ss, msg.Type())
+	s := "GroupID: " + msg.GroupID.String()
+	s += "MemberID: " + msg.MemberID.String()
+	return strings.Join(ss, "\n---\n")
+}
+
+func (msg *ExecutableMessageDeleteMember) Binary() []byte {
+	b := []byte{}
+	b = append(b, binutils.EncodeLengthPrefixedStringUint16BE(msg.Type())...)
+	b = binary.BigEndian.AppendUint64(b, uint64(msg.GroupID))
+	b = binary.BigEndian.AppendUint64(b, uint64(msg.MemberID))
+	return b
+}
+
+func ExecutableMessageDeleteMemberFromBinary(b []byte) *ExecutableMessageDeleteMember {
+	msg := &ExecutableMessageDeleteMember{}
+	t, b := binutils.MustDecodeLengthPrefixedStringUint16BE(b)
+	if t != msg.Type() {
+		panic("invalid type")
+	}
+	msg.GroupID, b = GroupID(binary.BigEndian.Uint64(b)), b[8:]
+	msg.MemberID, b = MemberID(binary.BigEndian.Uint64(b)), b[8:]
+	return msg
+}
+
+type DeleteMemberHandler struct {
+	dao_interfaces.MessageHandler
+}
+
+func NewDeleteMemberHandler() *DeleteMemberHandler {
+	return &DeleteMemberHandler{}
+}
+
+func (h *DeleteMemberHandler) Execute(imsg dao_interfaces.ExecutableMessage) {
+	msg := imsg.(*ExecutableMessageDeleteMember)
+	DeleteMember(msg.GroupID, msg.MemberID)
+}
+
+func (h *DeleteMemberHandler) Type() string {
+	return ExecutableMessageDeleteMember{}.Type()
+}
+
+func (h *DeleteMemberHandler) FromBinary(b []byte) dao_interfaces.ExecutableMessage {
+	return ExecutableMessageDeleteMemberFromBinary(b)
+}
diff --git a/examples/gno.land/r/demo/groups_v6/misc.gno b/examples/gno.land/r/demo/groups_v6/misc.gno
new file mode 100644
index 00000000000..07543ba4a45
--- /dev/null
+++ b/examples/gno.land/r/demo/groups_v6/misc.gno
@@ -0,0 +1,96 @@
+package groups
+
+import (
+	"std"
+	"strconv"
+	"strings"
+
+	"gno.land/r/demo/users"
+)
+
+//----------------------------------------
+// private utility methods
+// XXX ensure these cannot be called from public.
+
+func getGroup(gid GroupID) *Group {
+	gidkey := groupIDKey(gid)
+	group_, exists := gGroups.Get(gidkey)
+	if !exists {
+		panic("group id (" + gid.String() + ") does not exists")
+	}
+	group := group_.(*Group)
+	return group
+}
+
+func incGetGroupID() GroupID {
+	gGroupsCtr++
+	return GroupID(gGroupsCtr)
+}
+
+func padLeft(str string, length int) string {
+	if len(str) >= length {
+		return str
+	}
+	return strings.Repeat(" ", length-len(str)) + str
+}
+
+func padZero(u64 uint64, length int) string {
+	str := strconv.Itoa(int(u64))
+	if len(str) >= length {
+		return str
+	}
+	return strings.Repeat("0", length-len(str)) + str
+}
+
+func groupIDKey(gid GroupID) string {
+	return padZero(uint64(gid), 10)
+}
+
+func memberIDKey(mid MemberID) string {
+	return padZero(uint64(mid), 10)
+}
+
+func indentBody(indent string, body string) string {
+	lines := strings.Split(body, "\n")
+	res := ""
+	for i, line := range lines {
+		if i > 0 {
+			res += "\n"
+		}
+		res += indent + line
+	}
+	return res
+}
+
+// NOTE: length must be greater than 3.
+func summaryOf(str string, length int) string {
+	lines := strings.SplitN(str, "\n", 2)
+	line := lines[0]
+	if len(line) > length {
+		line = line[:(length-3)] + "..."
+	} else if len(lines) > 1 {
+		// len(line) <= 80
+		line = line + "..."
+	}
+	return line
+}
+
+func displayAddressMD(addr std.Address) string {
+	user := users.GetUserByAddress(addr)
+	if user == nil {
+		return "[" + addr.String() + "](/r/users:" + addr.String() + ")"
+	}
+	return "[@" + user.Name() + "](/r/users:" + user.Name() + ")"
+}
+
+func usernameOf(addr std.Address) string {
+	user := users.GetUserByAddress(addr)
+	if user == nil {
+		panic("user not found")
+	}
+	return user.Name()
+}
+
+func isValidPermission(perm Permission) bool {
+	return perm == EditPermission || perm == DeletePermission
+}
diff --git a/examples/gno.land/r/demo/groups_v6/public.gno b/examples/gno.land/r/demo/groups_v6/public.gno
new file mode 100644
index 00000000000..24864082574
--- /dev/null
+++ b/examples/gno.land/r/demo/groups_v6/public.gno
@@ -0,0 +1,116 @@
+package groups
+
+import (
+	"std"
+
+	"gno.land/r/demo/users"
+)
+
+//----------------------------------------
+// Public facing functions
+
+func GetGroupNameFromID(gid GroupID) (string, bool) {
+	groupI, exists := gGroups.Get(groupIDKey(gid))
+	if !exists {
+		return "", false
+	}
+	return groupI.(*Group).name, true
+}
+
+func GetGroupIDFromName(name string) (GroupID, bool) {
+	groupI, exists := gGroupsByName.Get(name)
+	if !exists {
+		return 0, false
+	}
+	return groupI.(*Group).id, true
+}
+
+func CreateGroup(name string) GroupID {
+	// std.AssertOriginCall()
+	caller := std.PrevRealm().Addr()
+	// usernameOf(caller)
+	url := "/r/demo/groups_v4:" + name
+	group := newGroup(url, name, caller)
+	gidkey := groupIDKey(group.id)
+	gGroups.Set(gidkey, group)
+	gGroupsByName.Set(name, group)
+	return group.id
+}
+
+func AddMember(gid GroupID, address string, weight int, metadata string) MemberID {
+	// std.AssertOriginCall()
+	caller := std.PrevRealm().Addr()
+	// usernameOf(caller)
+	group := getGroup(gid)
+	if !group.HasPermission(caller, EditPermission) {
+		panic(caller.String() + " aka " + std.PrevRealm().PkgPath() + " unauthorized to edit group, expected: " + group.creator.String())
+	}
+	/*
+		user := users.GetUserByAddress(std.Address(address))
+		if user == nil {
+			panic("unknown address " + address)
+		}
+	*/
+	mid := group.lastMemberID
+	member := group.newMember(mid, std.Address(address), weight, metadata)
+	midkey := memberIDKey(mid)
+	group.members.Set(midkey, member)
+	group.membersByAddress.Set(address, member)
+	group.totalWeight += weight
+	mid++
+	group.lastMemberID = mid
+	return member.id
+}
+
+func DeleteGroup(gid GroupID) {
+	// std.AssertOriginCall()
+	caller := std.PrevRealm().Addr()
+	group := getGroup(gid)
+	if !group.HasPermission(caller, DeletePermission) {
+		panic("unauthorized to delete group")
+	}
+	group.deleteGroup()
+}
+
+func DeleteMember(gid GroupID, mid MemberID) {
+	// std.AssertOriginCall()
+	caller := std.PrevRealm().Addr()
+	group := getGroup(gid)
+	if !group.HasPermission(caller, DeletePermission) {
+		panic("unauthorized to delete member")
+	}
+	group.deleteMember(mid)
+}
+
+func GetMemberWeightByAddress(gid GroupID, addr std.Address) int {
+	group := getGroup(gid)
+	if group == nil {
+		return 0
+	}
+	member, ok := group.membersByAddress.Get(string(addr))
+	if !ok {
+		return 0
+	}
+	return member.(*Member).weight
+}
+
+func GetGroupTotalWeight(gid GroupID) int {
+	group := getGroup(gid)
+	if group == nil {
+		return 0
+	}
+	return group.totalWeight
+}
+
+func GetMembers(gid GroupID) []Member {
+	group := getGroup(gid)
+	if group == nil {
+		return nil
+	}
+	members := []Member{}
+	group.members.Iterate("", "", func(key string, value interface{}) bool {
+		members = append(members, *(value.(*Member)))
+		return false
+	})
+	return members
+}
diff --git a/examples/gno.land/r/demo/groups_v6/render.gno b/examples/gno.land/r/demo/groups_v6/render.gno
new file mode 100644
index 00000000000..ca5566ae28d
--- /dev/null
+++ b/examples/gno.land/r/demo/groups_v6/render.gno
@@ -0,0 +1,40 @@
+package groups
+
+import (
+	"strings"
+)
+
+//----------------------------------------
+// Render functions
+
+func RenderGroup(gid GroupID) string {
+	group := getGroup(gid)
+	if group == nil {
+		return "missing Group"
+	}
+	return group.RenderGroup()
+}
+
+func Render(path string) string {
+	if path == "" {
+		str := "List of all Groups:\n\n"
+		gGroups.Iterate("", "", func(key string, value interface{}) bool {
+			group := value.(*Group)
+			str += " * [" + group.name + "](" + group.url + ")\n"
+			return false
+		})
+		return str
+	}
+	parts := strings.Split(path, "/")
+	if len(parts) == 1 {
+		// /r/Groups:Group_NAME
+		name := parts[0]
+		groupI, exists := gGroupsByName.Get(name)
+		if !exists {
+			return "Group does not exist: " + name
+		}
+		return groupI.(*Group).RenderGroup()
+	} else {
+		return "unrecognized path " + path
+	}
+}
diff --git a/examples/gno.land/r/demo/groups_v6/role.gno b/examples/gno.land/r/demo/groups_v6/role.gno
new file mode 100644
index 00000000000..3caceba2ef7
--- /dev/null
+++ b/examples/gno.land/r/demo/groups_v6/role.gno
@@ -0,0 +1,8 @@
+package groups
+
+type Permission string
+
+const (
+	DeletePermission Permission = "role:delete"
+	EditPermission   Permission = "role:edit"
+)