Chicago Ethereum Meetup’s Experiment in Quadratic Funding
Written by Spencer Graham and Paul Cowgill
The Chicago Ethereum Meetup is a local community that has been meeting roughly once per month since 2015. Typically, our meetups consist of a speaker or two across a mix of mostly technical Ethereum-related topics. This year, we wanted to vary the format to include more experiments and hands-on activities.
To help make these experiments a reality we asked the Ethereum Foundation for a grant, and they were generous enough to provide us with $1000!
We included a few ideas in our grant proposal, but we quickly realized that we should give the Chicago Ethereum community a voice in choosing the experiments we would run. Having just heard the Gitcoin team speak at our December meetup, we were inspired to run our own small version of a Quadratic Funding / CLR round, which would double as our first experiment.
The QF Experiment
We decided to kick off the funding round at our February meetup. Here’s what we did to prepare:
- We wrote a smart contract (code; Etherscan) to accept contributions from backers, record the amounts, and then route them to the various experiments (“projects”)
- We made a Gnosis Safe for each project to collect the contributions
- We wrote a Python script to read the contribution data from our contract and calculate the CLR matching amounts
During the meetup event, we introduced the concept and asked attendees to make contributions to the project(s) of their choice. Since our top priority was participation, we removed the cost barrier by sending each attendee 10 DAI to give to the projects (we politely asked that they not abscond with the 10 DAI). Attendees could also contribute using their own funds if they wished.
QF Results
Here are select raw results. For the full results, and to see the code we used to read data from our contract, calculate the CLR matching, and create these plots, check out our Jupyter notebook.
Three projects received the lion’s share of the matching funds — one in particular. humanity_dao and noloss_lotto each pulled in over 50 DAI in total contributions, while pizza attracted 250 DAI and nearly half the total matching funds!
The broader Chicago Ethereum community showed overwhelmingly that the best use of funds is to pay for food at our meetups. While it’s hard to argue that the attractiveness of free food didn’t play a role here, it’s also likely that backers consider meetup refreshments as a relatively high leverage way to grow the community. People have come to expect food at meetups, and we haven’t always been able to provide that at our meetups. Under that interpretation, pizza is a public good!
Zooming out, let’s take a look at how the CLR algorithm performed. Pretty well! Projects with larger amounts contributed by the community received a higher proportion of matched funds. But at a similar overall contribution level, projects with lower average contributions — reflecting a more distributed base of support — received an even higher proportion of matched funds. This is exactly what QF and CLR are designed to do.
QF Experiment Takeaways
This experiment was a good start. There were some challenges, and we ran into some hiccups. But there were also some surprisingly good outcomes!.
What Went Well?
- Meetup attendees came up with a few proposal projects — coffee coin, coffee forward, and budgeting DAO — to supplement our initial list, all three of which beat out two of our ideas — hooray for community involvement!
- A handful of attendees did not have wallets capable of browsing dapps, so we walked them through the steps of setting up a mobile dapp browser (Trust Wallet or MetaMask mobile). For some this was their first interaction with a dapp!
- The event was a lot of fun! Even with some UX challenges — or perhaps because of them? — the meetup went extremely well. All the attendees were engaged, and many told us that this was one of the more interesting meetups we’ve put on. Oh, and last (and least), it was a very rewarding experience for the organizers 😉.
- No one Sybil-attacked us.
What Was Challenging?
- While we had pretty good engagement within the Chicago community, there was not a lot of participation outside of Chicago despite some tweets. This isn’t terribly unexpected since the exercise was geared towards the Chicago community, but we were hoping to attract some additional attention to the experiment.
- We ran into a number of user experience challenges (see the next section for more detail).
- We had issues with executing transactions in the Gnosis Safe (for teams) UI, which caused some pain. The Gnosis Safe team helped us get past the issues and do what we needed to do, and we believe those issues are now resolved.
- Turning each send in real time into a multi-transaction process slowed us down significantly. We probably should have used Linkdrop, but we didn’t because they don’t yet have MetaMask mobile as an option, and we wanted to support a range of different wallets. If we were to do it again, we would enforce either laptop or mobile and have everyone use the same type of wallet.
UX Difficulties
Since we had limited time and resources to execute this experiment, we made several scope-constraining decisions. The most impactful decision was to forgo developing our own user interface and instead rely on tools like oneclickdapp.com as a very raw way for participants to interact with our dapp.
This forced attendees and other participants to:
- First approve our contract to spend their DAI (via either Etherscan’s write contract functionality or a oneclickdapp we created) before using a separate oneclickdapp to actually contribute to projects.
- Manually scale DAI values up by a factor of 10¹⁸ since Solidity can’t handle decimals. This was especially challenging because oneclickdapp.com doesn’t accept scientific notation, and our workaround using DuckDuckGo’s calculator turned out to be more challenging than helpful. In retrospect, we should have provided a reference table from which backers could copy the scaled-up values for common contribution amounts—e.g. “3 DAI = 3000000000000000000”. A couple backers ran into later issues because they only approved our contract to spend a tiny amount of DAI, and a couple other backers initially only contributed a tiny amount of DAI to their chosen projects.
Waiting for transactions to be mined caused some delays as well, which compounded these interaction challenges.
Eventually, we were able to work with participants to get through all these issues. And, the upside was that these issues allowed us to demonstrate and discuss the inner workings of Ethereum with our attendees, which made for good content.
Ultimately, though, this experiment demonstrated just how valuable good UX design is.
Our Next Steps
Now that the contributions and the results are in, here are our next steps:
- Present the results to our attendees during an upcoming meetup
- Order pizza for our next in-person meetup
- Begin work on the Ethereum Chicago versions of a no loss lottery and Humanity DAO. If you’re interested in helping out, please get in touch!
Appendix 1: What were these projects anyway?
bonding_curve — Funds to seed the reserve currency in a bonding curve that mints (and buys back) Chicago Ethereum tokens. These tokens could be used for a number of future projects within the Chicago Ethereum ecosystem.
budgeting_dao — A dapp that facilitates group budget allocation and manages spending permissions.
coffee_coin — A protocol for tokenizing small favors (e.g. buying somebody a coffee), creating a "favor economy".
coffee_forward — A dapp that makes it easy for people to pay for coffee (or tea!) for somebody else in line behind them (or virtually), and perhaps to be recognized for their generosity.
humanity_dao — A Chicago Ethereum version of the Humanity DAO registry of verified humans, which could be used as an Sybil-resistant list of unique humans for future Chicago Ethereum funding rounds, governance decisions, or even games.
noloss_lotto — A Chicago Ethereum version of PoolTogether.
pizza — Funds for food and drinks at Chicago Ethereum meetups.
unisocks — A Chicago Ethereum version of Unisocks, selling clothing (e.g. a shirt, socks, beanie, etc.) via a token on Uniswap.
Appendix 2: How to run your own version
Do you host an Ethereum meetup? Do you want to experiment with public goods funding for your community? If you’re interested in running your own version of this exercise, here’s what you’ll need:
- Fork our GitHub repo.
- Consider building a custom UI to avoid the UX challenges we faced.
- Deploy your own version of the EthChicagoQF.sol smart contract.
- Create an initial list of projects to fund, create Ethereum accounts for them (we used Gnosis Safes to help manage and protect funds, but any Ethereum account will work), and add the project names and addresses to the contract registry.
- Find a source of matching funds, perhaps with a grant application to the Ethereum Foundation.
- Announce it to your community, and go!
