Governance of the Internet Computer

A key feature of the Internet Computer blockchain is the Network Nervous System (NNS)=, an open algorithmic governance system that oversees the network and the token economics that make it possible to build DeFi and dapps, open internet services, and enterprise systems that are capable of operating at hyperscale.

Holders of the Internet Computer’s ICP utility tokens can lock their tokens in neurons to participate in governance and contribute to decision-making, such as voting to determine whether or not a new collection of nodes (also called a subnet) should be added to the network. By participating in governance, voters earn rewards. They can use these rewards, or ICP utility tokens procured from exchanges, to fuel computations of their canisters.

=Why the Internet Computer needs a Network Nervous System=

The Internet Computer is a distributed protocol run by a network of node machines, which are hosted in different data centers. The nodes communicate with one another over the internet to achieve a consensus on what the Internet Computer’s state should be. A collection of nodes engaging in consensus is called a subnet. On top of this underlying communication and consensus protocol, the Internet Computer hosts canisters, which are stateful programs that can also communicate with each other. The state of all of the canisters has to be replicated across all of the nodes. Therefore, to allow the Internet Computer to scale indefinitely, the network is made up of not just one subnet, but multiple subnets.

Different subnets can communicate with one another, enabling canisters that are hosted on different subnets to also communicate with each other. For the Internet Computer to scale on-demand, the network must be able to add new subnets over time to increase compute capacity. Moreover, the robustness of the subnets can be improved by adding new nodes to them over time. Eventually, the Internet Computer will run millions of nodes at scale. This means that there needs to be a mechanism by which the nodes and subnets are organized, tracked, and managed. For example, decisions must be made about when subnets and nodes should be added or removed. In addition, the Internet Computer is launching with an initial feature set, which may evolve over time. Therefore, the Internet Computer needs to be able to make decisions on how to evolve the protocol in a distributed manner.

Network Nervous System overview

The Network Nervous System, or “NNS”, is a tokenized open governance system that is responsible for managing the Internet Computer. For example, it stores information about what nodes belong to which subnet. It also makes decisions about how to update this information.

At a high level, the NNS is realized by a set of canisters. For making decisions, two of these canisters are key:

1. Governance canister: This stores two things: — a. Proposals, which are suggestions for how the Internet Computer should be changed. These proposals can then be voted on. — b. Neurons, which determine who is allowed to participate in governance.

2. Registry canister: This stores the configuration of the whole Internet Computer that can then be looked up by others. As an example, it stores which nodes belong to a certain subnet.

Anatomy of a decision via the NNS

Let’s say we have User A who controls Neuron A and submits a proposal on adding a node N to Subnet 1. The proposal will then be added to the governance canister. Other users who also control neurons can then vote on the proposal. If the majority of the users are in favor of the proposal, the proposal will be executed, which means that the content of the registry canister will be updated to reflect that the node N is part of Subnet 1.

The Internet Computer supports a variety of different proposal topics. Here are some non-exhaustive examples of topics that are initially supported:

• #SubnetManagement Proposals: This considers topology changes. The example proposal above about whether a node should be added to a subnet falls into this category.
• #ExchangeRate Proposals: This concerns real-time information about the value of ICP utility tokens, which is important to determine how many tokens have to be converted into computation cycles. (More on this below.)
• #NodeAdmin Proposals: This concerns the administration of node machines. An example of a proposal could specify that all of the nodes in a subnet should be updated.
• #NetworkEconomics Proposals: This concerns the administration of network economics. For example: what rewards should be paid to the node machine providers?

Token management via the NNS

Tokens are managed by yet another canister on the NNS, the ledger canister, which stores two things: accounts and transactions. An account record keeps track of how many tokens are in the possession of a given principal ID (i.e., an identity by which a user is authenticated on the Internet Computer). Tokens can then be sent from one account to another, and this is recorded in the transactions of the ledger canister.

ICP utility tokens can be used for three different things:

• First, the tokens facilitate participation in governance (more below on how the neurons are connected with the tokens).
• Second, those who participate in governance and those who provide compute capacity by operating note machines are both rewarded in tokens.
• Finally, tokens are used for conversion into cycles, which are fuel for canisters for computations and data storage.

Introduction to neurons

Neurons contain locked tokens, which are not liquid and cannot be transferred freely to others.

Among other data, a neuron stores the following information:

• First, it keeps track of how many tokens are associated with a given neuron, and it does so by referencing an account on the ledger.
• Second, it specifies a principal ID, which identifies a public key.
• Lastly, it also specifies a unique neuron ID.

There are some other parameters associated with the neuron that are important to note. One of the most important ones is the earliest date when the tokens can be unlocked. Only those neurons with tokens locked for at least six months are allowed to participate in governance. This should incentivize neuron holders to vote such that the value of their tokens is maximized for a future date.

If the value of the tokens is a rough proxy for the network’s success, this incentivizes voters to vote in the long-term interest of the Internet Computer.

