feat: r/gov/dao v2 + r/sys/vars

examples/gno.land/p/gov/dao/gno.mod

@@ -0,0 +1,3 @@
+module gno.land/p/gov/dao
+
+require gno.land/p/gov/proposal v0.0.0-latest

examples/gno.land/p/gov/dao/members.gno

@@ -0,0 +1,34 @@
+package dao
+
+import (
+	"std"
+)
+
+// MemberStore defines the member storage abstraction
+type MemberStore interface {
+	// GetMembers returns all members in the store
+	GetMembers() []Member
+
+	// IsMember returns a flag indicating if the given address
+	// belongs to a member
+	IsMember(address std.Address) bool
+
+	// GetMember returns the requested member
+	GetMember(address std.Address) (Member, error)
+
+	// AddMember attempts to add a member to the store
+	AddMember(member Member) error
+
+	// RemoveMember attempts to remove a member from the store
+	RemoveMember(address std.Address) error
+
+	// UpdateMember attempts to update the member in the store
+	UpdateMember(address std.Address, member Member) error
+}
+
+// Member holds the relevant member information
+type Member struct {
+	Address     std.Address // bech32 gno address of the member (unique)
+	Name        string      // name associated with the member
+	VotingPower uint64      // the voting power of the member
+}

examples/gno.land/p/gov/dao/proposal.gno

@@ -0,0 +1,47 @@
+package dao
+
+import "std"
+
+type Status string
+
+// ACTIVE -> ACCEPTED -> EXECUTED
+// ACTIVE -> NOT ACCEPTED
+var (
+	Active      Status = "active"       // proposal is still active
+	Accepted    Status = "accepted"     // proposal gathered quorum
+	NotAccepted Status = "not accepted" // proposal failed to gather quorum
+	Executed    Status = "executed"     // proposal is executed
+)
+
+func (s Status) String() string {
+	return string(s)
+}
+
+// PropStore defines the proposal storage abstraction
+type PropStore interface {
+	// GetProposals returns the given paginated proposals
+	GetProposals(offset, count uint64) []Proposal
+
+	// GetProposalByID returns the proposal associated with
+	// the given ID, if any
+	GetProposalByID(id uint64) (Proposal, error)
+
+	// GetProposalsByAddress returns the proposals associated
+	// with the given proposer address
+	GetProposalsByAddress(address std.Address) []Proposal
+}
+
+// Proposal is the single proposal abstraction
+type Proposal interface {
+	// GetAuthor returns the author of the proposal
+	GetAuthor() std.Address
+
+	// GetDescription returns the description of the proposal
+	GetDescription() string
+
+	// GetStatus returns the status of the proposal
+	GetStatus() Status
+
+	// GetVotes returns the votes of the proposal
+	GetVotes() []Vote
+}

examples/gno.land/p/gov/dao/types.gno

@@ -0,0 +1,43 @@
+package dao
+
+import (
+	"std"
+
+	"gno.land/p/gov/proposal"
+)
+
+type VoteOption string
+
+const (
+	YesVote VoteOption = "YES"
+	NoVote  VoteOption = "NO"
+)
+
+func (v VoteOption) String() string {
+	return string(v)
+}
+
+// Vote encompasses a single GOVDAO vote
+type Vote struct {
+	Address std.Address // the address of the voter
+	Option  VoteOption  // the voting option
+}
+
+// DAO defines the DAO abstraction
+type DAO interface {
+	// Propose adds a new proposal to the executor-based GOVDAO.
+	// Returns the generated proposal ID
+	Propose(comment string, executor proposal.Executor) (uint64, error)
+
+	// VoteOnProposal adds a vote to the given proposal ID
+	VoteOnProposal(id uint64, option VoteOption) error
+
+	// ExecuteProposal executes the proposal with the given ID
+	ExecuteProposal(id uint64) error
+
+	// GetMembStore returns the member store associated with the DAO
+	GetMembStore() MemberStore
+
+	// GetPropStore returns the proposal store associated with the DAO
+	GetPropStore() PropStore
+}

examples/gno.land/p/nt/simpledao/dao.gno

