Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Teritori's Builder Journey #7

Open
michelleellen opened this issue Jun 8, 2023 · 19 comments
Open

Teritori's Builder Journey #7

michelleellen opened this issue Jun 8, 2023 · 19 comments
Assignees

Comments

@michelleellen
Copy link

michelleellen commented Jun 8, 2023

Welcome Teritori team to the Gno.land hackerspace. The place to introduce yourself and document your journey in Gno.land as contributors and builders of the Gno.land Moderation DAO.

@michelleellen michelleellen changed the title Teritori's Journey Teritori's Builder Journey Jun 8, 2023
@zxxma
Copy link

zxxma commented Jun 8, 2023

Hey there!

I'm zôÖma, core team lead @ Teritori.
We're building an open source Web3 resilient OS for humans & organizations, soon available on desktop & mobile, with an all-in-one decentralized experience.


Teritori x Gno - Bi-weekly Call #0 Report - 06.08.2023

First bi-weekly call to start grant collaboration, share status and upcoming works.
Participants: @zivkovicmilos @michelleellen @zxxma + 5 teritori core team members (will be added here soon).

Current state:

  • We are now entering this summer into the Beta phase of our development, after 5 months of 'Alpha' in production.
  • Beta phase is introducing various important new features (DAO Deployer, Social feed v0.2, Play2Earn, Services Marketplace, Music Player, etc.)
    Grant Mission start! We now start to contribute to Gnolang development, with a first focus on Decentralized Organizations tools, and will contribute to provide tools for the ecosystem (both users and developers) :

GnoDAO Deployer:
Allowing to deploy DAOs on Gnoland, providing various DAO templates, in a great & simple UX
this will allow user to facilitate all specific DAO creations, etc.

Gno Moderation Module:
Allowing to add a decentralized moderation feature on various social network cases (starting from /boards, to social feeds, forums, etc). This module will be a more specific one, since dedicated to a social feature context, and can be even used by a DAO that have been deployed in the GnoDAO Deployer.


Teritori core team contributors:

🥷 JK Gopher
started to build a first GnoDAO standard version v0.1
WIP: Working on Tally endpoint, and after that:

🥷 Norman:
WIP:

  • start porting DAO contract into realms
  • implement GnoDAO v0.1 realms into Teritori DAO Deployer
  • Target is to allow Gno users to deploy a testnet gnodao with templates-ready deployment easily here:
    🔗 https://app.teritori.com/orgs

🥷 Yo1110:
WIP: Studying state of gno /boards & /users
Next:

  • experiment /boards to be integrated into Teritori UI to be able to test moderation DAO
  • experiment /users integration into Teritori UI

🥷 Omniwired:
WIP: Experiment and get knowledge asap on Gno status & /realms
Next:

🥷 zôÖma: Lead + Research
WIP: Research on Decentralized Governances

  • Preparing various DAO Designs templates for GnoDAO Deployer
  • Research around interactions around DAO-to-DAOs interactions and needs
  • Research around DAO <-> features interactions (ie: freelance service <-> dao patterns)

🥷 Ferryman Marketing
WIP: Preparing marketing operations

  • for general Gnoland promotions and developers onboarding
  • for Game of Realms promotion strategy
  • for long term partnerships allowing to develop gnoland

📖 Research & Documentation:
🔗 GnoDAO v0.1 Specs: https://hackmd.io/xmicUqNDQyKFptjxyAWq7g?view
🔗 Schema Moderation DAO v0.1:
🔗 Feed Moderation Pattern v0.1:
https://bafkreifd3eryxvlpi4g4xqde32v4x7oxewiy23zqblm4ssbu5ycrqt5kla.ipfs.nftstorage.link/
🔗 User Profile Moderation Pattern v0.1:
https://bafkreigzxvgsjopqzjgvrnzwqz5fjvrca7knyruk7jvpflatsyjogfwpsy.ipfs.nftstorage.link/
🔗 GnoDAOs repo: https://github.com/TERITORI/gnodaos
🔗 Research around Decentralized Social Feed Algorithm Design:
https://hackmd.io/mVc8J-LcSi6aNLyhx1f6wA?view


Few Identified locking points on current Gno state:

examples:

  • contract to contract interaction without importing it.
  • gas estimation
  • few more, will be detailed later

@n0izn0iz
Copy link

Added support for /r/demo/users in Teritori dApp

@hthieu1110 added /r/demo/users as "name service provider" in our dApp which means: in a lot or places where you would have seen a gno address previously, you now see the /r/demo/users name

We decided to suffix the gno names in our ui with .gno to differentiate them (will be especially useful when we add multi-chain name search)

Started to port DA0-DA0 contracts

I started porting the DA0-DA0 contracts to gno, they probably have vulnerabilities and are no-where complete, but we can create proposals and vote on them

Packages

https://test3.gno.land/p/demo/grc/grc4_group
https://test3.gno.land/p/demo/daodao/interfaces
https://test3.gno.land/p/demo/daodao/core
https://test3.gno.land/p/demo/daodao/voting_grc4
https://test3.gno.land/p/demo/daodao/proposal_single
https://test3.gno.land/p/demo/markdown_utils