A neuron’s voting power depends on multiple factors, including the amount of tokens that are locked in the neuron and the remaining time until when the tokens can be unlocked.

How to lock tokens in a neuron

Let’s assume that User B, who has an account (A1) on the ledger canister, would like to lock a hundred tokens in a neuron. To do so, User B sends a command to the NNS specifying the number of tokens and User B’s corresponding principal ID.

A transaction is then recorded on the ledger, which specifies that some tokens are sent from the original account (A1) of the user to a new account (A2), which also creates the new account (A2) that holds the locked tokens. A new neuron is created in the governance canister that specifies that User B is the one controlling this neuron and that specifies that the amount of locked tokens is defined by the new ledger account A2.

Externally, it’s not visible that the new account (A2) holds locked tokens or is in any way related to the original account (A1). Nevertheless, this account is in fact controlled by the neuron, which means that the tokens are not liquid and that User B cannot transfer the tokens or convert the tokens into cycles.

Controlling a neuron enables users to submit and vote on proposals, which are explained next.

Submitting a proposal via the NNS

A proposal describes a method in a canister that is called if the proposal is accepted. Moreover, it describes the parameters with which the method will be called. Let’s consider the example where the User C proposes that a new subnet is created that initially consists of two nodes: Node 1 and Node 2.

Once a user controls a neuron, they can submit a proposal by specifying their neuron ID, the type of proposal that they would like to submit, and the proposal’s parameters. In our example, User C submits a proposal to create a new subnet that consists of the initial nodes Node 1 and Node 2 (the proposal’s parameters).

Upon the receipt of this proposal, the governance canister first checks that this user is indeed the one controlling the neuron with the given ID and that this neuron is eligible to vote. If the requirements are met, the proposal is added to the governance canister. When users add new proposals, the number of “yes” votes associated with the given proposal is increased by the proposer’s voting power. This reflects that the proposal already has the support of the user submitting it.

To avoid being inundated by useless proposals, a user submitting a proposal has to pay a small fee if the proposal is rejected.

After a proposal is then submitted and added to the governance canister, other users who control neurons can vote on it. To vote, users would first ask the governance canister for the pending proposals to learn what they can actually vote on.

Assume that a given User D would like to reject the proposal that was just added by User C. To do so, User D would send their neuron ID and a “no” vote to the governance canister. Again, the governance canister would check that the vote is coming from the correct user who controls the neuron and confirm that the neuron is eligible to vote. If the conditions are met, the governance canister would then add the voting power of User D to the “no” votes.

Assume that at one point, the majority of voting power is in favor of the proposal. The proposal would be executed, which means that the described method will be called. In the example, the method to create a subnet to the registry canister will be called with the specified parameters. The result is that a new subnet is added to the registry canister, which consists of the given nodes Node 1 and Node 2.

Collecting rewards on the NNS

Contributing to decision-making is one incentive for voters to lock their neurons, but they are also rewarded for participating in network governance.

Each neuron keeps track of how many rewards it has accumulated through participation in the governance. To collect rewards, users can send a command to the governance canister to spawn a new neuron. As a result, a new neuron with a new associated account on the ledger will be created, which contains the rewards.

In fact, the new tokens are minted and transferred to the new account, which is also recorded in the ledger canister. The new neuron has a small dissolve delay, which means that users must only wait a short amount of time to be able to unlock the tokens and use them freely. Node machine providers are also provided rewards via the NNS.

Delegating votes on the NNS

Users may not have the time or knowledge to participate in all network decisions. For example, a user who is unfamiliar with network topologies might not want to make a decision on a proposal on whether a node should be added to a subnet.

For these cases, the Internet Computer facilitates liquid democracy. This means that a neuron can specify that it would like to follow other neurons (so-called followees), and the governance canister tracks the relation of follower and followee neurons.

If a majority of the followee neurons vote in a particular way, the governance canister would automatically also record the corresponding vote for the follower neurons. Through this, follower neurons can still earn voting rewards, without actively participating in governance. Neurons can even “follow” different neurons based on specific proposal topics.

Paying for cycles

Besides governance participation and voting rewards, tokens can also be converted into cycles, which fuel computation and storage on the Internet Computer. Each canister on the Internet Computer, except for those on the NNS, uses cycles for computations and has some cycles stored within it. While the token price may vary over time, the goal of the cycles is to keep the price of computation roughly consistent over time.

Consider User E who runs a canister on the Internet Computer and would like to top up the cycles of this canister so that it can perform even more computations. Also assume that this canister currently has 700 trillion cycles and User E would like to increase this number by 200 trillion. To do so, the user would send a command to the NNS that specifies the action of topping up their canister. Upon receiving this command, a transaction is made from the user’s account to the cycle’s minting canister, which is yet another canister on the NNS.

As a result of this transaction, the cycle’s minting canister would burn the tokens, mint new cycles, and send these freshly minted cycles to the user’s canister, meaning the canister balance is now 900 trillion cycles.