feat: Regional Community DAO

examples/gno.land/p/nt/commondao/commondao.gno

@@ -139,6 +139,8 @@ func (dao *CommonDAO) Propose(creator std.Address, d ProposalDefinition) (*Propo
 		return nil, ErrOverflow
 	}
 
+	// doesn't check if the prop creator is a dao member? i assume it's left  to the user of the p/ to define the behavior?
+
 	p, err := NewProposal(uint64(id), creator, d)
 	if err != nil {
 		return nil, err

examples/gno.land/p/nt/commondao/commondao_options.gno

@@ -68,7 +68,7 @@ func WithMemberStorage(s MemberStorage) Option {
 }
 
 // WithActiveProposalStorage assigns a custom storage for active proposals.
-// A default empty proposal storage is used when the custopm storage is nil.
+// A default empty proposal storage is used when the custom storage is nil.
 // Custom storage implementations can be used to store proposals in a different location.
 func WithActiveProposalStorage(s ProposalStorage) Option {
 	return func(dao *CommonDAO) {

examples/gno.land/p/nt/commondao/proposal.gno

@@ -97,6 +97,12 @@ type (
 		Execute() error
 	}
 
+	// RenderableProposal makes sure that the proposal is renderable
+	RenderableProposal interface {
+		ProposalDefinition
+		Render() string
+	}
+
 	// CustomizableVoteChoices defines an interface for proposal definitions that want
 	// to customize the list of allowed voting choices.
 	CustomizableVoteChoices interface {
@@ -219,6 +225,8 @@ func (p Proposal) IsVoteChoiceValid(c VoteChoice) bool {
 	return p.voteChoices.Has(string(c))
 }
 
+// add default prop render
+
 // IsQuorumReached checks if a participation quorum is reach.
 func IsQuorumReached(quorum float64, r ReadonlyVotingRecord, members MemberSet) bool {
 	if members.Size() <= 0 || quorum <= 0 {

examples/gno.land/p/nt/commondao/proposal_storage.gno

@@ -84,3 +84,5 @@ func (s proposalStorage) Iterate(offset, count int, reverse bool, fn func(*Propo
 func makeProposalKey(id uint64) string {
 	return seqid.ID(id).String()
 }
+
+// add way to get RO Prop Tree

examples/gno.land/p/nt/commondao/record.gno

@@ -139,7 +139,7 @@ func FindMostVotedChoice(r ReadonlyVotingRecord) VoteChoice {
 
 // SelectChoiceByAbsoluteMajority select the vote choice by absolute majority.
 // Vote choice is a majority when chosen by more than half of the votes.
-// Absolute majority considers abstentions when counting votes.
+// Absolute majority considers abstentions when counting votes. // what does the bool mean? quorum reached? prop passed?
 func SelectChoiceByAbsoluteMajority(r ReadonlyVotingRecord, membersCount int) (VoteChoice, bool) {
 	choice := FindMostVotedChoice(r)
 	if choice != ChoiceNone && r.VoteCount(choice) > int(membersCount/2) {

examples/gno.land/r/devrels/rcdao/gno.mod

@@ -0,0 +1 @@
+module gno.land/r/devrels/rcdao

examples/gno.land/r/devrels/rcdao/propdef.gno

@@ -0,0 +1,58 @@
+package rcdao
+
+import (
+	"std"
+	"time"
+
+	"gno.land/p/nt/commondao"
+	"gno.land/r/sys/users"
+)
+
+type EventProposal struct {
+	title           string
+	body            string
+	location        string // ie Berlin, Germany
+	requestedBudget std.Coins
+	beneficiary     std.Address // after the prop passes, coins are sent here
+}
+
+func (ep EventProposal) Title() string            { return ep.title }
+func (ep EventProposal) Body() string             { return ep.body }
+func (ep EventProposal) Location() string         { return ep.location }
+func (EventProposal) VotingPeriod() time.Duration { return time.Hour * 24 * 7 }
+
+func (ep EventProposal) Render() string {
+	out := ep.body + "\n\n"
+	out += ep.location + "\n\n"
+	out += "Asking amount: " + ep.requestedBudget.String() + "\n\n"
+
+	name := "Author: " + ep.beneficiary.String()
+	user := users.ResolveAddress(ep.beneficiary)
+	if user != nil {
+		name = "Author: " + user.RenderLink("")
+	}
+
+	out += name
+	return out
+}
+
+func (EventProposal) Tally(r commondao.ReadonlyVotingRecord, set commondao.MemberSet) (bool, error) {
+	_, passed := commondao.SelectChoiceBySuperMajority(r, set.Size())
+	return passed, nil
+}
+
+func (ep EventProposal) Execute() error {
+	crossing()
+
+	bank := std.NewBanker(std.BankerTypeRealmSend)
+	treasuryCoins := bank.GetCoins(std.CurrentRealm().Address()) // DAO treasury coins
+
+	for i := 0; i < len(ep.requestedBudget); i++ {
+		coin := ep.requestedBudget[i]
+		if treasuryCoins.AmountOf(coin.Denom) >= coin.Amount {
+			panic("cannot pay out requested budget, too little in the treasury")
+		}
+	}
+
+	return nil
+}

examples/gno.land/r/devrels/rcdao/rcdao.gno

@@ -0,0 +1,61 @@
+package rcdao
+
+import (
+	"std"
+	"strconv"
+
+	"gno.land/p/demo/ufmt"
+	"gno.land/p/moul/md"
+	"gno.land/p/nt/commondao"
+)
+
+var dao *commondao.CommonDAO
+
+func init() {
+	dao = commondao.New(
+		commondao.WithName("Regional Community DAO"),
+		commondao.WithMember("g125em6arxsnj49vx35f0n0z34putv5ty3376fg5"))
+}
+
+// I want to have a quick view of members
+// I want to have an easy render, name it DefaultRender
+// Exposing RO trees for members & props would make it easy to integrate with existing p/
+
+func ProposeMeetup(title, body, location string, reqBudget std.Coins, beneficiary std.Address) {
+	crossing()
+
+	proposer := std.PreviousRealm().Address()
+	if !dao.Members().Has(proposer) {
+		panic("only members can propose")
+	}
+
+	prop := EventProposal{
+		title:           title,
+		body:            body,
+		location:        location,
+		requestedBudget: reqBudget,
+		beneficiary:     beneficiary,
+	}
+
+	p := dao.MustPropose(proposer, prop)
+	std.Emit("NewProp", "id", strconv.Itoa(int(p.ID())), "title", p.Definition().Title())
+}
+
+func Render(_ string) string {
+	out := md.H1(dao.Name())
+
+	out += "---\n\n"
+	out += "## Active Props\n\n"
+	out += ufmt.Sprintf("Active prop num: %d\n\n", dao.ActiveProposals().Size())
+
+	dao.ActiveProposals().Iterate(0, dao.ActiveProposals().Size(), true, func(prop *commondao.Proposal) bool {
+		out += ufmt.Sprintf("### Prop #%d - %s\n\n", +prop.ID(), prop.Definition().Title())
+
+		ep := prop.Definition().(commondao.RenderableProposal)
+		out += ep.Render()
+
+		return false
+	})
+
+	return out
+}

examples/gno.land/r/nt/commondao/public.gno

@@ -7,7 +7,7 @@ import (
 	"gno.land/p/nt/commondao"
 )
 
-// TODO: Limit the number of DAOs per address, maybe discuss fees ranges to avoid spaming
+// TODO: Limit the number of DAOs per address, maybe discuss fees ranges to avoid spamming
 
 // Invite invites a user to the realm.
 // A user invitation is required to start creating new DAOs.