@@ -0,0 +1,206 @@
+package simpledao
+
+import (
+	"errors"
+	"std"
+
+	"gno.land/p/demo/ufmt"
+	"gno.land/p/gov/dao"
+	pproposal "gno.land/p/gov/proposal"
+)
+
+var (
+	errInvalidExecutor           = errors.New("invalid executor provided")
+	errInsufficientProposalFunds = errors.New("insufficient funds for proposal")
+	errInsufficientExecuteFunds  = errors.New("insufficient funds for executing proposal")
+	errProposalExecuted          = errors.New("proposal already executed")
+	errProposalInactive          = errors.New("proposal is inactive")
+	errProposalExpired           = errors.New("proposal is expired")
+	errProposalNotAccepted       = errors.New("proposal is not accepted")
+
+	errNotGovDAO = errors.New("caller not correct govdao instance")
+)
+
+var (
+	minProposalFeeValue int64 = 100 * 1_000_000 // minimum gnot required for a govdao proposal (100 GNOT)
+	minExecuteFeeValue  int64 = 500 * 1_000_000 // minimum gnot required for a govdao proposal (500 GNOT)
+
+	minProposalFee = std.NewCoin("ugnot", minProposalFeeValue)
+	minExecuteFee  = std.NewCoin("ugnot", minExecuteFeeValue)
+)
+
+// SimpleDAO is a simple DAO implementation
+type SimpleDAO struct {
+	membStore *MembStore
+	propStore *PropStore
+}
+
+// NewSimpleDAO creates a new instance of the simpledao DAO
+func NewSimpleDAO(membStore *MembStore, propStore *PropStore) *SimpleDAO {
+	return &SimpleDAO{
+		membStore: membStore,
+		propStore: propStore,
+	}
+}
+
+func (s *SimpleDAO) Propose(description string, executor pproposal.Executor) (uint64, error) {
+	// Make sure the executor is set
+	if executor == nil {
+		return 0, errInvalidExecutor
+	}
+
+	var (
+		caller      = getDAOCaller()
+		sentCoins   = std.GetOrigSend() // Get the sent coins, if any
+		canCoverFee = sentCoins.AmountOf("ugnot") >= minProposalFee.Amount
+	)
+
+	// Check if the proposal is valid
+	if !s.membStore.IsMember(caller) && !canCoverFee {
+		return 0, errInsufficientProposalFunds
+	}
+
+	// Create the wrapped proposal
+	prop := &proposal{
+		description: description,
+		executor:    executor,
+		author:      caller,
+		votes:       newVotes(),
+	}
+
+	// Add the proposal
+	id, err := s.propStore.addProposal(prop)
+	if err != nil {
+		return 0, ufmt.Errorf("unable to add proposal, %s", err)
+	}
+
+	return id, nil
+}
+
+func (s *SimpleDAO) VoteOnProposal(id uint64, option dao.VoteOption) error {
+	// Verify the GOVDAO member
+	member, err := s.membStore.GetMember(getDAOCaller())
+	if err != nil {
+		return ufmt.Errorf("unable to get govdao member, %s", err)
+	}
+
+	// Check if the proposal exists
+	propRaw, err := s.propStore.GetProposalByID(id)
+	if err != nil {
+		return ufmt.Errorf("unable to get proposal %d, %s", id, err)
+	}
+
+	prop := propRaw.(*proposal)
+
+	// Check the proposal status
+	if prop.GetStatus() == dao.Executed {
+		// Proposal was already executed, nothing to vote on anymore.
+		//
+		// In fact, the proposal should stop accepting
+		// votes as soon as a 2/3+ majority is reached
+		// on either option, but leaving the ability to vote still,
+		// even if a proposal is accepted, or not accepted,
+		// leaves room for "principle" vote decisions to be recorded
+		return errProposalInactive
+	}
+
+	// Check if the proposal executor is expired
+	if prop.executor.IsExpired() {
+		return errProposalExpired
+	}
+
+	// Cast the vote
+	if err = prop.votes.castVote(member, option); err != nil {
+		return ufmt.Errorf("unable to vote on proposal %d, %s", id, err)
+	}
+
+	// Check the votes to see if quorum is reached
+	var (
+		majorityPower = s.membStore.getMajorityPower()
+		yays, nays    = prop.votes.getTally()
+	)
+
+	switch {
+	case yays > majorityPower:
+		prop.status = dao.Accepted
+	case nays > majorityPower:
+		prop.status = dao.NotAccepted
+	default:
+		// Quorum not reached
+	}
+
+	return nil
+}
+
+func (s *SimpleDAO) ExecuteProposal(id uint64) error {
+	var (
+		caller      = getDAOCaller()
+		sentCoins   = std.GetOrigSend() // Get the sent coins, if any
+		canCoverFee = sentCoins.AmountOf("ugnot") >= minExecuteFee.Amount
+	)
+
+	// Check if the non-DAO member can cover the execute fee
+	if !s.membStore.IsMember(caller) && !canCoverFee {
+		return errInsufficientExecuteFunds
+	}
+
+	// Check if the proposal exists
+	propRaw, err := s.propStore.GetProposalByID(id)
+	if err != nil {
+		return ufmt.Errorf("unable to get proposal %d, %s", id, err)
+	}
+
+	prop := propRaw.(*proposal)
+
+	// Check the proposal status
+	if prop.GetStatus() != dao.Accepted {
+		// Proposal is not accepted, cannot be executed
+		return errProposalNotAccepted
+	}
+
+	// Check if the proposal is executed
+	if prop.GetStatus() == dao.Executed {
+		// Proposal is already executed
+		return errProposalExecuted
+	}
+
+	// Check if proposal is expired
+	if prop.executor.IsExpired() {
+		return errProposalExpired
+	}
+
+	// Update the proposal status
+	prop.status = dao.Executed
+
+	// Attempt to execute the proposal
+	if err = prop.executor.Execute(); err != nil {
+		return ufmt.Errorf("error during proposal %d execution, %s", id, err)
+	}
+
+	return nil
+}
+
+func (s *SimpleDAO) GetMembStore() dao.MemberStore {
+	return s.membStore
+}
+
+func (s *SimpleDAO) GetPropStore() dao.PropStore {
+	return s.propStore
+}
+
+// getDAOCaller returns the DAO caller.
+// XXX: This is not a great way to determine the caller, and it is very unsafe.
+// However, the current MsgRun context does not persist escaping the main() scope.
+// Until a better solution is developed, this enables proposals to be made through a package deployment + init()
+func getDAOCaller() std.Address {
+	return std.GetOrigCaller()
+}
+
+// TODO change to r/sys/vars
+const daoPkgPath = "gno.land/r/gov/dao"
+
+// isCallerGOVDAO returns a flag indicating if the
+// current caller context is the active GOVDAO
+func isCallerGOVDAO() bool {
+	return std.CurrentRealm().PkgPath() == daoPkgPath
+}