# Worxdao definition / scoping

## Ressources

- [manfred presentation about evaluation DAO](https://gnolang.github.io/workshops/presentations/2023-06-06--buidl-asia--manfred/presentations.slide.html#3)
key takeaway:
^worx:
- symbol for quantifying contributions
- broadens contribution definition beyond traditional work
- signifies appreciation for all forms of contribution, fostering engagement, creativity and collaboration
- plural form for diversity and unquantifiable nature of contributions
- not tradable (not $WORX), but holds value within the community
- potential for annotations with tags with tags for automatic quantified expertises
- empowers contributors, promotes a sense of ownership
- one of the main metrics used in the Contributors DAO
- [game of realm main issue](https://github.com/gnolang/game-of-realms?tab=readme-ov-file)
- [profile realm](https://github.com/gnolang/gno/pull/181)
- [github oracle realm](https://github.com/gnolang/gno/pull/1134)

## Lexicon

- Contribution DAO: authority structure of the chain (not in scope)
- Worx DAO: aggregate worx distribution as well as other relevant data for a gno contributor (main scope)
- Evaluation DAO: rate contribution and distribute worx (mocked version in scope)
- Support DAO: rate support contribution and distribute worx (mocked version in scope)

## grant proposal

- [ ] Define worxdao interfaces used to provide data about an user to the worxdao (contributions, scores, user-defined, etc..)
- [ ] Create a worxdao data-providers registry, permissioned with a single admin address first
- [ ] Create demo worxdao data-providers, user-defined profile, mock evaluation-dao, mock support-dao, etc..
- [ ] Allow to link a GitHub account with an address on-chain (or contribute with gno core mates on it)
Based on this Contributor Profile approach examples:
:link: https://github.com/gnolang/game-of-realms/tree/main/contributors/moul
:link: https://github.com/gnolang/game-of-realms/issues/10
- [ ] Fill gno user profile on Teritori UI with worxdao data (linkedin-like ux)
- [ ] Create a gnoweb-targeted Render() with worxdao data for an user (something like /r/worxcontributor:<addr>)
- [ ] Write documentation for the gno code (architecture overview, how to create a new data-provider, etc..)
- [ ] Build a Gno WorxDAO Leaderboard
- with accurate indexers and UI
- for last weeks, months, etc.
- rising stars, etc.
- leaving contributors
- allowing to see most important contributors and associated metrics
- [ ] Build a Gno WorxDAO 'Admin' Dashboard
- allowing to administrate and review WorxDAO data-providers

## tasks

- [x] decide if we push or pull
- we pull for poc
- [ ] define interfaces between aggregator and providers
- [ ] define aggregator public functions
- [ ] implement aggregator (worxdao) public functions
- [ ] implement mock evaluation dao
- admin can add data
- [ ] implement mock support dao
- random data

## exploration

### gno.land/r/worxdao with precise types

type WorxDistrib {
    Points uint64
    Rationale string
    Source string
}

/* example
worxDistrib = [{
    Points: 42
    Rationale: "helped the new intern"
    Source: "gno.land/r/supportdao"
}, {
    Points: 21
    Rationale: "developed X feature"
    Source: "gno.land/r/evaluationdao"
}]
*/

interface WorxDistributor {
    WorxPoints(addr std.Address) []WorxDistrib
    WorxSum(addr std.Address) uint64
}

type Contrib {
    // ???
}

interface ContribDistributor {
    Contribs(addr std.Address) []Contrib
}

var admin std.Address
var worxDistributors []WorxDistributor

func WorxPoints(addr std.Address) []WorxDistrib {
    all := []WorxDistrib{}
    for d := range worxDistributors {
        all = append(all, d.WorxPoints(addr)...)
    }
    return all
}

func Get(funcName string, addr std.Address) []WorxDistrib {
    all := []WorxDistrib{}
    for d := range worxDistributors {
        all = append(all, d.(addr)...)
    }
    return all
}

func exampleGet() {
    ret := Get("Worxpoint", addr).(WorxDistrib) ??
    
}

func WorxSum(addr std.Address) uint64 {
    // ...
}


func RegisterWorxDistributor(wd WorxDistributor) {
    if (std.PrevRealm().Addr() != admin) {
        panic("nonono")
    }
    worxDistributors = append(worxDistributors, wd)
}

### gno.land/r/worxdao with any

interface WorxDataProvider {
    Get(dataName string, addr std.Address) any
}

var admin std.Address
var dataProviders []WorxDataProvider

func Get(dataType string, addr std.Address) []any {
    all := []any{}
    for d := range dataProviders {
        all = append(all, d.Get(dataType, addr)...)
    }
    return all
}

func exampleGet() {
    ret := Get("Worxsum", addr)
    for r := range ret {
        switch r.(type) {
        case WorxSum: 
            // do something with worx points
        }
    }
}


func RegisterDataProvider(dp WorxDataProvider) {
    if (std.PrevRealm().Addr() != admin) {
        panic("nonono")
    }
    dataProviders = append(dataProviders, dp)
}

### gno.land/r/worxdao with any and avl

interface WorxDataProvider {
    Get(dataName string, addr std.Address) any
    SupportedTypes() []string
}

var admin std.Address
var dataProviders []WorxDataProvider
var dataTypeToDataProvider avl.Tree

func Get(dataType string, addr std.Address) []any {
    all := []any{}
    dataProviders :=  dataTypeToDataProvider.get(dataType)
    for d := range dataProviders {
        all = append(all, d.Get(dataType, addr)...)
    }
    return all
}

func exampleGet() {
    ret := Get("Worxsum", addr)
    for r := range ret {
        switch r.(type) {
        case WorxSum: 
            // do something with worx points
        }
    }
}


func RegisterDataProvider(dp WorxDataProvider) {
    if (std.PrevRealm().Addr() != admin) {
        panic("nonono")
    }
    for supp := range dp.SupportedTypes() {
        providers := dataTypeToDataProvider.get(supp)
        providers = append(providers, dp)
        dataTypeToDataProvider.set(supp, providers)
    }
}

## questions

gh0st: Why the name worxDAO ?
norman: worxaggregator better?
norman: should we pull r/profile data in worxdao?