/p/samcrew/basedao
Directory · 18 Files
basedao: Membership and Role Management for DAOs
basedao is a gnolang package that extends the DAOkit framework with comprehensive membership and role management capabilities. It serves as the foundation for most DAO implementation.
1. Core Components
Provides three main types for managing DAO membership and roles:
1// DAO member with assigned roles
2type Member struct {
3 Address string
4 Roles []string
5}
6
7// Contains metadata about DAO roles
8type RoleInfo struct {
9 Name string
10 Description string
11 Color string
12}
13
14// Central component for managing members and roles
15type MembersStore struct {
16 Roles *avl.Tree
17 Members *avl.Tree
18}
MembersStore Usage
Creating and initializing:
1// Create with initial data
2store := basedao.NewMembersStore(
3 []basedao.RoleInfo{
4 {Name: "admin", Description: "Administrators", Color: "#329175"},
5 {Name: "treasurer", Description: "Treasury management", Color: "#F3D3BC"},
6 },
7 []basedao.Member{
8 {Address: "g1admin...", Roles: []string{"admin"}},
9 {Address: "g1user...", Roles: []string{}},
10 },
11)
12
13// Create empty store for dynamic management
14store := basedao.NewMembersStore(nil, nil)
Common operations:
1// Member operations
2store.AddMember("g1new...", []string{"moderator"})
3store.RemoveMember("g1former...")
4isMember := store.IsMember("g1user...")
5count := store.MembersCount()
6
7// Role operations
8store.AddRole(basedao.RoleInfo{Name: "secretary", Description: "Records keeper", Color: "#4A90E2"})
9store.RemoveRole("obsolete-role")
10store.AddRoleToMember("g1user...", "secretary")
11store.RemoveRoleFromMember("g1user...", "moderator")
12
13// Query operations
14hasRole := store.HasRole("g1user...", "admin")
15memberRoles := store.GetMemberRoles("g1user...")
16roleMembers := store.GetMembersWithRole("admin")
17adminCount := store.CountMembersWithRole("admin")
18membersWithoutRoles := store.GetMembersWithoutRole()
19roleInfo := store.RoleInfo("admin") // Get role metadata
20membersJSON := store.GetMembersJSON() // Export as JSON
2. Built-in Actions
Provides built-in actions for common DAO operations. Each action has a unique type identifier:
Action Type Constants
1const ActionAddMemberKind = "gno.land/p/samcrew/basedao.AddMember"
2const ActionRemoveMemberKind = "gno.land/p/samcrew/basedao.RemoveMember"
3const ActionAssignRoleKind = "gno.land/p/samcrew/basedao.AssignRole"
4const ActionUnassignRoleKind = "gno.land/p/samcrew/basedao.UnassignRole"
5const ActionEditProfileKind = "gno.land/p/samcrew/basedao.EditProfile"
6const ActionChangeDAOImplementationKind = "gno.land/p/samcrew/basedao.ChangeDAOImplementation"
Creating Actions
1// Add a member with roles
2action := basedao.NewAddMemberAction(&basedao.ActionAddMember{
3 Address: address("g1newmember..."),
4 Roles: []string{"moderator", "treasurer"},
5})
6
7// Remove member
8action := basedao.NewRemoveMemberAction(address("g1member..."))
9
10// Assign role to member
11action := basedao.NewAssignRoleAction(&basedao.ActionAssignRole{
12 Address: address("g1member..."),
13 Role: "admin",
14})
15
16// Remove role from member
17action := basedao.NewUnassignRoleAction(&basedao.ActionUnassignRole{
18 Address: address("g1member..."),
19 Role: "moderator",
20})
21
22// Edit DAO profile
23action := basedao.NewEditProfileAction(
24 [2]string{"DisplayName", "My Updated DAO Name"},
25 [2]string{"Bio", "An improved description of our DAO"},
26 [2]string{"Avatar", "https://example.com/new-logo.png"},
27)
3. Core Governance Interface
Allow DAO's members to interact through proposals and voting.
Creating Proposals
1// Create a new proposal for members to vote on
2// Returns its proposal ID
3func Propose(req daokit.ProposalRequest) uint64 {...}
4
5type ProposalRequest struct {
6 Title string
7 Description string
8 Action Action
9}
Example - Adding a new member:
1addMemberAction := basedao.NewAddMemberAction(&basedao.ActionAddMember{
2 Address: "g1alice...",
3 Roles: []string{"treasurer"},
4})
5
6proposal := daokit.ProposalRequest{
7 Title: "Add new treasurer",
8 Description: "Proposal to add Alice as treasurer for better fund management",
9 Action: addMemberAction,
10}
11proposalID := Propose(proposal)
Voting on Proposals
1// Cast your vote on an active proposal
2// Available vote: VoteYes, VoteNo, VoteAbstain
3func Vote(proposalID uint64, vote daocond.Vote) {...}
4
5Vote(1, daocond.VoteYes) // Vote yes on proposal #1
6Vote(2, daocond.VoteNo) // Vote no on proposal #2
7Vote(3, daocond.VoteAbstain) // Vote abstain on proposal #3
Executing Proposals
1// Execute a proposal that has passed its voting requirements.
2// cur is threaded down to the action handler so it can perform cross-realm calls.
3func Execute(cur realm, proposalID uint64) {...}
4
5Execute(cross(cur), 1) // Execute proposal #1 -- only works if it has enough votes
Instant Execution
Skip the voting process and execute a proposal immediately if you have the required permissions:
1// This performs: Propose() -> Vote(VoteYes) -> Execute()
2proposalID := daokit.InstantExecute(DAO, proposal, cur)
Useful for admin actions, migrations, and emergency procedures.
Rendering DAO Information
Built-in render paths:
/- Main DAO overview with basic info/members- Member list with roles and permissions/proposals- Proposal list with their status and voting progress/proposals/{id}- Detailed view of a proposal with vote breakdown/config- DAO configuration and governance rules/roles- Available roles and their descriptions
You can add or overwrite renders by providing a custom RenderFn in the DAO configuration.
4. Creating a DAO with basedao
4.1 Basic DAO Setup
1package my_dao
2
3import (
4 "gno.land/p/samcrew/basedao"
5 "gno.land/p/samcrew/daocond"
6 "gno.land/p/samcrew/daokit"
7)
8
9var (
10 localDAO daokit.DAO // Local interface for DAO interaction
11 daoPrivate *basedao.DAOPrivate // Full access to internal DAO state
12)
13
14func init(cur realm) {
15 // Set up roles
16 roles := []basedao.RoleInfo{
17 {Name: "admin", Description: "Administrators", Color: "#329175"},
18 {Name: "member", Description: "Regular members", Color: "#21577A"},
19 }
20
21 // Add initial members
22 members := []basedao.Member{
23 {Address: "g1admin...", Roles: []string{"admin"}},
24 {Address: "g1user1...", Roles: []string{"member"}},
25 {Address: "g1user2...", Roles: []string{"member"}},
26 }
27
28 store := basedao.NewMembersStore(roles, members)
29
30 // Require 60% of members to approve proposals
31 condition := daocond.MembersThreshold(0.6, store.IsMember, store.MembersCount)
32
33 // Create the DAO (cur is threaded so the DAO can perform cross-realm calls)
34 localDAO, daoPrivate = basedao.New(&basedao.Config{
35 Name: "My DAO",
36 Description: "A simple DAO example",
37 Members: store,
38 InitialCondition: condition,
39 }, cur)
40}
41
42// Create a new Proposal to be voted on
43// To execute this function, you must use a MsgRun (maketx run)
44// See why it is necessary in Gno Documentation: https://docs.gno.land/users/interact-with-gnokey#run
45func Propose(cur realm, req daokit.ProposalRequest) {
46 localDAO.Propose(req)
47}
48
49// Allows DAO members to cast their vote on a specific proposal
50func Vote(cur realm, proposalID uint64, vote daocond.Vote) {
51 localDAO.Vote(proposalID, vote)
52}
53
54// Triggers the implementation of a proposal's actions
55func Execute(cur realm, proposalID uint64) {
56 localDAO.Execute(proposalID, cur)
57}
58
59// Render generates a UI representation of the DAO's state
60func Render(path string) string {
61 return localDAO.Render(path)
62}
4.2 Configuration Options
1type Config struct {
2 // Basic DAO information
3 Name string
4 Description string
5 ImageURI string
6
7 // Core components
8 Members *MembersStore
9
10 // Feature toggles
11 NoDefaultHandlers bool // Skips registration of default management actions (add/remove members, etc.)
12 NoDefaultRendering bool // Skips setup of default web UI rendering routes
13 NoCreationEvent bool // Skips emitting the DAO creation event
14
15 // Governance configuration
16 InitialCondition daocond.Condition // Default condition for all built-in actions, defaults to 60% member majority
17
18 // Profile integration (optional)
19 SetProfileString ProfileStringSetter // Function to update profile fields (DisplayName, Bio, Avatar)
20 GetProfileString ProfileStringGetter // Function to retrieve profile fields for members
21
22 // Advanced customization hooks
23 SetImplemFn SetImplemRaw // Function called when DAO implementation changes via governance
24 MigrationParamsFn MigrationParamsFn // Function providing parameters for DAO upgrades
25 RenderFn RenderFn // Rendering function for Gnoweb
26 CallerID CallerIDFn // Custom function to identify the current caller, defaults to realmid.Previous
27
28 // Internal configuration
29 PrivateVarName string // Name of the private DAO variable for member querying extensions
30}
5. DAO Upgrades and Migration
Supports upgrading DAO implementations through governance proposals, allowing DAOs to evolve over time.
5.1 Configuration for Upgrades
1DAO, daoPrivate = basedao.New(&basedao.Config{
2 // ... other config
3 MigrationParamsFn: func() []any { return nil }, // Parameters passed to migration function
4
5 SetImplemFn: setImplem,
6}, cur)
7
8// Update DAO variable after migration
9func setImplem(newDAO daokit.DAO) {
10 DAO = newDAO
11}
5.2 Migration Process
1// Migration function signature (rlm is threaded so the migration can create a new DAO)
2type MigrateFn = func(prev *DAOPrivate, params []any, rlm realm) daokit.DAO
3
4// Parameters function signature
5type MigrationParamsFn = func() []any
6
7// 1. Define migration function
8// params contains data from MigrationParamsFn - use for config, settings, etc.
9func migrateTo2_0(prev *basedao.DAOPrivate, params []any, rlm realm) daokit.DAO {
10 // Preserve existing member store
11 memberStore := prev.Members
12
13 // Add new roles for v2.0
14 memberStore.AddRole(basedao.RoleInfo{
15 Name: "auditor",
16 Description: "Financial oversight",
17 })
18
19 // Create new DAO with enhanced features
20 newLocalDAO, newPrivate := basedao.New(&basedao.Config{
21 Name: prev.InitialConfig.Name + " v2.0",
22 Description: "Upgraded DAO with audit capabilities",
23 Members: memberStore,
24 InitialCondition: prev.InitialConfig.InitialCondition,
25 // ... other configuration
26 }, rlm)
27
28 return newLocalDAO
29}
30
31// 2. Create and submit upgrade proposal
32action := basedao.NewChangeDAOImplementationAction(migrateTo2_0)
33proposal := daokit.ProposalRequest{
34 Title: "Upgrade to DAO v2.0",
35 Description: "Adds auditor role and enhanced governance",
36 Action: action,
37}
38proposalID := DAO.Propose(proposal)
39
40// 3. Execute Migration
41DAO.Execute(proposalID, cur)
42
43// Alternatively, you can use InstantExecute to skip the voting process
44// if you have sufficient permissions to execute the action directly
45daokit.InstantExecute(DAO, proposal, cur)
6. Event System
Events are emitted when actions happen in your DAO. This helps track activities.
1// DAO creation (only if NoCreationEvent is false)
2chain.Emit("BaseDAOCreated")
3
4// Member management
5chain.Emit("BaseDAOAddMember", "address", memberAddr)
6chain.Emit("BaseDAORemoveMember", "address", memberAddr)
7. Membership Extension
Allows other packages and realms to check if an address is a member of your DAO.
Usage
1import "gno.land/p/samcrew/basedao"
2
3// Check if someone is a DAO member
4ext := basedao.MustGetMembersViewExtension(localDAO)
5if ext.IsMember("g1user...") {
6 // User is a member
7}
Example: Member-Only action
The DAO value is kept unexported in the DAO realm, so expose a read-only membership check for other realms:
1package my_dao
2
3// IsMember reports whether addr is a member of this DAO.
4func IsMember(addr string) bool {
5 return basedao.MustGetMembersViewExtension(localDAO).IsMember(addr)
6}
Other realms can then gate actions on membership:
1package my_content
2
3import (
4 "chain/runtime/unsafe"
5
6 "gno.land/r/some/dao"
7)
8
9func Post(title, content string) {
10 caller := unsafe.PreviousRealm().Address()
11
12 if !dao.IsMember(caller.String()) {
13 panic("Only DAO members can post")
14 }
15
16 createPost(title, content)
17}
The extension is automatically registered when you create a DAO with basedao.New().
Part of the daokit framework for building decentralized autonomous organizations in gnolang.
