feat: DAO SDK

examples/gno.land/p/demo/users/types.gno

@@ -1,5 +1,9 @@
 package users
 
+import (
+	"std"
+)
+
 type AddressOrName string
 
 func (aon AddressOrName) IsName() bool {
@@ -12,3 +16,14 @@ func (aon AddressOrName) GetName() (string, bool) {
 	}
 	return "", false
 }
+
+func (aon AddressOrName) IsValid() bool {
+	if len(aon) == 0 {
+		return false
+	}
+	if aon[0] == '@' {
+		// TODO: validate name better
+		return len(aon) >= 2
+	}
+	return std.Address(aon).IsValid()
+}

examples/gno.land/p/demo/users/users_test.gno

@@ -1 +1,58 @@
 package users
+
+import (
+	"testing"
+)
+
+func TestAddressOrNameValidation(t *testing.T) {
+	tests := []struct {
+		name     string
+		address  string
+		expected bool
+	}{
+		{
+			name:     "Valid address",
+			address:  "g18syxa0vh0vmne90mwhtynjet0zgeqf6prh3ryy",
+			expected: true,
+		},
+		{
+			name:     "Invalid address",
+			address:  "0x123456789012345678901234567890123456789",
+			expected: false,
+		},
+		{
+			name:     "Valid name",
+			address:  "@test",
+			expected: true,
+		},
+		{
+			name:     "Invalid name",
+			address:  "test@",
+			expected: false,
+		},
+		{
+			name:     "Empty",
+			address:  "",
+			expected: false,
+		},
+		{
+			name:     "Only @",
+			address:  "@",
+			expected: false,
+		},
+		{
+			name:     "One letter",
+			address:  "@a",
+			expected: true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			result := AddressOrName(test.address).IsValid()
+			if result != test.expected {
+				t.Errorf("Expected %v, got %v", test.expected, result)
+			}
+		})
+	}
+}

examples/gno.land/p/teritori/dao_core/dao_core.gno