Realm

https://test3.gno.land/r/demo/foo_dao_2

In the Teritori dApp

You can also see the DAO in the Teritori dApp

Gno's eval query mechanism seems very powerful :), but the output is hard to handle for now

I have trouble signing transactions with Adena so no web interactions yet

Screenshot 2023-06-13 at 00 13 09
Screenshot 2023-06-13 at 00 15 07

@zxxma
Copy link

zxxma commented Jun 22, 2023

Teritori x Gno - Bi-weekly Call #0 Report - 06.08.2023

Curent state:

We are building first bricks to be able to build decentralized moderation
We're building 2 different DAO standards:

  • First is inspired from Aragon works in Solidity
  • Second is DAODAO (CosmWasm) contracts port

/users & /boards & social feed Integration

  • allowing to use /users in several interfaces (feed, profiles, etc.)
  • allowing to use /boards as a social feed
  • be able to make UI simple in GnoDAODeployer

This two bricks are mandatory to be able to build a the 'ModerationDAO' module and experiment it asap.


🥷 Norman:

  • DAO-DAO contracts port, currently implemented: https://test3.gno.land/r/demo/foo_dao_2

    • weighted membership voting
    • single choice proposal
      • sentiment proposals
      • members updates
    • custom interactive web ui (using gno-js-client and adena)
  • basic /r/demo/users indexing and search (for friendly members update ui)

🥷 Gopher:

  • avl tree implementation
  • Resolve type definition and conversion issues on Gnodao contract
  • Add unit test for IsDAOMember
  • Total voting power calculation logic implementation for init and vpUpdates
  • Update getDAOVotingPower address parameter
  • Add unit test for CreateDAO
  • Introduce new votingPowers variable for common usage on test
  • Complete unit test for CreateProposal
  • Add unit test for VoteProposal
  • Adding unit test for TallyAndExecute

🥷 Yo1110:

  • gno addr -> username
  • integrating Gno boards with Teritori social feed

🥷 Omniwired (Juan):

  • Digged on the documents
  • Followed closely the developements from the team.
  • Updated a Tendermint 2 readme and is close to be merged chore: update README.md gno#870
  • Watched Manfred Seoul video
  • Installed gnokey, etc.
  • No code yet :(

RAW Questions & Notes from Call w/ Jae, Manfred & Core team):

  • Is there an indexing example -> needed for emergent sorted pagination and aggreggates
    • Gnoscan.io is running its own indexer
    • There is an ongoing PR to revamp TX indexing -> feat: add file-based transaction indexing gno#546
    • The new philosophy is to have like a local simple pubsub system where we receive events and then you can plug your own writer to whatever you want (sql, etc)
  • Is there a way to do “dynamic linking”/“dynamic call” ? Useful for generic daos and account abstraction
    • "dynamic" -> not yet; maybe postmainnet; potentialy only on forks (not on the main mainnet)
    • there will be an async way with IBC (can be local IBC) potentially before mainnet
    • maybe: hack can be done today with something like func func RelayCall(fn func()) { if whitelistedAddr { fn() }} if the target function is checking for std.CurrentRealm()
    • example: amino package has a amino.Register(struct{}); then you can call it from another package; it's similar to dynamic package injection
    • TODO @moul: add an example of dynamic contract through anonymous function (closure)
  • Is there a way to give authority to a realm / like std.GetOrigCaller but for the calling realm
  • Is there a way to have state in a package or can we import a realm (useful for registries for example)
    • packages (/p) are pure, and can import pure packages
    • realms (/r) can import other realms and pure packages
    • when a realm import other realms, each realm has its own independent state; a realm can't store another realms' state, but can share primitives; or share p.Struct which is pure and permanent
  • How to properly fetch complex state in clients, should we use binary encoding in render paths?
  • How to pass time for time related check on unit test? ->
    • soon: we will have std.TestSetTime()
  • What assertion library to use to do Equal check
    • answer for clients (TX)
    • answer for Render() from gnoweb
      • let's port p/demo/testify or create p/demo/utestify
      • there is a jaekwon/testify; maybe we should use this one instead
  • Render function is actually required?
    • nope
  • Can we set OrigCaller in tests?
    • yes, std.TestSetOrigCaller(...)

Side topics:

  • Teritori core team will be at EthCC, OsmoCon, Nebular Paris to promote Gnolang
  • Started research on 'GrantsModule' feature that would allow a decentralized Grants Program Manager (later) for DAOs, Companies, etc.
  • Started research on 'Game of Realms' Teritori Interface with a first step: "Introduction Track to Gnolang", and then a second for Phase 2 of GoR, gathering all datas and incentivising contributors with badges & certifications.
  • Started to explore Marketing contributions that could help in Gnolang ecosystem growth.

Next steps:

  • Demo of GnoDAODeployer & GnoDAOManager with UI v0.1
  • Demo of GnoFeed with UI v0.1

@zxxma
Copy link

zxxma commented Jul 10, 2023

🔗 Previous call report here: #7

