- We propose to add SNS user functionality within the NNS frontend dapp.
- The SNS frontend within the NNS will manage the full range of functionality of user interactions with an SNS; from participating in an SNS launch, to managing SNS neurons & voting & transferring SNS tokens.
- SNS frontend functionality is planned to be released incrementally.
- We are prioritizing this work within the roadmap of the NNS frontend.
A service nervous system (SNS) is an open tokenized governance system that can be used to decentralize the control of a dapp. SNSs will be provided as a service by the Internet Computer (IC) and work conceptually similarly to the Network Nervous System (NNS). While the NNS is the open governance system that controls the full Internet Computer, each SNS will control one dapp.
An SNS consists of a set of canisters, including the governance canister, which stores proposals and neurons, and the ledger canister. A motion proposal that is currently under vote proposes that the SNS launch contains an initial token distribution to ensure decentralization of SNS governance. Thus, assuming that this proposal is adopted, the SNS will at launch time also consist of an initial swap canister where participants can exchange ICP tokens for SNS tokens to provide funding for a dapp. (We refer to this forum post for more information about the initial token swap and to this forum post for more information on governance.)
One important goal of the SNSs is decentralization, that is that decisions regarding how the dapp is evolved are made by a variety of different parties, for example including dapp users and investors. Another important goal of the SNSs is to allow anyone, even small investors, to contribute to initial funding and thus support dapps.
The achievement of these goals heavily relies on many users actually participating in the initial token swap and later in the governance process. User participation in turn relies on how user-friendly the participation is.
Therefore, similarly to how users can stake neurons and participate in the NNS governance by using the NNS frontend dapp, SNSs should have a user-friendly frontend that users can interact with to provide funding to SNSs and participate in SNS governance.
In this post, we propose a high level design for the SNS frontend and present some first drafts of what the SNS frontend UI could look like. While everyone can implement a frontend for the SNS, we explain why we propose to also include an SNS frontend within the NNS frontend dapp. We also suggest a prioritization of the different user stories, that is which user stories should be supported for the Carbon milestone and which ones shortly after.
We first present how users can interact with an SNS and what kinds of user groups there are. Motivated by this, we then present a proposed design and timeline.
There are the following categories of user interactions with the SNS:
- Initial swap participation: users send ICP to the SNS during its launch to contribute to the SNS’s funding. If the SNS launch is successful, the users receive SNS tokens, staked in SNS neurons, in return. (See this post for more details.)
- SNS governance participation: users that already got SNS tokens, either from the initial token swap or by other means such as exchanges, can stake the tokens in neurons and participate in governance. This includes that they can make new proposals on how to evolve the dapp governed by the SNS and that they can vote on such proposals. To successfully participate in governance, users should also be able to configure their neurons.
- SNS ledger transfers: users that already got SNS tokens should be able to transfer them to other accounts, such as other users or to dapp services that they can pay for.
While the initial swap participation is a one-time event for each SNS, the governance and ledger interactions continue throughout the lifetime of an SNS.
There are two main groups of SNS users that one can distinguish.
First, there are the dapp users. Due to the design of the Internet Computer, anyone can interact with a dapp without the need for owning any tokens or understanding the underlying blockchain architecture. Therefore, many dapp users might not have any experience with token wallets and governance participation.
Despite the lack of this expertise, many of these users might want to participate in the SNS, for example by receiving SNS tokens as rewards for certain activities in the dapp, by paying with SNS tokens for dapp services, or by helping decide how the dapp is evolved. To make such SNS interactions accessible to dapp users, developers will likely include parts of this functionality directly in the already existing dapp frontend so that users can stay on the same web app for all interactions.
The second group of users are investors and other IC enthusiasts that already own ICP tokens and would like to use those ICP to help fund new projects and support the IC ecosystem. Many of these users already interact with the NNS frontend dapp, but are not regular users of all the dapps on the IC. Thus, it would be beneficial to have an entrypoint on the NNS frontend dapp to make SNS initial token swaps and SNS governance accessible to these users.
We conclude that to attract as many users as possible, for many dapps it is best to support SNS participation from different entry points. However, it is of course up to the different dapps to decide what they would like to support and not all developers might have the resources to add an SNS frontend integration to their dapp. Therefore, to ensure that even such dapps can get enough user interaction to successfully launch their SNS, we propose to add an SNS frontend to the NNS frontend dapp. As argued above, the NNS frontend dapp also provides a natural entry point for one user group.
We plan to first realize the functionalities required for users to participate in the initial token swap, as presented below, and then add the remaining components for SNS governance participation and ledger transactions. We first present in some more details what the user interface for the initial token swap participation could look like and then present more details on the timeline.
Two key views of the UI are demonstrated in Figures 1 and 2, which show the NNS frontend dapp in a “light skin” that will be available soon.
The NNS frontend dapp will have a new Launch Pad view where users will be able to find the current SNS launches and their deadlines (see Figure 1). This overview includes both SNS launches for which the user has already participated in the initial token swap (Project Pac-Man with 25.00 ICP in the example) and projects where they have not yet participated (Project Tetris in the example). For those SNS launches where a user has participated, the view also shows the user’s current contribution.
Initial token swaps are started by an NNS proposal. In addition to the current SNS launches that are ongoing, the Launch Pad view thus also shows a list of initial token swaps that are currently being voted on and where the user might participate in the near future (see Figure 1).
To participate in one of the current SNS launches, a user can tap on a project from the Launch Pad view. This will lead to a view with details about the project as shown in Figure 2. The view provides a detailed overview of the SNS that is launched, including its token name and the conditions of the initial token swap such as the minimum and maximum amount of ICP that a user can contribute.
A user can also learn how far the initial token swap is, that is whether it has already reached the minimum and maximum number of total ICP that it aims to collect and when its deadline will be reached. If the user agrees with the conditions, they can specify the ICP amount with which they want to participate in the initial token swap.
If the swap is successful, a new SNS neuron will be created for the user which the user will be able to find on the NNS frontend dapp.
As mentioned above, we propose to prioritize the frontend for the initial token swap and then add the remaining components for SNS governance participation and ledger transactions. In more detail, we propose to include the frontend for the initial token swap in the Carbon milestone and add the remaining functionality shortly after.
The main reason for this are:
- Including all of the frontend work in the Carbon milestone would delay the Carbon milestone. Therefore, we propose an incremental approach and focus on one part first which can be delivered by the time of the Carbon milestone.
- There are two main reasons why we propose to prioritize the initial token swap over other frontend work.
First, as argued above, many dapps will want to integrate SNS functionalities directly in the dapp frontend but they might not have enough resources to do all of it. As the initial token swap is only a one-time event and governance and ledger transactions are needed throughout the dapps’ lifetime, dapp developers might want to prioritize work on the latter two. We thus think it is important that the swap participation is covered by the NNS frontend dapp.
Second, in the flow of SNS interactions, the users first interact with the initial token swap to obtain tokens and then interact with the governance. Thus, when the first SNSs launch, the integration with the initial token swap is the first thing that they will need.
- Q: Does this frontend block SNS launch? If it does, by how much?
A: This proposal does not block or delay the SNS milestone Carbon. While initial versions of the SNS canisters governance, ledger and root exist, the SNS initial token swap canister and tooling around the SNS deployment and upgrades are still ongoing work. The frontend can be built in parallel to this ongoing work, as this is mostly done by another team. As explained, to avoid delaying the deadline, we propose an iterative process that first focuses on the initial token swap for the Carbon milestone and then adds support for SNS governance and SNS ledger transfers shortly after.
- Q: Can other people build the SNS frontend? Are the APIs and frameworks available to them?
A: The APIs will all be publicly available and are open sourced as they are implemented on the SNS canisters. As motivated, dapps and other parties can build SNS frontend integrations themselves and we expect that many projects will integrate parts of the SNS interaction into the existing dapps. We propose to also integrate the SNS interaction to the NNS frontend as 1) the NNS frontend is a natural entry point to attract users that already have ICP that they would like to invest and 2) not all dapp developers will have the resources to do all of this by themselves.
- Q: What happens if we do not build this?
A: If we do not provide this functionality, we risk that the SNSs have little participation and thus little decentralization and initial funding. This is because we cannot expect that all dapp developers have the resources to integrate all SNS functionalities to their dapp by the time when the first SNSs are ready to be launched.