@@ -0,0 +1,206 @@
+package core
+
+import (
+	"std"
+	"strconv"
+	"strings"
+
+	dao_interfaces "gno.land/p/teritori/dao_interfaces"
+)
+
+// TODO: add wrapper message handler to handle multiple proposal modules messages
+
+type daoCore struct {
+	dao_interfaces.IDAOCore
+
+	votingModule              dao_interfaces.IVotingModule
+	proposalModules           []dao_interfaces.ActivableProposalModule
+	activeProposalModuleCount int
+	realm                     std.Realm
+	registry                  *dao_interfaces.MessagesRegistry
+}
+
+func NewDAOCore(
+	votingModuleFactory dao_interfaces.VotingModuleFactory,
+	proposalModulesFactories []dao_interfaces.ProposalModuleFactory,
+	messageHandlersFactories []dao_interfaces.MessageHandlerFactory,
+) dao_interfaces.IDAOCore {
+	if votingModuleFactory == nil {
+		panic("Missing voting module factory")
+	}
+
+	if len(proposalModulesFactories) == 0 {
+		panic("No proposal modules factories")
+	}
+
+	core := &daoCore{
+		realm:                     std.CurrentRealm(),
+		activeProposalModuleCount: len(proposalModulesFactories),
+		registry:                  dao_interfaces.NewMessagesRegistry(),
+		proposalModules:           make([]dao_interfaces.ActivableProposalModule, len(proposalModulesFactories)),
+	}
+
+	core.votingModule = votingModuleFactory(core)
+	if core.votingModule == nil {
+		panic("voting module factory returned nil")
+	}
+
+	for i, modFactory := range proposalModulesFactories {
+		mod := modFactory(core)
+		if mod == nil {
+			panic("proposal module factory returned nil")
+		}
+
+		core.proposalModules[i] = dao_interfaces.ActivableProposalModule{
+			Enabled: true,
+			Module:  mod,
+		}
+	}
+
+	// this registry is specific to gno since we can't do dynamic calls
+	core.registry.Register(NewUpdateVotingModuleMessageHandler(core))
+	core.registry.Register(NewUpdateProposalModulesMessageHandler(core))
+	for _, handlerFactory := range messageHandlersFactories {
+		handler := handlerFactory(core)
+		if handler == nil {
+			panic("message handler factory returned nil")
+		}
+
+		core.registry.Register(handler)
+	}
+
+	return core
+}
+
+// mutations
+
+func (d *daoCore) UpdateVotingModule(newVotingModule dao_interfaces.IVotingModule) {
+	if std.CurrentRealm().Addr() != d.realm.Addr() { // not sure this check necessary since the ownership system should protect against mutation from other realms
+		panic(ErrUnauthorized)
+	}
+
+	d.votingModule = newVotingModule
+}
+
+func (d *daoCore) UpdateProposalModules(toAdd []dao_interfaces.IProposalModule, toDisable []int) {
+	if std.CurrentRealm().Addr() != d.realm.Addr() { // not sure this check necessary since the ownership system should protect against mutation from other realms
+		panic(ErrUnauthorized)
+	}
+
+	for _, module := range toAdd {
+		d.addProposalModule(module)
+	}
+
+	for _, moduleIndex := range toDisable {
+		module := GetProposalModule(d, moduleIndex)
+
+		if !module.Enabled {
+			panic(ErrModuleAlreadyDisabled)
+		}
+
+		module.Enabled = false
+
+		d.activeProposalModuleCount--
+		if d.activeProposalModuleCount == 0 {
+			panic("no active proposal modules") // this -> `panic(ErrNoActiveProposalModules)` triggers `panic: reflect: reflect.Value.SetString using value obtained using unexported field`
+		}
+	}
+}
+
+// queries
+
+func (d *daoCore) ProposalModules() []dao_interfaces.ActivableProposalModule {
+	return d.proposalModules
+}
+
+func (d *daoCore) VotingModule() dao_interfaces.IVotingModule {
+	return d.votingModule
+}
+
+func (d *daoCore) VotingPowerAtHeight(address std.Address, height int64) uint64 {
+	return d.VotingModule().VotingPowerAtHeight(address, height, []string{})
+}
+
+func (d *daoCore) ActiveProposalModuleCount() int {
+	return d.activeProposalModuleCount
+}
+
+func (d *daoCore) Render(path string) string {
+	sb := strings.Builder{}
+	sb.WriteString("# DAO Core\n")
+	votingInfo := d.votingModule.Info()
+	sb.WriteString("## Voting Module: ")
+	sb.WriteString(votingInfo.String())
+	sb.WriteRune('\n')
+	sb.WriteString(d.votingModule.Render(""))
+	sb.WriteString("## Supported Messages:\n")
+	sb.WriteString(d.registry.Render())
+
+	sb.WriteString("## Proposal Modules:\n")
+	for i, propMod := range d.proposalModules {
+		if !propMod.Enabled {
+			continue
+		}
+
+		info := propMod.Module.Info()
+		sb.WriteString("### #")
+		sb.WriteString(strconv.Itoa(i))
+		sb.WriteString(": ")
+		sb.WriteString(info.String())
+		sb.WriteRune('\n')
+		sb.WriteString(propMod.Module.Render(""))
+	}
+
+	sb.WriteRune('\n')
+	return sb.String()
+}
+
+func (d *daoCore) Registry() *dao_interfaces.MessagesRegistry {
+	return d.registry
+}
+
+// TODO: move this helper in dao interfaces
+
+func GetProposalModule(core dao_interfaces.IDAOCore, moduleIndex int) *dao_interfaces.ActivableProposalModule {
+	if moduleIndex < 0 {
+		panic("module index must be >= 0")
+	}
+
+	mods := core.ProposalModules()
+	if moduleIndex >= len(mods) {
+		panic("invalid module index")
+	}
+
+	return &mods[moduleIndex]
+}
+
+// internal
+
+func (d *daoCore) executeMsgs(msgs []dao_interfaces.ExecutableMessage) {
+	for _, msg := range msgs {
+		d.registry.Execute(msg)
+	}
+}
+
+func (d *daoCore) addProposalModule(proposalMod dao_interfaces.IProposalModule) {
+	for _, mod := range d.proposalModules {
+		if mod.Module != proposalMod {
+			continue
+		}
+
+		if mod.Enabled {
+			panic(ErrModuleAlreadyAdded)
+		}
+
+		mod.Enabled = true
+		d.activeProposalModuleCount++
+		return
+	}
+
+	d.proposalModules = append(d.proposalModules, dao_interfaces.ActivableProposalModule{
+		Enabled: true,
+		Module:  proposalMod,
+	})
+
+	d.activeProposalModuleCount++
+}