Current State TLDR:

  • Gno DAO Deployer v0.1 … ██████████ 100% ✔️
    • Aragon POC of implementation
    • DAODAO POC of implementation
  • Gno Moderation Module v0.1 : … ████████▒▒ 85% 💻
    • allowing to moderate content on /boards realm
    • allowing to moderate content on /socialfeed realm
  • Gno Social Feed Integration v0.1 : … ████████▒▒ 75% 💻
    • new socialfeed realm
    • front end integration
  • Game of Realms Integration v0.1 : … ██▒▒▒▒▒▒▒▒ 15% 💻
    • identify interesting quests
  • Associated Documentation … 0% : ...▒▒▒▒▒▒▒▒▒▒
  • Grant Manager Module … 0.1% : ...▒▒▒▒▒▒▒▒▒▒
    • Design UI/UX : bootstrapped

💻 Norman:

  • created generic flagging package
  • forked gno.land/r/demo/groups
    • use PrevRealm().Addr() instead GetOrigCaller() for auth
  • forked gno.land/r/demo/boards
    • add a flagging "manager" instance per board
    • use PrevRealm().Addr() instead GetOrigCaller() for auth
    • add flagging "button" in post render that redirects to cli help page
    • show flags count in post render
    • add a <boardName>/flags render path that shows the most flagged posts for this board
    • clear flags on post delete
  • reworked membership-based voting module to use gno.land/r/demo/groups fork instead of custom group package
  • added executable message system to have proposals that actually do stuff
    • gno.land/r/demo/groups: add/remove members
    • dao proposal module: change settings (threshold/quorum)
    • boards: create board, delete message/thread
  • added demo ui in teritori dapp to create moderated boards and delete flagged posts via DAO proposals
  • opened issues for bugs in gnovm slices and PrevRealm
  • started exploring gnovm code and investigating the slice bug

The gno code is here TERITORI/gno#3, this is still at exploration stage so it's unsafe and will probably change a lot
The ui code is here TERITORI/teritori-dapp#629

Associated questions:

  • Should we create a realm that handles multiple daos (like boards and groups) or one realm per dao? Due to the auth model via PrevRealm, it seems we have to create one realm per dao
  • Is there a way to use encoding/json? This issue seem to indicate that there is a way

💻 Gopher:

  • More unit tests for GnoDAOs
  • Successfully deploy GnoDAO contract on testnet
    • Setup keys, get faucet tokens and RPC endpoint for GnoDAO testnet deployment
    • Install latest version of Gno binaries as previous version's out of date
    • Resolve package import issue for avl on testnet deployment
    • Met some issues interacting with GnoDAOs contract through CLI
    • Update endpoints to use only allowed parameter types, and redeploy
    • Compose tx/query CLI commands for GnoDAO endpoints & test
    • Update unit test for changes made during the deployment stage
    • Investigation on unit test failure with gnodev binary (using gno binary for test now)
  • Investigation on GnoDAOs contract interaction through CLI & JS library
    • querying GnoDAOs contract status response formatting through CLI
    • JS client library functions review
  • Move code to TERITORI/gno repo to raise PR into main gno repo at a stage

Associated questions:

  • When passing array of items, is it normal to pass string with comma separated list? (We used that strategy to avoid array of items which is not supported)
  • Is json package fine to use at Gno? Since map is not compatible, json might be not compatible as well and asking for confirmation.

No official limitation.

  • It was not able to test properly the result without Render function. Gno js client library can fetch the struct in JSON format?

💻 Yo1110:

  • done social_feeds contract
  • done writing tests
  • integrating with UI

🔗 TERITORI/gno#1

Associated questions:

  • How to wait tx done like in ETH
const tx = await doTx();
const result = await tx.wait();
  • Is that possible to return copy of object instead of pointer ? to prevent cross contract call from deleting given object. Ex:
# This does not work
func GetPost(pid PostID) Post {
    postPointer := getPostPointer(pid)
    return &postPointer
}
  • Is that possible to marshal/unmarshal json string/struct ?
  • Dont know why when testing
