Contract architecture

​

Factory pattern

1. Factory contract (AgoraDaoFactory) deploys new DAO instances
2. Product contract (AgoraDao) represents individual DAOs
3. Registry tracks all deployed DAOs for discovery

// In AgoraDaoFactory.sol:63
function createDao(
    string memory _name,
    string memory _description,
    uint256 _categoryID,
    string memory _imageURI
) external {
    // Create new DAO contract instance
    AgoraDao createdDaoContract = new AgoraDao(address(this), msg.sender);

    // Store in registry
    allDaos.push(newDao);
    daosByUser[msg.sender].push(newDao);
    isDao[address(createdDaoContract)] = true;
}

​

Benefits of factory pattern

​

Contract relationships

​

AgoraDaoFactory relationships

• Ownable (OpenZeppelin) - Provides single owner with admin privileges
• Validation - Provides input validation for DAO creation

• AgoraDao instances via the new keyword

• Array of all DAOs (allDaos)
• Mapping of DAOs by creator (daosByUser)
• Mapping to verify DAO authenticity (isDao)

contract AgoraDaoFactory is Ownable, Validation {
    uint256 public userCounter;
    uint256 public daoCounter;
    Dao[] public allDaos;
    
    mapping(address => Dao[]) public daosByUser;
    mapping(address => bool) internal isDao;
}

​

AgoraDao relationships

• Rol - Provides complete role-based access control system

• fabric - Stores parent factory address for callbacks
• Calls IAgoraDaoFactory.addUserCounter() when users join

• Creator automatically receives DEFAULT_ADMIN_ROLE
• Tracks member count via userCounter

contract AgoraDao is Rol {
    address public fabric;
    uint256 public daoID;
    uint256 public userCounter;

    constructor(address _fabric, address _creator) {
        fabric = _fabric;
        _grantRole(DEFAULT_ADMIN_ROLE, _creator);
        userCounter++;
    }
}

​

Inheritance structure

​

Rol inheritance

abstract contract Rol is AccessControl {
    bytes32 internal constant AUDITOR_ROLE = keccak256("AUDITOR_ROLE");
    bytes32 internal constant TASK_MANAGER_ROLE = keccak256("TASK_MANAGER_ROLE");
    bytes32 internal constant PROPOSAL_MANAGER_ROLE = keccak256("PROPOSAL_MANAGER_ROLE");
    bytes32 internal constant USER_ROLE = keccak256("USER_ROLE");
    
    mapping(bytes32 => address[]) private roleUsers;
    mapping(bytes32 => mapping(address => bool)) private isMemberOfRole;
}

• hasRole(bytes32 role, address account) - Check if account has role
• _grantRole(bytes32 role, address account) - Grant role to account
• _revokeRole(bytes32 role, address account) - Revoke role from account
• DEFAULT_ADMIN_ROLE - Built-in admin role

• Role enumeration via roleUsers mapping
• Batch role assignment via registerRoleBatch()
• Role deletion with array compaction
• Additional permission checks for role assignment

​

Validation inheritance

abstract contract Validation {
    function _createDao(
        string memory _name,
        string memory _description,
        uint256 _categoryID,
        string[] memory _daoCategories
    ) internal virtual {
        require(bytes(_name).length > 0, "Dao name must not be empty");
        require(bytes(_name).length <= 50, "The name of the DAO is very long");
        require(bytes(_description).length > 0, "DAO description must not be empty");
        require(bytes(_description).length <= 500, "The description of the DAO is very long");
        require(_categoryID < _daoCategories.length, "Invalid category ID.");
    }
}

​

State variables and mappings

​

AgoraDaoFactory state

uint256 public userCounter;  // Total unique users across all DAOs
uint256 public daoCounter;   // Total number of DAOs created

Dao[] public allDaos;                      // All DAOs in creation order
mapping(address => Dao[]) public daosByUser;  // DAOs by creator
mapping(address => bool) internal isDao;      // Verify DAO authenticity

string[] internal daoCategories;  // Available DAO categories
// Default: ["SERVICE", "GOVERNANCE", "SOCIAL IMPACT", "ENERGY"]

mapping(address => bool) internal isUser;  // Track unique users

​

AgoraDao state

address public fabric;  // Parent factory contract address

uint256 public daoID;       // Unique identifier (set by factory)
uint256 public userCounter; // Number of members in this DAO

​

Rol state

mapping(bytes32 => address[]) private roleUsers;

mapping(bytes32 => mapping(address => bool)) private isMemberOfRole;

mapping(bytes32 => mapping(address => uint256)) private memberPosition;

​

Events emitted

​

Factory events

event DaoCreated(uint256 indexed daoID, address indexed creator, string indexed name);

​

DAO events

event UserJoined(address indexed user, uint256 userID);

​

Role events

event RoleRegistered(bytes32 indexed role, address indexed user, address indexed executor);
event RoleDeleted(bytes32 indexed role, address indexed user, address indexed executor);

• RoleRegistered - Emitted when a role is granted
• RoleDeleted - Emitted when a role is revoked

​

Data flow diagram

​

Access control matrix

​

Next steps