Introduction
This document discusses two methods for implementing voting with respect in Notion and Snapshot via the Notion API. The first method involves using the Notion API to input respect scores into a Notion database and voting using the Upvote button in Notion. The second method involves mirroring Notion pages into Snapshot and allowing community members to vote in Snapshot, with the voting results imported back into Notion using the Notion API. The document provides details and considerations for each method, as well as potential integrations and related resources.
Table of Contents
- Introduction
- How to Vote with Respect
- Option 1: Vote in Notion
- Option 2: Vote in Snapshot
- Summary
- Priority and Rationale
- Collaborative Approach
- Implementations in Apps
- Fractal App
- Respect Trees
- Cignals
- Copinions
- Brand Decisions
- Technical Integrations
- OSO and Optimism Collective Metric-Based Evalution
- Auxiliary Respect Tokens
- The Graph and Substreams
- EasyRetroPGF.xyz
- Considerations
- Alternative Voting Strategies
- Alternatives to Snapshot
- Alternatives to Notion
- Related Resources
How to Vote with Respect
It would be amazing to do weighted voting based on respect tokens in notion and I think there are a two different ways that we could achieve this. There is a simpler way is described first and a more complex method is below:
Option 1: Vote in Notion
We can use the Notion API to input Respect scores into a notion database that shows the amount of Respect as a property for each community member, then vote using the Upvote button directly in notion.
This could work with the way described in this page and a conceptual framework for this can be found here. With this method, there would be no need to connect a wallet or provide a EVM signature anywhere. Notion would need to poll the blockchain for Respect scores, but it would only need to do it once a week then the Respect scores could reside within a Notion database. The Respect scores for each community member would be stored as a property in a Notion database, the roll-up functionality would be used to ‘bridge’ the Respect to be used in any other Notion database (such as a projects or topics database), and the formula property would be used to calculate the amount of Respect voted for each project or topic after participants click ‘Upvote.’ I think Pipedream could be used to input Respect for each player into Notion, as explained in these videos. Community members would simple hit the Upvote button then the ‘Upvotes’ property in a notion database would add their total amount of Respect instead of the number 1. This would enable us to vote with Respect rather than ‘one person, one vote’.
I think this would likely be the easiest way to implement Respect voting in Notion at first and could provide a very smooth UX since it’s all in Notion without the need for wallet interactions or external dependencies. The downsides are that it’s more dependent on Notion, I’m not sure if there’s a way for users to allocate a percentage of their votes across different projects, and I’m not sure if there’s any easy way to allocate Respect votes in a finite manner with this method (ie each person would only be able to vote with all their Respect and they could vote with their full voting weight for as many projects as they want). An alternative approach where community members can strategically allocate a limited amount of votes across projects would probably be better in most situations, though the link that I provided above shares an interesting idea to overcome some of these limitations with a manual process. It also may be possible that Notion releases new features such as a voting slider that could provide some of this functionality (and they recently did release the vote button which is a big step), though I haven’t heard anything about this kind of upcoming feature from Notion.
This solution would provide basic functionality to vote with Respect directly in Notion and would be a great improvement over ‘one person one vote’ that we currently know how to do in Notion. We could also test this method by manually entering Respect scores into a database each week before developing a more automated solution with the API.
Option 2: Vote in Snapshot
We can use a combination of tools to automatically mirror all pages in a Notion database into Snapshot, then allow community members to vote in Snapshot and use the Notion API to import the voting results into Notion.
This method could provide more functional and flexible voting strategies within Notion, since it inherits all the customizability of Snapshot as an application specifically designed for voting with onchain tokens. It would enable each community member to strategically allocate a limited amount of Respect across many projects. For example, if you have 500 Respect then you could allocate 225 Respect to one project, 100 Respect to two projects, and 75 Respect amongst 10 other projects. This method could also be used for a wide variety of other voting systems (such as Ranked Choice Voting) and could provide an ideal way to allocate resources voting with Respect for many kinds of multi-variant decisions, such as allocating resources amongst projects, tasks, discussion topics, and grant recipients. In addition to providing more flexible voting systems, this system would also be more independent of Notion and could be directly implemented into fractal apps in the future.
The technical implementation for this method would require more complex development, though it seems feasible to accomplish as a medium to large sized project and could create immense benefits for any community that plays the Respect Game. Most of the following is based on answers I learned in this conversation with ChatGPT. As I understand the Notion API is able to receive data from outside sources like a blockchain or IPFS (where Snapshot votes are recorded), but it is not currently able to send data to outside sources. This means that an intermediary tool (such as Pipedream, Zapier, or IFTTT) may be required to send a signal whenever a page in a specified notion database is created or edited. This signal could then be received via the Snapshot API, which could automatically create a new poll in Snapshot for each notion page. The community members would be able to vote in Snapshot and they’d be able to see all of the pages along with their votes in both Notion and Snapshot.
This approach would likely involve the creation of many polls in Snapshot, which could be organized nicely with the Snapshot Sub-spaces feature. For example we could have sub-spaces for Projects, Tasks, Discussion Topics, RetroFunding Impact Metrics, and RetroFunding Grant Recipients. There could also be more specific sub-spaces specifically for Development Projects, Marketing Tasks, RetroFunding Round 6 Projects, Impact Metrics for RetroFunding Round 4, and Discussion Topics for Season 3 of Optimism Fractal. Snapshot includes over 400 custom voting strategies that can help us in various ways, but I think an ideal configuration would involve creating a new voting strategy that allows a limited amount of Respect votes to be allocated amongst polls in a sub-space. This configuration would allow community members to easily allocate their Respect across different options in each subspace by voting on different polls.
I had a deep conversation with ChatGPT about this a few days ago that provides a lot more details about this method and several pieces of code that could be used to start developing tooling for this method, which you can see in this notion page. Before taking the next steps in developing tooling for this method it might be prudent to scope out the design, specifications, and integrations. We could also explore alternative strategies such as Ranked Choice or Quadratic Voting in the Snapshot Subspace, though I think that a weighted voting across polls in a subspace. It’s may also be possible to use a different software like Tally.xyz, EasyRetroPGF.xyz, or JokeRace.io instead of Snapshot; but from my research Snapshot seems to be well positioned to provide what we need. It also seems worth exploring how The Graph and Substreams may be able to help make Respect more useful, which I’ve been curating here.
It’s worth noting that this is just my understanding so far and there may be some parts above that are not correct. Another point that’s worth considering is the independence and useable lifespan of the tooling that we build. Notion is an excellent app that’s paving the way towards an ideal collaborative user experience, but we should be careful to avoid becoming too dependent on closed-source software from a corporation in California that could change it’s policies at any time. In the longer term I’d like to integrate this functionality into a fractal app using open source code from Appflowy.io, Charmverse.io, or Notion (if they ever open source their software). This would enable any community or organization to vote with Respect in a highly flexible and independent manner for all kinds of collective decisions.
Summary
Overall I think that the first method described would probably be easier and smoother to implement first. The second method can provide many powerful benefits and might provide the ideal solution over the long-term, but it requires connecting a few moving parts and the development would be more complex. It might make the most sense to start with the first method and scope out the second method in the coming weeks. A ‘one person one vote’ system could also work well for some purposes now as the community is small, but we’ll need to find ways to vote with Respect as the community grows and building these features quickly can create profound benefits.
Priority and Rationale
The faster we can build features to enable voting with Respect, the better we can position Optimism Fractal to play a leading role in Optimism Collective governance going into RetroFunding RetroFunding Round 6 (which is focused on governance). The Optimism Collective is seeking the kinds of solutions that Optimism Fractal provides, as you can see in their recently released blog posts about Experimenting with Deliberative Processes in the Collective The Path to Open Metagovernance, and plans to experiment with Impact Juries. The tooling that enables voting with Respect in flexible environments like Notion could greatly help Optimism Fractal community members earn significant funding, propel the growth of Optimism Fractal, and provide a powerful catalyzing force to implement fractal consensus processes throughout society.
Collaborative Approach
I also just saved most of these notes along with some more information in this notion page and will share a message about this soon in the Optimism Fractal discord, so others can get involved as well and we can coordinate development as a community wherever it makes sense. Please feel free let me know if you have any questions or if there’s anything else I can do to help. Thanks! :)
Implementations in Apps
There are several apps and brands in development that could integrate with this ability to vote with Respect in Notion or Snapshot. A few of them are listed below with brief descriptions
Fractal App
In the longer term I’d also like to integrate this functionality into a fractal app using open source code from appflowy.io, charmverse.io, or Notion (if they ever open sources their software). AppFlowy is an open source alternative to Notion with a very active developer base, as you can see in their github repository. You can find more details about the fractal app development below:
Respect Trees
Respect Trees are a a fractal framework designed to facilitate collective decision-making, set priorities, and allocate resources in decentralized communities. While Respect votes can be displayed in linear UIs like Notion and Snapshot, they could also be displayed in an interactive tree structure as Tadas has been planning with Respect Trees. Furthermore, Respect Trees provides a way This can enable many unique advantages and . You can learn more about Respect Trees in the following articles:
Cignals
This tooling could be branded as Cignals, which is a portmanteau of community and signals. The Cignals brand has been developing for over a year and has been used at several events to describe how communities can collectively send signals and individuals within a community can signal their opinions to each other (including during events to improve real-time coordination). The following articles provide an overview of Cignals and it’s pilot use cases so far. More resources and projects related to Cignals can be shared here if it would be helpful.
https://optimystics.io/exploringretropitches
Develop Cignals Consensus Games
Copinions
Copinions is envisioned as a type of consensus game to optimize collective decision-making. All communities and organizations should have the tools and methods to make decisions as fast, fair, and fun as possible. The name Copinions is a portmanteau of community opinions, consensus opinions, or collaborative opinions. It emphasizes the fact that each opinion is expressed collaboratively and cooperatively, while also emphasizing that thoughts expressed or decisions made are expressions of the community’s opinion.
Most of the mechanics of these games are fairly well developed and tested, so Copinions seeks to package the technical consensus processes into easily approachable games. There are a few game modes of Copinions that enable voting with Respect, which can be seen below:
Brand Decisions
- There are many ways to name, brand, and convey the concept of voting with Respect and it’s worth considering the best ways.
- Perhaps it should use a combination of these or different messaging for different purposes?
Decide the best way to name and brand the concept of voting with Respect
Technical Integrations
OSO and Optimism Collective Metric-Based Evalution
The Optimism Foundation is working with Open-Source Observer (OSO) to determine impact metrics to measure, evaluate, and determine how much public goods projects should receive from RetroFunding. You can see this announcement for round 4, further explanation, and the a preview of details for round 7 for information about this. Open-Source Observer has posted a data challenge and request for impact metrics, which you can see below.
Development that facilitate voting with Respect in Snapshot (as described in the second method) could be useful to submit as impact metrics. We’re creating a project in the Optimism Fractal notion site to integrate Respect and Respectful Vote. You can see details about this in the following task: Organize Project to Submit Respect and Respect Voting as Impact Metric for Open Source Observer(OSO)
Experiment: Metrics-based Evaluation
- Thesis: By leveraging quantitive metrics, citizens are able to more accurately express their preferences for the types of impact they want to reward, as well as make more accurate judgements of the impact delivered by individual projects.
In Retro Funding 3, badgeholders voiced that non-standardized impact metrics added difficulty to the voting process and expressed desire to directly vote based on metrics. Examples of this approach include Buidl Guidl’s impact calculator and OpenSource Observers impact vectors. Metrics-based evaluation will be used to reward downstream impact, as this category can benefit from a quantitive approach to measuring impact.
Related Tasks
Auxiliary Respect Tokens
We’re considering implementing new kinds of Respect at Optimism Fractal, including a form of Respect for more kinds of contributors in the Optimism Collective. You see more details about this in Create Auxiliary Respect Tokens for the Optimism Collective.
It would be great to augment the ability to vote with different kinds of Respect in Notion or Snapshot. We could potentially integrate these different kinds of Respect votes into different snapshot subspaces and notion properties, which would allow people to easily sort and filter databases according to their preferences, a higher resolution of consensus, and provide useful information for data scientists.
The Graph and Substreams
The Graph and Substreams can significantly enhance a Respectful voting system and the utility of a voting token by Indexing Respect Data Efficiently, providing Real-Time Data Feeds (that enables new kinds of expressive voting during community events), and offering Modular Development approach for composable functionalities. It seems worth exploring how The Graph and Substreams may be able to help make Respect more useful, which I’ve been curating here.
Organize Research about Substreams, Subgraphs, and The Graph
EasyRetroPGF.xyz
It may be helpful to enable participants to vote with Respect directly in a UI designed for RetroPGF. You can learn more about this in the project below and the open-source project from the Gitcoin team, EasyRetroPGF.xyz.
Create RetroPGF UI to sort applicants by Respect
Considerations
Alternative Voting Strategies
Before taking the next steps in developing tooling, it might be prudent to scope out the design, specifications, and integrations. We could also explore alternative strategies such as Ranked Choice or Quadratic Voting in the Snapshot Subspace, though I think that a weighted voting across polls in a subspace would be a sufficiently immense upgrade in itself and alternative voting strategies would provide a relatively lesser benefit that would be good to explore after developing a weighted voting system.
Pilot use cases with ranked choice voting:
Alternatives to Snapshot
It’s may also be possible to use a different software like Tally.xyz, EasyRetroPGF.xyz, or JokeRace.io instead of Snapshot; but from my research Snapshot seems to be well positioned to provide what we need.
Snapshot is open-source and appears well funded from RetroFunding and a round of VC funding a couple years ago
Alternatives to Notion
A point that’s worth considering is the independence and useable lifespan of the tooling that we build. Notion is an excellent app that’s paving the way towards an ideal collaborative user experience, but we should be careful to avoid becoming too dependent on closed-source software from a corporation in California that could change it’s policies at any time. In the longer term I’d like to integrate this functionality into a fractal app using open source code from Appflowy.io , Charmverse.io , or Notion (if they ever open source their software). This would enable any community or organization to vote with Respect in a highly flexible and independent manner for all kinds of collective decisions.
The AppFlowy repository is very active and seems like the best open-source alternative to notion. AppFlowy is an open source alternative to Notion with a very active developer base, as you can see in their github repository. Charmverse is well developed with integrations with Optimism and also has additional features for proposals and grants. In the future we could also explore other solutions like RoamResearch.com and EdenCreators.com/research.
Related Resources
Improve RetroPGF Review Process: Mission Request Draft
Create tools and processes to track projects and tasks for Optimism Fractal
https://gov.optimism.io/t/enhancing-retropgf-with-optimism-fractal/7175
Design Cagendas for Optimism Fractal and Optimism Town Hall
Explore deeper integrations between Snapshot and Optimism Fractal
Create Notion API integration that allows upvoting with Respect