const admin = std.Address("xxx")
func Test(t *testing.T) {
    std.TestSetOrigCaller(admin)
    std.TestSetOrigSend(std.Coins{{"ugnot", 200000000}}, nil)
    users.Register("", "social_feeds_admin", "")
    ...

in users.Register, the check std.GetCallerAt(2) is not admin, so not the value of std.GetOrigCaller here but its value is std.GetCallerAt(1)


💻 Omniwired:

  • I have successfully set up and tested the first contracts (realms) on Gno.
  • I have updated the "awesome gno" documentation and added an onbloc tutorial. Made PR.
  • Identified some "quests" for future devs to do when onboarding them to GNOLand and PathWar.
  • Started front end and models for the Pathwar challenges, leaderboard, tournaments. On-going.

Out of current scope:

💻 Dadidou (Extra - Preparing future milestone: Multisig Interface)


Side Notes:

  • setup a dedicated Marketing call for
    • Gnoland automated Goodies Shop idea
    • Prepare EthCC connexions
  • setup a dedicated Work session on Pathwar/Game of Realms
    • maybe @ parisian hostel
  • Publish a blogpost about Moderation DAO concept

@zxxma
Copy link

zxxma commented Oct 11, 2023

Teritori Report - 30 September 2023

🗒️ Previous Report:
https://hackmd.io/@zxxma/report-sept-28

TLDR;
We completed the Moderation DAO v0.1 Module Milestone during september, and now focus on upcoming milestone.

Current State TLDR: Moderation DAO Milestone: ✅

Gno DAO Deployer v0.1 … ██████████ 100% ✔️
Gno Moderation Module v0.1 : … ██████████ 100% ✔️
Gno Social Feed Integration v0.1 : … ██████████ 100% ✔️
Gno Documentation v0.1 : ... ██████████ 100% ✔️
Public Articles presenting Modules : ██████████ 100% ✔️

🔗 feat: teritori contracts #1154 - PR Link: gnolang/gno#1154
Available on 🔗 https://app.teritori.com (select Gno Teritori Testnet)

🔖 Associated Documentations:

Moderation DAO:
https://github.com/gnolang/gno/blob/7d9aa49394b5049eacc57effe8b14a556f92e087/examples/gno.land/r/demo/teritori/MODERATION_DAO.md

DAO Deployer Tutorial:
https://github.com/gnolang/gno/blob/7d9aa49394b5049eacc57effe8b14a556f92e087/examples/gno.land/r/demo/teritori/DAO_TUTORIAL.md

Teritori Demo Readme:
https://github.com/gnolang/gno/blob/7d9aa49394b5049eacc57effe8b14a556f92e087/examples/gno.land/r/demo/teritori/README.md

📖 Updated the documentation & tutorials with the faucet and published them on Teritori Gitbook:
- Gno.land Grant Program
- How to get started with Gno.land using Teritori
- Introducing Gno.land Social Feed V0.1
- How to deploy a Gno.land DAO using Teritori


🎯 Upcoming Milestone :

Onchain Project Manager Module v0.1

Onchain task management contracts
The aim of this module is to enable an organization to manage projects securely and transparently.
Through modular Gno contracts, and a Kanban like interface, this tool will ensure visibility in the monitoring of decentralized projects. Use cases identified to date are:

  • Grant Program management
  • Services marketplace for freelancers, etc.
  • Management of a DAO's internal project, requiring collective decision-making for follow-up and payment.
  • ... others will be added, so don't hesitate to contribute.

🚧 Status: User Interface design v0.1 : … █████████▒ 95% 💻
🔗 TERITORI/gno#5 (Escrow PR)

Grants_adm_home Grants_opened Grants_adm_requests Grants_payment

Justice DAO Module v0.1

this module will allow to solve a conflict between buyer and seller using a dedicated DAO. This module will randomly select people to judge the conflict situation without any major conflict of interest. Users randomly selected in the Justice DAO will vote to find the fairest solution to the conflict.

🚧 Status:
We spent around +1 month to start exploring VRF and Justice DAO specs, and then we spent 1 month starting a POC.

#14 TERITORI/gno#10 (VRF + Justice DAO PR)

Current state:

  • Justice DAO enhancement
    • Connect Justice DAO solution to escrow realm to determine the final amount by DAO
    • Update example commands to interact with Justice DAO
    • Add CurrentRealm endpoint on Justice DAO to configure on escrow realm
  • Escrow realm enhancement for grant manager support
    • Design the changes to make for milestone management
    • Update existing endpoints for milestones management (CreateContract, AcceptContract, CompleteContract, CompleteContractByDAO, CancelContract, PauseContract, ResumeContract, RenderContract, GiveFeedback)
    • Milestones management endpoints implementation (PayActiveMilestone, PayAndCompleteActiveMilestone, StartNextMilestone, AddUpcomingMilestone, CancelUpcomingMilestone)
    • Make the contract to be created by one of contractor or funder & accepted by counterparty
    • Deploy a new escrow realm for test

Side contributions on Gno core topics & Dev tools

The team will continue to identify useful tools for developers, to facilitate the onboarding of future developers within the Gno ecosystem.
For example, the list of interesting topics we'd like to continue contributing to:

  • GnoLS
  • GnoVM topics
  • VRF (*Verifiable Random Function)

We use the october month to : 1. review everything related to previous modules 2. bug fixing 3. prepare the next milestone plan.

TERITORI/gno#5 (Escrow PR)
TERITORI/gno#2 (Gnodaos PR)
TERITORI/gno#10 (VRF + Justice DAO PR)

@zxxma
Copy link

zxxma commented Nov 8, 2023

Last update

Quick Report

  • VRF enhancement
    • Add improvement thoughts on VRF
  • Escrow enhancement
    • Communication for dynamic package call possibility in Gnolang
    • Update CompleteContractByConflictHandler functionality to be executed only by conflict resolve module (caller or prevRealmPath)
    • Modify data structure of escrow to handle conflict by dynamic realm & implement SuggestConflictHandler and ApproveConflictHandler
    • Update escrow to render newly added fields conflictHandler, handlerCandidate, handlerSuggestor
    • Add validation on escrow realm for contractor and funder to not be empty
    • Remove daoAdmin & all relevant functions on escrow realm as all the conflicts are solved by modules configured by contract participants
    • Resolve invalid status check on PayActiveMilestone and PayAndCompleteActiveMilestone
    • Write detailed spec for escrow realm & each endpoint and datastructure
      • Write contract fields, status, milestone spec and use case
      • CreateContract, CancelContract, AcceptContract, PauseContract, ResumeContract, PayActiveMilestone, SuggestConflictHandler, ApproveConflictHandler, CompleteContractByConflictHandler, GiveFeedback, PayAndCompleteActiveMilestone, StartMilestone, AddUpcomingMilestone, CancelUpcomingMilestone, CompleteContract, PayAndCompleteActiveMilestone, CurrentRealm, GetContracts, RenderContract, RenderContracts
    • Update to appropriate names for escrow function params and struct fields
    • Realm rendering enhancement and test through CLI
    • Preparation for latest escrow realm and frontend connection
  • Conflict solver template realm
    • Write Conflict Solver Template realm code and spec
    • Compose CLI commands for changed realm and test through CLI

🔗 PR: TERITORI/gno#11

@zxxma
Copy link

zxxma commented Nov 14, 2023

VRF Research Report

Latest VRF codebase
🔗 https://github.com/TERITORI/gno/tree/escrow_justice_update/examples/gno.land/r/demo/teritori/vrf

PR
🔗 https://github.com/TERITORI/gno/pull/11/files

For VRF 0.1 for Gnoland, we use following mechanism.

  • VRF data feeders are available and only those can feed data
  • Long data bytes will be feed into the realm by multiple feeders
  • All of the values provided from those feeders will be combined to generate random data (This will make the random secure enough e.g. when 1 feeder is attacked for server attack - just need at least one trustworthy data feeder)
  • Random data is written up-on the request. That way, noone knows what will be written at the time of requesting randomness.

Use case

VRF can be used by offchain users to request random data or by other realms to get TRUE random value on their operations.

The initial use case is on Justice DAO to determine random members to get voting power on the DAO to resolve conflict between service providers and customers when there are issues between them.

Data structure

VRF utilize two structs, Config for feeders administration, and Request to manage the state of random requests by id.

type Config struct {
	vrfAdmin string
	feeders  []string
}
type Request struct {
	id                   uint64
	requesterAddress     string
	requesterRealm       string
	requiredFeedersCount uint64
	fulfilledCount       uint64
	randomWords          []byte
	fulfillers           []string
}

Realm configuration process

After realm deployment, VRF admin is set by using SetVRFAdmin endpoint.

By VRF admin, feeders are set by using SetFeeders endpoint.

Feeders can be modified by VRF admin at any time.

Note: The random data that's already feed by feeder can not be cancelled by VRF admin.

Random data generation process

  • A user or realm request random words from feedeers by using RequestRandomWords endpoint
  • Feeders monioring the requests check not filled requests and add random words by running FulfillRandomWords endpoint
  • The requester can use RandomValueFromWordsWithIndex or RandomValueFromWords based on the required number of random values

Improvement thoughts

Continuously consuming VRF request

On VRF 0.1, one request is designed for one time use. There might be a possibility where a realm continuously requires random numbers based on interval. And requesting it everytime would require bad UX.

Transfering the ownership of VRF to DAO

To get better trust on VRF, the owner of the VRF will need to be a DAO realm.

Random data source

There should be a software that the feeders run and the versions should be managed, the version should be compatible with the VRF realm.
The software should fetch the bytes from verifiable source to avoid manipulation.

VRF random data feeders performance counting

It can count the number of requests fulfilled for up-time calculation.
And it would be good to add sort of verifiers to ensure that the random data sent is accurate.

VRF random data feeders incentives

It would be good to add sort of mechanism for rewards distribution to random data feeders.

VRF random data feeders onboarding flow

VRF 0.1 is assuming the owner set the data feeders directly, it would be good to let feeders to send request through realm with social profiles, and get it approved by DAO to join as random data feeder.

Random data feeders profile management

Random data feeders can maintain their profile.

Questions

  • Any specific direction that is being discussed internally for VRF at Gnoland core team?
  • Which stuff will be supported on chain level for VRF?

@zxxma
Copy link

zxxma commented Nov 23, 2023

Quick Update

Escrow system realms & Onchain project manager

  • Add SetActiveMilestoneInReview, SetActiveMilestoneInProgress endpoint for milestone status management
  • Add link parameter on AddUpcomingMilestone
  • Add milestone status management on StartMilestone, PayAndCompleteActiveMilestone
  • Update CreateContract endpoint for contract metadata and milestone link and status management
  • Update contract rendering to render milestones and contract metadata for more fields addition
  • Update CLI commands for modified Escrow interfaces and test
  • Resolve strconv & strings not found issue on deployment
  • Test Updated escrow realm with CLI commands and resolve issues
  • Share up-to-date escrow realm code and interaction script for front end

PR: TERITORI/gno#11

Screenshot 2023-11-23 at 22 07 37

Music Feed

We just deployed a kind of "soundcloud like" v1 on the gnosocial feed here (in the Music Feed Tab on top) :
https://app.teritori.com/feed?network=gno-teritori

So in this v0.1, users can now :

  • listen to music when they're browsing in features
  • publish music as artist (check "Music Feed" tab on top) and have it automatically on their userprofile
  • comment tracks
  • tips artists/tracks
  • moderate the "music feed" as for all others content, using the Gno Moderation DAO module
    Screenshot 2023-11-23 at 22 08 13

In next versions, we would like to allow:

  • album creation
  • create playlists (not onchain, it's not necessary since it's for private use)
  • crowd-fund a future album, and generate a nft gated dao with supporters/backers in 3 clicks
  • create a "music record label" (kind of dao of bands/musicians gathering forces?)

Please feel free to test, give feed back, ask for features, no idea is dumb!
(ex: in v3 or v4, we plan to create a world map to be able to listen music by countries... an browse "the teritori" to discover random artists)

If you need some testnet tokens for GnoTeritori testnet, you just have to go on the home of the dApp (on GnoTeritori Testnet only) and you'll find a direct button for faucet. Feel free to ask for help here, we'll airdrop you! Later, we'll also probably invite you in the Moderation DAO, to grow the moderation committee!

@n0izn0iz
Copy link

n0izn0iz commented Mar 18, 2024

Today we had a brainstorm about worxdao bootstrap with gh0st and mikecito, here is the final document, everything is still wip and at early brainstorm/exploration stage, feedbacks are very welcome!!

Worxdao definition / scoping

Ressources

  • manfred presentation about evaluation DAO
    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
  • profile realm
  • github oracle realm

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:
    🔗 https://github.com/gnolang/game-of-realms/tree/main/contributors/moul
    🔗 Create an Offchain Profile/Contributor/Contribution System game-of-realms#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:)
  • 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

  • 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 struct {
    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 struct {
    // ???
}

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 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 realm?

@omarsy
Copy link
Member

omarsy commented Apr 9, 2024

Project Update: WorxDAO Development Progress

Objective

Our current focus is on developing a proof of concept (POC) realm that allows linking a GitHub account with an on-chain address. This realm aims to enable users to associate their GitHub identity with an on-chain address.

Current Status

  1. Linking GitHub Account with On-Chain Address

    • The realm allows a bot to add a public key.
    • The bot can sign the address and GitHub ID account.
    • This functionality permits everyone to link their account on the realm seamlessly.
  2. Blockers and Solutions

    • PR: #1863:
      • This PR enables the realm to verify a signature.
      • Currently in the review stage.
    • PR: #100:
      • This was an issue blocking the publish transaction.
      • Resolved and merged.
  3. Demo

    • We have created a demo showcasing how the flow works:

Next Steps

  1. Aggregate Worx Distribution

    • We have begun development on the aggregate worx distribution.
    • Our focus is on creating a generic aggregator that allows specialized aggregators like contribution to register on it.
  2. Related PRs

    • PR: #17:
      • This PR is related to the development of the generic aggregator.
      • It focuses on allowing specialized aggregators, such as contribution, to register.

@zxxma
Copy link

zxxma commented May 22, 2024

Quick last report :

  • GnoVM

    • Cannot use struct as key of a map: We resolved the issue where structs couldn't be used as keys in maps. This PR has been merged (PR #2044).
    • Go2Gno loses type info: This issue is still awaiting review and merge (PR #2016).
    • Gno Issue with pointer: We proposed a solution (Issue #2060).
    • Stacktrace functionality: We added stacktrace functionality and replaced some uses of Machine.String (PR #2145).
    • Recover not working correctly with runtime panics: We created an issue to address this problem (Issue #2146).
    • Panic when adding a package with subpaths: We worked on this issue and waiting for review and merge PR #2155).
  • Gno lint

    • Printing all the errors from goparser: This improvement is waiting for review and merge (PR #2011).
  • DAO SDK

    • DAO SDK: Waiting Review and merge: PR #1925.
  • Project Manager
    Since we have already a lot in review, before opening a PR on the Gno repo, we're taking time to:

    • Polish the "private" atomic PR
    • Polish the UI
    • Set-up e2e testing with gnodev and a gno-js-client wallet, you can see a demo recording here, the end-goal is to run e2e tests in CI

@zxxma
Copy link

zxxma commented Jun 5, 2024

Quick last report:

  • GnoVM

    • Add stacktrace functionality and replace some uses of Machine.String: This pull request is currently in review discussions with Morgan (PR #2145).
    • Go2Gno loses type info: This issue is Merged (PR #2016).
    • Avoid instantiation of banker on pure package: This change is awaiting review and merge (PR #2248).
    • Missing length check in value declaration: This pull request is also awaiting review and merge (PR #2206).
    • Issue: File line not set on ValueDeclr, ImportDecl, TypeDecl: The issue has been resolved and closed (Issue #2220).
    • File line not set on ValueDeclr, ImportDecl, TypeDecl: The fix has been successfully merged (PR #2221).
  • Gno lint

    • Printing all the errors from goparser: This pull request has been successfully merged (PR #2011).
    • Lint all files in folder before panicking: This pull request is awaiting review and merge (PR #2202).
  • DAO SDK (still waiting for review)
    PR: #1925

Upcoming week focusses:

  • rework social feed contract (cosmwasm and gnolang)
    gno contract: r/demo/teritori/social_feeds on this branch
    teritori contract: https://github.com/TERITORI/teritori-contracts/tree/master/contracts/social-feed
  • re-deploy contracts and gnolang realm on portal loop
  • index social feed on gno (currently it's direct contract queries for gno)
  • Project manager :
    • polish e2e test
    • polish UI to get beta users tests
    • think about the strategy to make it a "stand alone product" estimation
      • new app mode : gnoworker, same codebase, new url
    • show projects list on userpublicprofiles

added to backlog:

  • support cross-chain post queries
  • sign proof-of-ownership for Cosmos + Gnoland + EVM

@zxxma
Copy link

zxxma commented Jul 4, 2024

Quick report:

  • Teritori Realms

  • GnoVM

    • New PRs:

      • Recover Not Working Correctly with Runtime Panics: Addressed an issue with runtime panics in Gnolang. Waiting for review and merge: PR #2484.
      • Annotate does not implement preprocessing error: Started throwing ideas about how to tackle this (Early draft) PR #2206.
    • Still Waiting Reviews:

      • Add Stacktrace Functionality: Implemented stacktrace functionality and replaced some uses of Machine.String. Currently under review: PR #2145.
      • Avoid Instantiation of Banker on Pure Package: This improvement is still awaiting review and merge: PR #2248.
      • Missing Length Check in Value Declaration: This fix is awaiting review and merge: PR #2206.
  • Gno lint

    • Still Waiting Reviews:
      • Lint All Files in Folder Before Panicking: Ensured all files in a folder are linted before the process panics. Waiting for review and merge: PR #2202.

@zxxma
Copy link

zxxma commented Jul 17, 2024

Quick report:

  • Teritori Node
    Updates:

    • Node Setup and Monitoring: We have successfully set up Gno nodes for test4 (validator + sentry) and added alerting mechanisms to monitor the nodes' status and ensure they remains operational.
  • Test 4
    Deployed social_feeds realm on test4
    UI: https://app.teritori.com/feed?network=gno-test4
    Gnoweb: https://test4.gno.land/r/teritori/social_feeds:teritori

  • GnoVM

    Updates:

    • Comment Fixes on Length Check: Made corrections to comments on the missing length check in value declaration: PR #2206.
    • Annotate Specific Reason for Interface Non-Implementation: Added annotations to specify the reason a value does not implement an interface. The PR has been approved and is waiting for merge: PR #2492.

    Pending PRs:

    • Add Stacktrace Functionality: PR #2145.
    • Avoid Instantiation of Banker on Pure Package: PR #2248.
    • Missing Length Check in Value Declaration: PR #2206.
  • Gno Lint

    Pending PRs:

    • Lint All Files in Folder Before Panicking: PR #2202 - Waiting for review and merge.
  • Gno CI

    Updates:

    • Gno Lint Action: We are implementing a POC Gno lint action to detect and report issues using the same mechanism as the golint-action. The temporary repository can be found here.
      Hope we will have a demo next call

    Blockers:

    • Required PR for Linting: We need PR #2202 to be merged. This PR enables linting of all files when running 'gno lint'.

In the background, we are also working on :

  • Prepare upcoming gno task force roadmap adjusted with gno core needs
  • Prepare our internal product features development roadmap priorization:
    - Social feed v2
    - Teritori gno Map
    - Project manager
    - Launchpad
  • Write an article explaining upcoming Teritori OS moves and past contributions
  • Prepare our internal engineers organization update to consolide our team, go IRL events, improve efficiency, etc.
  • Some surprises for 2025.

@zxxma
Copy link

zxxma commented Jul 31, 2024

Report:

  • GnoVM

    Updates:

    • Stacktrace PR: Addressed comments for the stacktrace PR.
    • Length Check PR: Addressed comments for the missing length check in value declaration.
    • New Issues Created:
    • Merged PR: Missing length check in value declaration: PR #2206

    Pending PRs:

    • Add Stacktrace Functionality and Replace (Some) Uses of Machine.String: PR #2145
    • Avoid Instantiation of Banker on Pure Package: PR #2248
  • Gno Lint

    Pending PRs:

    • Lint All Files in Folder Before Panicking: PR #2202 - Waiting for review and merge.
  • Teritori DAPP: Social Feed Map
    allowing to browse a gno social feed by exploring a world map UI. Geolocation is optional, and the address is chosen manually by the user, not automatically by device localization, to protect users while allowing them to view the community in a region, or have fun colonizing an area in groups of gnomees.

    Updates:

    • Map Post Publisher: Implemented a feature to publish posts with geolocations.
    • Indexing Posts:
      • Posts are indexed using the tx-indexer.
      • The tx-indexer runs as an independent service, and we use its GraphQL endpoint to sync all posts to our own database.
      • Detailed process: Documentation.

@zxxma
Copy link

zxxma commented Aug 14, 2024

August 1st to August 14th (Gno Developer Call)

User Public Profile (UPP)

Updates:

  • Integration with Gno Users/Profile: The UPP has been integrated to work seamlessly with Gno user profiles. Details here.
  • UPP Edit Page: Refactored the edit page for smoother functionality.

Social Feed Map

Updates:

  • Backend Optimization: Improved performance when handling a large number of posts. PR #1246.
  • Heatmap: Added a heatmap feature on the social feed for better visualization.

GnoVM

Updates:

  • Merged PR: Added stacktrace functionality and replaced some uses of Machine.String. PR #2145.

Pending PRs:

  • Fix Const Declaration Type: PR #2651.
  • Avoid Instantiation of Banker on Pure Package: PR #2248.

Gno Faucet

Updates:

  • Merged PR: Added a healthcheck endpoint for monitoring the Gno faucet. PR #49.

Gno Playground

Updates:

  • New Issue Created: Identified a bug with the deployment modal on namespace input. Issue #2682.

Gno Lint

Pending PRs:

  • Lint All Files Before Panicking: PR #2202 - Waiting for review and merge.

@zxxma
Copy link

zxxma commented Sep 3, 2024

August 15th to September 2nd

Social Feed Map

  • Frontend: Enhanced the social feed map to display the feed directly on the map. (should be ready for community testing mi-september maximum)

User Public Profile (UPP)

  • Feature Update: Added support for arbitrary fields in user profiles, enhancing customization and flexibility. pr: pull request.

GRC 20 Launchpad

  • Planning: Focused on developing the specification and roadmap for the GRC 20 Launchpad project, which is detailed here.
  • Brainstorms and explorations about gno community owned launchpad fee models and long term visions.

WorxDAO Tooling = Cockpit

  • Collaboration: Had a productive sync session with @moul.
  • Specification: Planned the next steps specification for WorxDAO Tooling, which can be reviewed here :

WorxDAO Tooling & Cockpit

Lexicon

  • Cockpit: A suite of tools that aggregates and presents all relevant data for WorxDAO members, aiding decision-making through data analysis.

Next Steps:

  • Create aggregator realm and display profile aggregator.
  • Develop r/github: Extract raw GitHub metrics and feed them into an oracle.
    • Oracle Example: Gnorkle Oracle
    • Rationale: Enables direct integration and usage of GitHub activity data.
  • Build r/notablecontributions.

1. Tooling Objectives

Cockpit: Data Aggregation

r/cockpit: Initial Data Rendering

  • Purpose: Aggregate data from all sources.
  • Initial Focus: Display information from r/profiles only.

r/github:

  • Data Focus: Raw GitHub metrics (no reviews or scores, just activities such as PRs, issues, etc.).
  • Key Metrics:
    • Number of PRs (monthly, yearly, overall).
    • Number of Commits (monthly, yearly, overall).
    • Lines of Code (monthly, yearly, overall).
    • Number of Open Issues (monthly, yearly, overall).
  • Repositories in Scope: Focus on Gno repositories.
  • Optimization: Automatically push data for the top 100 users to the oracle. Others can claim their data manually.

r/governance: Voting and Participation

  • Data Points: Track voting activities (e.g., number of votes).

r/profile:

  • Data Type: Web metadata, manual entries (bio, description, avatar, etc.).
  • Design Inspiration: Figma Manual Data

r/socialactivities:

  • Interactions: Track interactions with r/boards (e.g., posts, likes, and upvotes).

r/notablecontributions:

  • Reputation System: Members can award points for significant contributions (e.g., notable work like project creation).
    • Example: Manfred awards 50 points to a member for a major contribution.
    • Resource: Notable Contributions

r/support:

  • Support Activities: Track non-development contributions, such as help messages and typo fixes.
    • Potential Sources:
      • r/boards interactions.
      • Discord oracle for checking liked messages.

r/review:

  • Peer Review: Human-driven reviews presented as spider graphs.
  • Criteria:
    1. Code skills
    2. Helper/Maintainer skills
    3. Social skills
    4. Creative skills

V1 Focus

  • Scope: Focus on code-related data.
  • UI Considerations: Simple and functional design (e.g., GitHub calendar, spider graphs).
  • Goal: Create a profile page that aggregates contributions with a minimal design, prioritizing visibility and functionality.
    • Example UI: Gnoweb.
    • Integration: Functional with Gnoweb, with the option to link to a more sophisticated UI like Teritori.

2. WorxDAO Overview

  • Role: On-chain company managing HR, OKRs, bonuses, and more.
  • TBD: dedicated workshop needed in upcoming weeks, probably more info during Turin Retreat.

@zxxma
Copy link

zxxma commented Sep 25, 2024

Report

Sept 2 to Sept 12

Gnorkle & Github Verify Oracle

Launchpad GRC20

Gno Profile

Sept 12 to Sept 25

GnoRealm - Updates:

Gnopls 🆕 by @n0izn0iz

  • POC done, has most features of gopls, tested in gno repo and teritori monorepo

GRC20 Launchpad by @Mikael

Role Manager Exploration 🆕 by @Mikael

GnoVM - Updates:

@zxxma
Copy link

zxxma commented Oct 16, 2024

🆕 September 25 to October 9th - Development Report

Gno

WorxDAO Tooling

DOrg Deployer:

Role Manager:

Misc - Updates:

PR awaiting Review

Questions or blocking points:

  • Integration of notable contributions realms with Gnorkle seems forced

Misc - UX Research & Proof-of-Contrib Experimentation:

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
Development

No branches or pull requests

6 participants