package ic_nns_governance.pb.v1
Get desktop application:
View/edit binary Protocol Buffers messages
message
governance.proto:406Subset of Neuron that has no collections or big fields that might not exist in most neurons, and the goal is to keep the size of the struct consistent and can be easily stored in a StableBTreeMap. For the meaning of each field, see the Neuron struct.
bytes account = 2
optional controller = 3
uint64 cached_neuron_stake_e8s = 5
uint64 neuron_fees_e8s = 6
uint64 created_timestamp_seconds = 7
uint64 aging_since_timestamp_seconds = 8
optional uint64 spawn_at_timestamp_seconds = 19
oneof dissolve_state
uint64 when_dissolved_timestamp_seconds = 9
uint64 dissolve_delay_seconds = 10
bool kyc_verified = 13
uint64 maturity_e8s_equivalent = 15
optional uint64 staked_maturity_e8s_equivalent = 20
optional bool auto_stake_maturity = 21
bool not_for_profit = 16
optional uint64 joined_community_fund_timestamp_seconds = 17
optional NeuronType neuron_type = 22
message
governance.proto:675Adds and/or removes NodeProviders from the list of current node providers.
Used in:
oneof change
to_add = 1
to_remove = 2
message
governance.proto:669For all Neurons controlled by the given principals, set their KYC status to `kyc_verified=true`.
Used in:
repeated principals = 1
message
governance.proto:2547Audit events in order to leave an audit trail for certain operations.
uint64 timestamp_seconds = 1
The timestamp of the event.
oneof payload
reset_aging = 2
Reset aging timestamps for https://forum.dfinity.org/t/icp-neuron-age-is-52-years/21261/26
restore_aging = 3
Restore aging timestamp that were incorrectly reset.
message
governance.proto:2558Used in:
fixed64 neuron_id = 1
The neuron id whose aging was reset.
uint64 previous_aging_since_timestamp_seconds = 2
The aging_since_timestamp_seconds before reset.
uint64 new_aging_since_timestamp_seconds = 3
The aging_since_timestamp_seconds after reset.
oneof neuron_dissolve_state
Neuron's dissolve state at the time of reset.
uint64 when_dissolved_timestamp_seconds = 4
uint64 dissolve_delay_seconds = 5
uint64 neuron_stake_e8s = 6
Neuron's stake at the time of reset.
message
governance.proto:2578Used in:
optional uint64 neuron_id = 1
The neuron id whose aging was restored.
optional uint64 previous_aging_since_timestamp_seconds = 2
The aging_since_timestamp_seconds before restore.
optional uint64 new_aging_since_timestamp_seconds = 3
The aging_since_timestamp_seconds after restore.
oneof neuron_dissolve_state
Neuron's dissolve state at the time of restore.
uint64 when_dissolved_timestamp_seconds = 4
uint64 dissolve_delay_seconds = 5
optional uint64 neuron_stake_e8s = 6
Neuron's stake at the time of restore.
message
governance.proto:1222Used in: ,
Vote vote = 1
uint64 voting_power = 2
message
governance.proto:182How did a neuron vote in the recent past? This data is used by other neurons to determine what neurons to follow.
Used in: ,
optional proposal_id = 1
Vote vote = 2
message
governance.proto:2368The arguments to the method `claim_or_refresh_neuron_from_account`. DEPRECATED: Use ManageNeuron::ClaimOrRefresh.
optional controller = 1
The principal for which to refresh the account. If not specified, defaults to the caller.
uint64 memo = 2
The memo of the staking transaction.
message
governance.proto:2379Response to claim_or_refresh_neuron_from_account. DEPRECATED: Use ManageNeuron::ClaimOrRefresh.
oneof result
error = 1
Specified in case of error.
neuron_id = 2
The ID of the neuron that was created or empty in the case of error.
message
governance.proto:1869Mainly, calls the deploy_new_sns Candid method on the SNS-WASMs canister. Therefore, most of the fields here have equivalents in SnsInitPayload. Please, consult the comments therein.
Metadata --------
Used in:
optional string name = 1
optional string description = 2
optional string url = 3
optional logo = 4
repeated fallback_controller_principal_ids = 5
repeated dapp_canisters = 6
optional initial_token_distribution = 7
optional swap_parameters = 8
optional ledger_parameters = 9
optional governance_parameters = 10
message
governance.proto:1970Proposal Parameters -------------------
Used in:
optional proposal_rejection_fee = 1
optional proposal_initial_voting_period = 2
optional proposal_wait_for_quiet_deadline_increase = 3
optional neuron_minimum_stake = 4
optional neuron_minimum_dissolve_delay_to_vote = 5
optional neuron_maximum_dissolve_delay = 6
optional neuron_maximum_dissolve_delay_bonus = 7
optional neuron_maximum_age_for_age_bonus = 8
optional neuron_maximum_age_bonus = 9
optional voting_reward_parameters = 10
message
governance.proto:1993Used in:
optional initial_reward_rate = 1
optional final_reward_rate = 2
optional reward_rate_transition_duration = 3
message
governance.proto:1888Used in:
optional developer_distribution = 1
optional treasury_distribution = 2
optional swap_distribution = 3
message
governance.proto:1889Used in:
repeated developer_neurons = 1
message
governance.proto:1890Used in:
optional controller = 1
optional dissolve_delay = 2
optional uint64 memo = 3
optional stake = 4
optional vesting_period = 5
message
governance.proto:1909Used in:
optional total = 1
message
governance.proto:1903Used in:
optional total = 1
message
governance.proto:1961Used in:
optional transaction_fee = 1
optional string token_name = 2
optional string token_symbol = 3
optional token_logo = 4
message
governance.proto:1921Used in:
optional uint64 minimum_participants = 1
optional minimum_icp = 2
optional maximum_icp = 3
optional minimum_direct_participation_icp = 12
optional maximum_direct_participation_icp = 13
optional minimum_participant_icp = 4
optional maximum_participant_icp = 5
optional neuron_basket_construction_parameters = 6
optional string confirmation_text = 7
optional restricted_countries = 8
optional start_time = 9
The swap occurs at a specific time of day, in UTC. It will happen the first time start_time occurs that's at least 24h after the proposal is adopted.
optional duration = 10
optional neurons_fund_investment_icp = 11
The amount that the Neuron's Fund will collectively spend in maturity on the swap.
optional bool neurons_fund_participation = 14
Whether Neurons' Fund participation is requested. Cannot be set to true until Matched Funding is released
message
governance.proto:1933Used in:
optional uint64 count = 1
optional dissolve_delay_interval = 2
message
governance.proto:1530This message has a couple of unusual features. 1. There is (currently) only one field. We expect that more fields will be (and possibly other clients) to be able to handle this information in a generic way, i.e. without having to change their code. 2. Fields that might be added later will probably be mutually exclusive with existing fields. Normally, this would be handled by putting all such fields into a oneof. However, Candid has a bug where variant is not handled correctly. Therefore, we refrain from using oneof until we believe that the fix is very imminent.
Used in: ,
optional swap_background_information = 1
message
governance.proto:846Empty message to use in oneof fields that represent empty enums.
Used in:
(message has no fields)
message
governance.proto:652Payload of a proposal that calls a function on another NNS canister. The canister and function to call is derived from the `nns_function`.
Used in:
NnsFunction nns_function = 1
This enum value determines what canister to call and what NNS function to call on that canister.
bytes payload = 2
The payload of the NNS function.
message
governance.proto:1413optional nns_proposal_id = 1
ID of the NNS proposal that resulted in the creation of the corresponding Swap.
message
governance.proto:1418oneof result
err = 1
ok = 2
message
governance.proto:1420Request was completed successfully.
Used in:
optional neurons_fund_audit_info = 1
Represents public information suitable for auditing Neurons' Fund participation in an SNS swap.
message
governance.proto:2008This represents the whole NNS governance system. It contains all information about the NNS governance system that must be kept across upgrades of the NNS governance system.
map<fixed64, > neurons = 1
Current set of neurons.
map<uint64, > proposals = 2
Proposals.
repeated to_claim_transfers = 3
The transfers that have been made to stake new neurons, but haven't been claimed by the user, yet.
uint64 wait_for_quiet_threshold_seconds = 5
Also known as the 'normal voting period'. The maximum time a proposal (of a topic with "normal" voting period) is open for voting. If a proposal has not been decided (adopted or rejected) within this time since the proposal was made, the proposal is rejected. See also `short_voting_period_seconds`.
optional economics = 8
The network economics configuration parameters.
optional latest_reward_event = 9
The last reward event. Should never be missing.
map<fixed64, > in_flight_commands = 10
Set of in-flight neuron ledger commands. Whenever we issue a ledger transfer (for disburse, split, spawn etc) we store it in this map, keyed by the id of the neuron being changed and remove the entry when it completes. An entry being present in this map acts like a "lock" on the neuron and thus prevents concurrent changes that might happen due to the interleaving of user requests and callback execution. If there are no ongoing requests, this map should be empty. If something goes fundamentally wrong (say we trap at some point after issuing a transfer call) the neuron(s) involved are left in a "locked" state, meaning new operations can't be applied without reconciling the state. Because we know exactly what was going on, we should have the information necessary to reconcile the state, using custom code added on upgrade, if necessary.
uint64 genesis_timestamp_seconds = 11
The timestamp, in seconds since the unix epoch, at which `canister_init` was run for the governance canister, considered the genesis of the IC for reward purposes.
repeated node_providers = 12
The entities that own the nodes running the IC.
map<int32, > default_followees = 13
Default followees A map of Topic (as i32) to Neuron id that is set as the default following for all neurons created post-genesis. On initialization it's required that the Neurons present in this map are present in the initial set of neurons. Default following can be changed via proposal.
uint64 short_voting_period_seconds = 14
The maximum time a proposal of a topic with *short voting period* is open for voting. If a proposal on a topic with short voting period has not been decided (adopted or rejected) within this time since the proposal was made, the proposal is rejected. The short voting period is used for proposals that don't make sense to vote on if the proposal is "old". For example, proposals to set the exchange rate should not be voted on if they're days old because exchange rates fluctuate regularly. Currently, only proposals to set the exchange rate use the short voting period, and such proposals are deprecated.
optional uint64 neuron_management_voting_period_seconds = 25
The maximum time a proposal of a topic with *private voting period* is open for voting. If a proposal on a topic with short voting period has not been decided (adopted or rejected) within this time since the proposal was made, the proposal is rejected. This is useful for proposals that are for "private matters" like NeuronManagement proposals. These proposals are not meant to be voted on by the general public and have limited impact, so a different voting period is appropriate.
optional metrics = 15
optional most_recent_monthly_node_provider_rewards = 16
optional int32 cached_daily_maturity_modulation_basis_points = 17
Cached value for the maturity modulation as calculated each day.
optional uint64 maturity_modulation_last_updated_at_timestamp_seconds = 18
The last time that the maturity modulation value was updated.
optional bool spawning_neurons = 19
Whether the heartbeat function is currently spawning neurons, meaning that it should finish before being called again.
optional making_sns_proposal = 20
optional migrations = 21
Migration related data.
map<int32, > topic_followee_index = 22
A Structure used during upgrade to store the index of topics for neurons to their followers. This is the inverse of what is stored in a Neuron (its followees).
optional xdr_conversion_rate = 26
Local cache for XDR-related conversion rates (the source of truth is in the CMC canister).
optional restore_aging_summary = 27
The summary of restore aging event.
message
governance.proto:2239A map of followees to their followers.
Used in:
map<fixed64, > followers_map = 1
The key is the neuron ID of the followee.
message
governance.proto:2240Used in:
repeated followers = 1
The followers of the neuron with the given ID. These values will be non-repeating, and order does not matter.
message
governance.proto:2126Stores metrics that are too costly to compute each time metrics are requested. For bucketed metrics, keys are bucket IDs, i.e., number of full half-year dissolve delay intervals of neurons counted towards this bucket.
Used in:
uint64 timestamp_seconds = 1
uint64 total_supply_icp = 2
uint64 dissolving_neurons_count = 3
map<uint64, double> dissolving_neurons_e8s_buckets = 4
map<uint64, uint64> dissolving_neurons_count_buckets = 5
uint64 not_dissolving_neurons_count = 6
map<uint64, double> not_dissolving_neurons_e8s_buckets = 7
map<uint64, uint64> not_dissolving_neurons_count_buckets = 8
uint64 dissolved_neurons_count = 9
uint64 dissolved_neurons_e8s = 10
uint64 garbage_collectable_neurons_count = 11
uint64 neurons_with_invalid_stake_count = 12
uint64 total_staked_e8s = 13
uint64 neurons_with_less_than_6_months_dissolve_delay_count = 14
uint64 neurons_with_less_than_6_months_dissolve_delay_e8s = 15
uint64 community_fund_total_staked_e8s = 16
uint64 community_fund_total_maturity_e8s_equivalent = 17
uint64 neurons_fund_total_active_neurons = 25
uint64 total_locked_e8s = 18
uint64 total_maturity_e8s_equivalent = 19
uint64 total_staked_maturity_e8s_equivalent = 20
map<uint64, double> dissolving_neurons_staked_maturity_e8s_equivalent_buckets = 21
uint64 dissolving_neurons_staked_maturity_e8s_equivalent_sum = 22
map<uint64, double> not_dissolving_neurons_staked_maturity_e8s_equivalent_buckets = 23
uint64 not_dissolving_neurons_staked_maturity_e8s_equivalent_sum = 24
uint64 seed_neuron_count = 26
uint64 ect_neuron_count = 27
uint64 total_staked_e8s_seed = 28
uint64 total_staked_e8s_ect = 29
uint64 total_staked_maturity_e8s_equivalent_seed = 30
uint64 total_staked_maturity_e8s_equivalent_ect = 31
map<uint64, double> dissolving_neurons_e8s_buckets_seed = 32
map<uint64, double> dissolving_neurons_e8s_buckets_ect = 33
map<uint64, double> not_dissolving_neurons_e8s_buckets_seed = 34
map<uint64, double> not_dissolving_neurons_e8s_buckets_ect = 35
message
governance.proto:2186Records that making an OpenSnsTokenSwap (OSTS) or CreateServiceNervousSystem (CSNS) proposal is in progress. We only want one of these to be happening at the same time, because otherwise, it is error prone to enforce that open OSTS or CSNS proposals are unique. In particular, the result of checking that the proposal currently being made would be unique is liable to becoming invalid during an .await. This is a temporary measure, because OSTS is part of the SNS flow that will be replaced by 1-proposal very soon.
Used in:
optional proposer_id = 1
optional caller = 2
optional proposal = 3
message
governance.proto:2195Progress of a migration that (potentially) is performed over the course of more than one heartbeat call.
Used in:
optional Migration.MigrationStatus status = 1
Migration status.
optional string failure_reason = 2
The reason why it failed. Should only be present when the status is FAILED. This is only for debugging and it should not be used programmatically (other than its presence).
oneof progress
Migration progress (cursor).
last_neuron_id = 3
Last neuron id migrated.
Used in:
MIGRATION_STATUS_UNSPECIFIED = 0
Unspecified.
MIGRATION_STATUS_IN_PROGRESS = 1
Migration is in progress.
MIGRATION_STATUS_SUCCEEDED = 2
Migration succeeded.
MIGRATION_STATUS_FAILED = 3
Migration failed.
message
governance.proto:2227The status of all on-going (and recently completed) migrations (that take place over the course of multiple heartbeat calls). Each Migration field corresponds to one (ongoing or recently completed) migration. After a migration is finished, it should be OK to reserve the tag and lose the data.
Used in:
optional neuron_indexes_migration = 1
Migrates neuron indexes to stable storage.
optional copy_inactive_neurons_to_stable_memory_migration = 2
message
governance.proto:2031The possible commands that require interaction with the ledger.
Used in:
uint64 timestamp = 1
The timestamp at which the command was issued, for debugging purposes.
oneof command
disburse = 2
split = 3
disburse_to_neuron = 5
merge_maturity = 7
claim_or_refresh_neuron = 8
configure = 9
merge = 10
spawn = 20
sync_command = 21
message
governance.proto:2046A general place holder for sync commands. The neuron lock is never left holding a sync command (as it either succeeds to acquire the lock and releases it in the same call, or never acquires it in the first place), but it still must be acquired to prevent interleaving with another async command. Thus there's no value in actually storing the command itself, and this placeholder can generally be used in all sync cases.
Used in:
(message has no fields)
message
governance.proto:1158Used in: , , , , ,
GovernanceError.ErrorType error_type = 1
string error_message = 2
Used in:
ERROR_TYPE_UNSPECIFIED = 0
ERROR_TYPE_OK = 1
The operation was successfully completed.
ERROR_TYPE_UNAVAILABLE = 2
This operation is not available, e.g., not implemented.
ERROR_TYPE_NOT_AUTHORIZED = 3
The caller is not authorized to perform this operation.
ERROR_TYPE_NOT_FOUND = 4
Some entity required for the operation (for example, a neuron) was not found.
ERROR_TYPE_INVALID_COMMAND = 5
The command was missing or invalid. This is a permanent error.
ERROR_TYPE_REQUIRES_NOT_DISSOLVING = 6
The neuron is dissolving or dissolved and the operation requires it to be not dissolving (that is, having a non-zero dissolve delay that is accumulating age).
ERROR_TYPE_REQUIRES_DISSOLVING = 7
The neuron is not dissolving or dissolved and the operation requires it to be dissolving (that is, having a non-zero dissolve delay with zero age that is not accumulating).
ERROR_TYPE_REQUIRES_DISSOLVED = 8
The neuron is not dissolving and not dissolved and the operation requires it to be dissolved (that is, having a dissolve delay of zero and an age of zero).
ERROR_TYPE_HOT_KEY = 9
When adding or removing a hot key: the key to add was already present or the key to remove was not present or the key to add was invalid or adding another hot key would bring the total number of the maximum number of allowed hot keys per neuron.
ERROR_TYPE_RESOURCE_EXHAUSTED = 10
Some canister side resource is exhausted, so this operation cannot be performed.
ERROR_TYPE_PRECONDITION_FAILED = 11
Some precondition for executing this method was not met (e.g. the neuron's dissolve time is too short). There could be a change in the state of the system such that the operation becomes allowed (e.g. the owner of the neuron increases its dissolve delay).
ERROR_TYPE_EXTERNAL = 12
Executing this method failed for some reason external to the governance canister.
ERROR_TYPE_LEDGER_UPDATE_ONGOING = 13
A neuron has an ongoing ledger update and thus can't be changed.
ERROR_TYPE_INSUFFICIENT_FUNDS = 14
There wasn't enough funds to perform the operation.
ERROR_TYPE_INVALID_PRINCIPAL = 15
The principal provided was invalid.
ERROR_TYPE_INVALID_PROPOSAL = 16
The proposal is defective in some way (e.g. title is too long). If the same proposal is submitted again without modification, it will be rejected regardless of changes in the system's state (e.g. increasing the neuron's dissolve delay will not make the proposal acceptable).
ERROR_TYPE_ALREADY_JOINED_COMMUNITY_FUND = 17
The neuron attempted to join the community fund while already a member.
ERROR_TYPE_NOT_IN_THE_COMMUNITY_FUND = 18
The neuron attempted to leave the community fund but is not a member.
message
governance.proto:1479This function is called "ideal" because it serves as the guideline that the Neurons' Fund will try to follow, but may deviate from in order to satisfy SNS-specific participation constraints while allocating its overall participation amount among its neurons' maturity. In contrast, The "effective" matched participation function `crate::neurons_fund::MatchedParticipationFunction` is computed *based* on this one.
Used in:
optional string serialized_representation = 1
The encoding of the "ideal" matched participation function is defined in `crate::neurons_fund`. In the future, we could change this message to represent full abstract syntactic trees comprised of elementary mathematical operators, with literals and variables as tree leaves.
message
governance.proto:1841Used in: ,
optional id = 1
optional known_neuron_data = 2
message
governance.proto:1847Known neurons have extra information (a name and optionally a description) that can be used to identify them.
Used in: , ,
string name = 1
optional string description = 2
message
governance.proto:2354A response to "ListKnownNeurons"
repeated known_neurons = 1
List of known neurons.
message
governance.proto:2329A request to list neurons. The "requested list", i.e., the list of neuron IDs to retrieve information about, is the union of the list of neurons listed in `neuron_ids` and, if `caller_neurons` is true, the list of neuron IDs of neurons for which the caller is the controller or one of the hot keys.
repeated fixed64 neuron_ids = 1
The neurons to get information about. The "requested list" contains all of these neuron IDs.
bool include_neurons_readable_by_caller = 2
If true, the "requested list" also contains the neuron ID of the neurons that the calling principal is authorized to read.
message
governance.proto:2342A response to a `ListNeurons` request. The "requested list" is described in `ListNeurons`.
map<fixed64, > neuron_infos = 1
For each neuron ID in the "requested list", if this neuron exists, its `NeuronInfo` at the time of the call will be in this map.
repeated full_neurons = 2
For each neuron ID in the "requested list", if the neuron exists, and the caller is authorized to read the full neuron (controller, hot key, or controller or hot key of some followee on the `ManageNeuron` topic).
message
governance.proto:2360Response to list_node_providers
repeated node_providers = 1
List of all "NodeProviders"
message
governance.proto:2284Proposals with restricted voting are not included unless the caller is allowed to vote on them. The actual ballots of the proposal are restricted to ballots cast by the caller.
uint32 limit = 1
Limit on the number of [ProposalInfo] to return. If no value is specified, or if a value greater than 100 is specified, 100 will be used.
optional before_proposal = 2
If specified, only return proposals that are strictly earlier than the specified proposal according to the proposal ID. If not specified, start with the most recent proposal.
repeated Topic exclude_topic = 3
Exclude proposals with a topic in this list. This is particularly useful to exclude proposals on the topics TOPIC_EXCHANGE_RATE and TOPIC_KYC which most users are not likely to be interested in seeing.
repeated ProposalRewardStatus include_reward_status = 4
Include proposals that have a reward status in this list (see [ProposalRewardStatus] for more information). If this list is empty, no restriction is applied. For example, many users listing proposals will only be interested in proposals for which they can receive voting rewards, i.e., with reward status PROPOSAL_REWARD_STATUS_ACCEPT_VOTES.
repeated ProposalStatus include_status = 5
Include proposals that have a status in this list (see [ProposalStatus] for more information). If this list is empty, no restriction is applied.
optional bool include_all_manage_neuron_proposals = 6
Include all ManageNeuron proposals regardless of the visibility of the proposal to the caller principal. Note that exclude_topic is still respected even when this option is set to true.
optional bool omit_large_fields = 7
Omits "large fields" from the response. Currently only omits the `logo` and `token_logo` field of CreateServiceNervousSystem proposals. This is useful to improve download times and to ensure that the response to the request doesn't exceed the message size limit.
message
governance.proto:2320repeated proposal_info = 1
message
governance.proto:855All operations that modify the state of an existing neuron are represented by instances of `ManageNeuron`. All commands are available to the `controller` of the neuron. In addition, commands related to voting, i.g., [manage_neuron::Follow] and [manage_neuron::RegisterVote], are also available to the registered hot keys of the neuron.
Used in:
optional id = 1
This is the legacy way to specify neuron IDs that is now discouraged.
oneof neuron_id_or_subaccount
The ID of the neuron to manage. This can either be a subaccount or a neuron ID.
bytes subaccount = 11
neuron_id = 12
oneof command
configure = 2
disburse = 3
spawn = 4
follow = 5
make_proposal = 6
register_vote = 7
split = 8
disburse_to_neuron = 9
claim_or_refresh = 10
merge_maturity = 13
merge = 14
stake_maturity = 15
message
governance.proto:881Add a new hot key that can be used to manage the neuron. This provides an alternative to using the controller principal’s cold key to manage the neuron, which might be onerous and difficult to keep secure, especially if it is used regularly. A hot key might be a WebAuthn key that is maintained inside a user device, such as a smartphone.
Used in:
optional new_hot_key = 1
message
governance.proto:904Changes auto-stake maturity for this Neuron. While on, auto-stake maturity will cause all the maturity generated by voting rewards to this neuron to be automatically staked and contribute to the voting power of the neuron.
Used in:
bool requested_setting_for_auto_stake_maturity = 1
message
governance.proto:1039Claim a new neuron or refresh the stake of an existing neuron.
Used in: ,
oneof by
uint64 memo = 1
DEPRECATED: Use MemoAndController and omit the controller.
memo_and_controller = 2
Claim or refresh a neuron, by providing the memo used in the staking transfer and 'controller' as the principal id used to calculate the subaccount to which the transfer was made. If 'controller' is omitted, the principal id of the caller is used.
neuron_id_or_subaccount = 3
This just serves as a tag to indicate that the neuron should be refreshed by it's id or subaccount. This does not work to claim new neurons.
message
governance.proto:1040Used in:
uint64 memo = 1
optional controller = 2
message
governance.proto:910Commands that only configure a given neuron, but do not interact with the outside world. They all require the caller to be the controller of the neuron.
Used in: ,
oneof operation
increase_dissolve_delay = 1
start_dissolving = 2
stop_dissolving = 3
add_hot_key = 4
remove_hot_key = 5
set_dissolve_timestamp = 6
join_community_fund = 7
leave_community_fund = 8
change_auto_stake_maturity = 9
message
governance.proto:925Disburse this neuron's stake: transfer the staked ICP to the specified account.
Used in: ,
optional amount = 1
The (optional) amount to transfer. If not specified the cached stake is used.
optional to_account = 2
The principal to which to transfer the stake.
message
governance.proto:927Used in:
uint64 e8s = 1
message
governance.proto:990Disburse a portion of this neuron's stake into another neuron. This allows to split a neuron but with a new dissolve delay and owned by someone else.
Used in: ,
optional new_controller = 1
The controller of the new neuron (must be set).
uint64 amount_e8s = 2
The amount to disburse.
uint64 dissolve_delay_seconds = 3
The dissolve delay of the new neuron.
bool kyc_verified = 4
Whether the new neuron has been kyc verified.
uint64 nonce = 5
The nonce with which to create the subaccount.
message
governance.proto:1024Add a rule that enables the neuron to vote automatically on proposals that belong to a specific topic, by specifying a group of followee neurons whose majority vote is followed. The configuration of such follow rules can be used to a) distribute control over voting power amongst multiple entities, b) have a neuron vote automatically when its owner lacks time to evaluate newly submitted proposals, c) have a neuron vote automatically when its own lacks the expertise to evaluate newly submitted proposals, and d) for other purposes. A follow rule specifies a set of followees. Once a majority of the followees votes to adopt or reject a proposal belonging to the specified topic, the neuron votes the same way. If it becomes impossible for a majority of the followees to adopt (for example, because they are split 50-50 between adopt and reject), then the neuron votes to reject. If a rule is specified where the proposal topic is UNSPECIFIED, then it becomes a catch-all follow rule, which will be used to vote automatically on proposals belonging to topics for which no specific rule has been specified. If the list 'followees' is empty, this removes following for a specific topic.
Used in:
Topic topic = 1
Topic UNSPECIFIED means add following for the 'catch all'.
repeated followees = 2
message
governance.proto:869The dissolve delay of a neuron can be increased up to a maximum of 8 years.
Used in:
uint32 additional_dissolve_delay_seconds = 1
message
governance.proto:897Join the Internet Computer's community fund with this neuron's present and future maturity.
Used in:
(message has no fields)
message
governance.proto:899Leave the Internet Computer's community fund.
Used in:
(message has no fields)
message
governance.proto:947Merge another neuron into this neuron.
Used in: ,
optional source_neuron_id = 1
The neuron to merge stake and maturity from.
message
governance.proto:972Merge the maturity of a neuron into the current stake. The caller can choose a percentage of the current maturity to merge into the existing stake. The resulting amount to merge must be greater than or equal to the transaction fee.
Used in: ,
uint32 percentage_to_merge = 1
The percentage to merge, from 1 to 100 (inclusive).
message
governance.proto:1032Have the neuron vote to either adopt or reject a proposal with a specified id.
Used in:
optional proposal = 1
Vote vote = 2
message
governance.proto:886Remove a hot key that has been previously assigned to the neuron.
Used in:
optional hot_key_to_remove = 1
message
governance.proto:892An (idempotent) alternative to IncreaseDissolveDelay where the dissolve delay is passed as an absolute timestamp in seconds since the unix epoch.
Used in:
uint64 dissolve_timestamp_seconds = 1
message
governance.proto:957When the maturity of a neuron has risen above a threshold, it can be instructed to spawn a new neuron. This creates a new neuron that locks a new balance of ICP on the ledger. The new neuron can remain controlled by the same principal as its parent, or be assigned to a new principal.
Used in:
optional new_controller = 1
If not set, the spawned neuron will have the same controller as this neuron.
optional uint64 nonce = 2
The nonce with which to create the subaccount.
optional uint32 percentage_to_spawn = 3
The percentage to spawn, from 1 to 100 (inclusive).
message
governance.proto:941Split this neuron into two neurons. The child neuron retains the parent neuron's properties.
Used in: ,
uint64 amount_e8s = 1
The amount to split to the child neuron.
message
governance.proto:982Stake the maturity of a neuron. The caller can choose a percentage of of the current maturity to stake. If 'percentage_to_stake' is not provided, all of the neuron's current maturity will be staked.
Used in:
optional uint32 percentage_to_stake = 1
The percentage of maturity to stake, from 1 to 100 (inclusive).
message
governance.proto:873Used in:
(message has no fields)
message
governance.proto:874Used in:
(message has no fields)
message
governance.proto:1082The response of the ManageNeuron command There is a dedicated response type for each `ManageNeuron.command` field
oneof command
error = 1
configure = 2
disburse = 3
spawn = 4
follow = 5
make_proposal = 6
register_vote = 7
split = 8
disburse_to_neuron = 9
claim_or_refresh = 10
merge_maturity = 11
merge = 12
stake_maturity = 13
message
governance.proto:1137Used in:
optional refreshed_neuron_id = 1
message
governance.proto:1083Used in:
(message has no fields)
message
governance.proto:1085Used in:
uint64 transfer_block_height = 1
The block height at which the disburse transfer happened
message
governance.proto:1132Used in:
optional created_neuron_id = 1
The ID of the Neuron created from disbursing a Neuron
message
governance.proto:1105Used in:
(message has no fields)
message
governance.proto:1107Used in:
optional proposal_id = 1
The ID of the created proposal
optional string message = 2
message
governance.proto:1095Used in:
uint64 merged_maturity_e8s = 1
uint64 new_stake_e8s = 2
message
governance.proto:1121A response for merging or simulating merge neurons
Used in:
optional source_neuron = 1
The resulting state of the source neuron
optional target_neuron = 2
The resulting state of the target neuron
optional source_neuron_info = 3
The NeuronInfo of the source neuron
optional target_neuron_info = 4
The NeuronInfo of the target neuron
message
governance.proto:1113Used in:
(message has no fields)
message
governance.proto:1090Used in:
optional created_neuron_id = 1
The ID of the Neuron created from spawning a Neuron
message
governance.proto:1115Used in:
optional created_neuron_id = 1
The ID of the Neuron created from splitting another Neuron
message
governance.proto:1100Used in:
uint64 maturity_e8s = 1
uint64 staked_maturity_e8s = 2
message
governance.proto:2389The most recent monthly Node Provider rewards
Used in:
uint64 timestamp = 1
repeated rewards = 2
message
governance.proto:662If adopted, a motion should guide the future strategy of the Internet Computer ecosystem.
Used in:
string motion_text = 1
The text of the motion. Maximum 100kib.
message
governance.proto:1682Network economics contains the parameters for several operations related to the economy of the network. When submitting a NetworkEconomics proposal default values (0) are considered unchanged, so a valid proposal only needs to set the parameters that it wishes to change. In other words, it's not possible to set any of the values of NetworkEconomics to 0. NOTE: If adding a value to this proto, make sure there is a corresponding `if` in Governance::perform_action().
Used in: ,
uint64 reject_cost_e8s = 1
The number of E8s (10E-8 of an ICP token) that a rejected proposal will cost. This fee should be controlled by an #Economic proposal type. The fee does not apply for ManageNeuron proposals.
uint64 neuron_minimum_stake_e8s = 2
The minimum number of E8s that can be staked in a neuron.
uint64 neuron_management_fee_per_proposal_e8s = 4
The number of E8s (10E-8 of an ICP token) that it costs to employ the 'manage neuron' functionality through proposals. The cost is incurred by the neuron that makes the 'manage neuron' proposal and is applied regardless of whether the proposal is adopted or rejected.
uint64 minimum_icp_xdr_rate = 5
The minimum number that the ICP/XDR conversion rate can be set to. Measured in XDR (the currency code of IMF SDR) to two decimal places. See /rs/protobuf/def/registry/conversion_rate/v1/conversion_rate.proto for more information on the rate itself.
uint64 neuron_spawn_dissolve_delay_seconds = 6
The dissolve delay of a neuron spawned from the maturity of an existing neuron.
uint64 maximum_node_provider_rewards_e8s = 8
The maximum rewards to be distributed to NodeProviders in a single distribution event, in e8s.
uint64 transaction_fee_e8s = 9
The transaction fee that must be paid for each ledger transaction.
uint32 max_proposals_to_keep_per_topic = 10
The maximum number of proposals to keep, per topic for eligible topics. When the total number of proposals for a given topic is greater than this number, the oldest proposals that have reached a "final" state may be deleted. If unspecified or zero, all proposals are kept.
optional neurons_fund_economics = 11
Global Neurons' Fund participation thresholds.
message
governance.proto:243This structure represents a neuron "at rest" in governance system of the Internet Computer IC.
Used in: , ,
optional id = 1
The id of the neuron. This is stored here temporarily, since its also stored on the map that contains neurons. Initialization uses ids for the following graph. We need neurons to come into existence at genesis with pre-chosen ids, so a neuron needs to have an id. We could alternatively choose a unique naming scheme instead and chose the ids on the initialization of the canister.
bytes account = 2
The principal of the ICP ledger account where the locked ICP balance resides. This principal is indistinguishable from one identifying a public key pair, such that those browsing the ICP ledger cannot tell which balances belong to neurons.
optional controller = 3
The principal that actually controls the neuron. The principal must identify a public key pair, which acts as a “master key”, such that the corresponding secret key should be kept very secure. The principal may control many neurons.
repeated hot_keys = 4
Keys that can be used to perform actions with limited privileges without exposing the secret key corresponding to the principal e.g. could be a WebAuthn key.
uint64 cached_neuron_stake_e8s = 5
The amount of staked ICP tokens, measured in fractions of 10E-8 of an ICP. Cached record of the locked ICP balance on the ICP ledger. For neuron creation: has to contain some minimum amount. A spawned neuron with less stake cannot increase its dissolve delay.
uint64 neuron_fees_e8s = 6
The amount of ICP that this neuron has forfeited due to making proposals that were subsequently rejected or from using the 'manage neurons through proposals' functionality. Must be smaller than 'neuron_stake_e8s'. When a neuron is disbursed, these ICP will be burned.
uint64 created_timestamp_seconds = 7
When the Neuron was created. A neuron can only vote on proposals submitted after its creation date.
uint64 aging_since_timestamp_seconds = 8
The timestamp, in seconds from the Unix epoch, corresponding to the time this neuron has started aging. This is either the creation time or the last time at which the neuron has stopped dissolving. This value is meaningless when the neuron is dissolving, since a dissolving neurons always has age zero. The canonical value of this field for a dissolving neuron is `u64::MAX`.
optional uint64 spawn_at_timestamp_seconds = 19
The timestamp, in seconds from the Unix epoch, at which this neuron should be spawned and its maturity converted to ICP according to https://wiki.internetcomputer.org/wiki/Maturity_modulation.
oneof dissolve_state
At any time, at most one of `when_dissolved` and `dissolve_delay` are specified. `NotDissolving`. This is represented by `dissolve_delay` being set to a non zero value. `Dissolving`. This is represented by `when_dissolved` being set, and this value is in the future. `Dissolved`. All other states represent the dissolved state. That is, (a) `when_dissolved` is set and in the past, (b) `dissolve_delay` is set to zero, (c) neither value is set. Cf. [Neuron::stop_dissolving] and [Neuron::start_dissolving].
uint64 when_dissolved_timestamp_seconds = 9
When the dissolve timer is running, this stores the timestamp, in seconds from the Unix epoch, at which the neuron becomes dissolved. At any time while the neuron is dissolving, the neuron owner may pause dissolving, in which case `dissolve_delay_seconds` will get assigned to: `when_dissolved_timestamp_seconds - <timestamp when the action is taken>`.
uint64 dissolve_delay_seconds = 10
When the dissolve timer is stopped, this stores how much time, in seconds, the dissolve timer will be started with. Can be at most 8 years. At any time while in this state, the neuron owner may (re)start dissolving, in which case `when_dissolved_timestamp_seconds` will get assigned to: `<timestamp when the action is taken> + dissolve_delay_seconds`.
map<int32, > followees = 11
Map `Topic` to followees. The key is represented by an integer as Protobuf does not support enum keys in maps.
repeated recent_ballots = 12
Information about how this neuron voted in the recent past. It only contains proposals that the neuron voted yes or no on.
bool kyc_verified = 13
`true` if this neuron has passed KYC, `false` otherwise
optional transfer = 14
The record of the transfer that was made to create this neuron.
uint64 maturity_e8s_equivalent = 15
The accumulated unstaked maturity of the neuron, in "e8s equivalent". The unit is "e8s equivalent" to insist that, while this quantity is on the same scale as ICPs, maturity is not directly convertible to ICPs: conversion requires a minting event and the conversion rate is variable.
optional uint64 staked_maturity_e8s_equivalent = 20
The accumulated staked maturity of the neuron, in "e8s equivalent" (see "maturity_e8s_equivalent"). Staked maturity becomes regular maturity once the neuron is dissolved. Contrary to `maturity_e8s_equivalent` this maturity is staked and thus locked until the neuron is dissolved and contributes to voting power and rewards. Once the neuron is dissolved, this maturity will be "moved" to 'maturity_e8s_equivalent' and will be able to be spawned (with maturity modulation).
optional bool auto_stake_maturity = 21
If set and true the maturity rewarded to this neuron for voting will be automatically staked and will contribute to the neuron's voting power.
bool not_for_profit = 16
Whether this neuron is "Not for profit", making it dissolvable by voting.
optional uint64 joined_community_fund_timestamp_seconds = 17
If set, this neuron is a member of the Community Fund. This means that when a proposal to open an SNS token swap is executed, maturity from this neuron will be used to participate in the SNS token swap.
optional known_neuron_data = 18
If set, the neuron belongs to the "known neurons". It has been given a name and maybe a description.
optional NeuronType neuron_type = 22
The type of the Neuron. See [NeuronType] for a description of the different states.
message
governance.proto:346Protobuf representing a list of followees of a neuron for a specific topic.
Used in: , ,
repeated followees = 1
message
governance.proto:188The result of querying for the state of a single neuron.
Used in: ,
uint64 retrieved_at_timestamp_seconds = 1
The exact time at which this data was computed. This means, for example, that the exact time that this neuron will enter the dissolved state, assuming it is currently dissolving, is given by `retrieved_at_timestamp_seconds+dissolve_delay_seconds`.
NeuronState state = 2
The current state of the neuron. See [NeuronState] for a description of the different states.
uint64 age_seconds = 3
The current age of the neuron. See [Neuron::age_seconds] for details on how it is computed.
uint64 dissolve_delay_seconds = 4
The current dissolve delay of the neuron. See [Neuron::dissolve_delay_seconds] for details on how it is computed.
repeated recent_ballots = 5
See [Neuron::recent_ballots] for a description.
uint64 voting_power = 6
Current voting power of the neuron.
uint64 created_timestamp_seconds = 7
When the Neuron was created. A neuron can only vote on proposals submitted after its creation date.
uint64 stake_e8s = 8
Current stake of the neuron, in e8s.
optional uint64 joined_community_fund_timestamp_seconds = 9
Timestamp when this neuron joined the community fund.
optional known_neuron_data = 10
If this neuron is a known neuron, this is data associated with it, including the neuron's name and (optionally) a description.
optional NeuronType neuron_type = 11
The type of the Neuron. See [NeuronType] for a description of the different states.
message
governance.proto:224A transfer performed from some account to stake a new neuron.
Used in: ,
uint64 transfer_timestamp = 1
When the transfer arrived at the governance canister.
optional from = 2
The principal that made the transfer.
bytes from_subaccount = 3
The (optional) subaccount from which the transfer was made.
bytes to_subaccount = 4
The subaccount to which the transfer was made.
uint64 neuron_stake_e8s = 5
The amount of stake that was transferred.
uint64 block_height = 6
The block height at which the transfer occurred.
uint64 memo = 7
The memo sent with the transfer.
Every neuron is in one of three states. Note that `Disbursed` is not a state of a neuron, as the neuron is consumed through the act of disbursement (using the method [Governance::disburse]). See [neuron::DissolveState] for detail on how the different states are represented.
Used in:
NEURON_STATE_UNSPECIFIED = 0
Not a valid state. Required by Protobufs.
NEURON_STATE_NOT_DISSOLVING = 1
In this state, the neuron is not dissolving and has a specific `dissolve_delay`. It accrues `age` by the passage of time and it can vote if `dissolve_delay` is at least six months. The method [Neuron::start_dissolving] can be called to transfer the neuron to the `Dissolving` state. The method [Neuron::increase_dissolve_delay] can be used to increase the dissolve delay without affecting the state or the age of the neuron.
NEURON_STATE_DISSOLVING = 2
In this state, the neuron's `dissolve_delay` decreases with the passage of time. While dissolving, the neuron's age is considered zero. Eventually it will reach the `Dissolved` state. The method [Neuron::stop_dissolving] can be called to transfer the neuron to the `NotDissolving` state, and the neuron will start aging again. The method [Neuron::increase_dissolve_delay] can be used to increase the dissolve delay, but this will not stop the timer or affect the age of the neuron.
NEURON_STATE_DISSOLVED = 3
In the dissolved state, the neuron's stake can be disbursed using the [Governance::disburse] method. It cannot vote as its `dissolve_delay` is considered to be zero. If the method [Neuron::increase_dissolve_delay] is called in this state, the neuron will no longer be dissolving, with the specified dissolve delay, and will start aging again. Neuron holders have an incentive not to keep neurons in the 'dissolved' state for a long time: if the holders wants to make their tokens liquid, they disburse the neuron's stake, and if they want to earn voting rewards, they increase the dissolve delay. If these incentives turn out to be insufficient, the NNS may decide to impose further restrictions on dissolved neurons.
NEURON_STATE_SPAWNING = 4
The neuron is in spawning state, meaning it's maturity will be converted to ICP according to https://wiki.internetcomputer.org/wiki/Maturity_modulation.
Types of a Neuron.
Used in: , ,
NEURON_TYPE_UNSPECIFIED = 0
Placeholder value due to the proto3 requirement for a zero default. This is an invalid type; neurons should not be assigned this value.
NEURON_TYPE_SEED = 1
Represents neurons initially created for Seed accounts in the Genesis Token Canister, or those descended from such neurons.
NEURON_TYPE_ECT = 2
Represents neurons initially created for Early Contributor Token (ECT) accounts in the Genesis Token Canister, or those descended from such neurons.
message
governance.proto:1402This is a view of the NeuronsFundData returned by API queries and is NOT used for storage. Currently, the structure is identical to NeuronsFundData, but this may change over time. Some of the fields, e.g., actual IDs of neurons, are anonymized.
Used in:
optional initial_neurons_fund_participation = 1
See documentation for NeuronsFundData.neurons_fund_participation
optional final_neurons_fund_participation = 2
See documentation for NeuronsFundData.final_neurons_fund_participation
optional neurons_fund_refunds = 3
See documentation for NeuronsFundData.neurons_fund_refunds
message
governance.proto:1378This structure contains data for settling the Neurons' Fund participation in an SNS token swap.
Used in:
optional initial_neurons_fund_participation = 1
Initial Neurons' Fund reserves computed at the time of execution of the proposal through which the SNS swap is created.
optional final_neurons_fund_participation = 2
Final Neurons' Fund participation computed at the time of swap finalization. This field should remain unspecified until either (1) the `settle_neurons_fund_participation` function is called or (2) the NNS handles an error at the SNS deployment stage. If specified, this must be a subset of `initial_neurons_fund_participation`.
optional neurons_fund_refunds = 3
Refunds for any leftover Neurons' Fund maturity that could not be used to participate in the swap. This field should remain unspecified `settle_neurons_fund_participation` is called. If specified, this must be equal to the following set-difference: `initial_neurons_fund_participation.neurons_fund_reserves` set-minus `final_neurons_fund_participation.neurons_fund_reserves`.
message
governance.proto:1762When the Neurons' Fund decides to participates in an SNS swap, the amount of participation is determined according to the rules of Matched Funding. The amount of ICP tokens contributed by the Neurons' Fund depends on four factors: (1) Direct participation amount at the time of the swap's successful finalization. (2) Amount of maturity held by all eligible neurons that were members of the Neurons' Fund at the time of the CreateServiceNervousSystem proposal execution. (3) Global Neurons' Fund participation thresholds, held in this structure (defined in XDR). (4) ICP/XDR conversion rate at the time of the CreateServiceNervousSystem proposal execution.
Used in:
optional max_theoretical_neurons_fund_participation_amount_xdr = 1
This is a theoretical limit which should be smaller than any realistic amount of maturity that practically needs to be reserved from the Neurons' Fund for a given SNS swap.
optional neurons_fund_matched_funding_curve_coefficients = 2
Thresholds specifying the shape of the matching function used by the Neurons' Fund to determine how much to contribute for a given direct participation amount.
optional minimum_icp_xdr_rate = 3
The minimum value of the ICP/XDR conversion rate used by the Neurons' Fund for converting XDR values into ICP.
optional maximum_icp_xdr_rate = 4
The maximum value of the ICP/XDR conversion rate used by the Neurons' Fund for converting XDR values into ICP.
message
governance.proto:1737The thresholds specify the shape of the ideal matching function used by the Neurons' Fund to determine how much to contribute for a given direct participation amount. Note that the actual swap participation is in ICP, whereas these thresholds are specifid in XDR; the conversion rate is determined at the time of execution of the CreateServiceNervousSystem proposal.
Used in:
optional contribution_threshold_xdr = 1
Up to this amount of direct participation, the Neurons' Fund does not contribute to this SNS.
optional one_third_participation_milestone_xdr = 2
Say the direct participation amount is `x_icp`. When `x_icp` equals the equavalent of `one_third_participation_milestone_xdr` in ICP (we use ICP/XDR conversion data from the CMC), the Neurons' Fund contributes 50% on top of that amount, so the overall contributions would be `1.5 * x_icp` of which 1/3 comes from the Neurons' Fund.
optional full_participation_milestone_xdr = 3
Say the direct participation amount is `x_icp`. When `x_icp` equals the equavalent of `full_participation_milestone_xdr` in ICP (we use ICP/XDR conversion data from the CMC), the Neurons' Fund contributes 100% on top of that amount, so the overall contributions would be `2.0 * x_icp` of which a half comes from the Neurons' Fund.
message
governance.proto:1432Information for deciding how the Neurons' Fund should participate in an SNS Swap.
Used in: ,
optional ideal_matched_participation_function = 1
The function used in the implementation of Matched Funding. If an NNS Governance upgrade takes place *during* a swap, the original "ideal" matched participation function needs to be recovered at the end of the swap, ensuring e.g., that the amount of maturity stored in `neurons_fund_snapshot` will not not be exceeded for due to a change in this function.
optional neurons_fund_reserves = 2
The snapshot of the Neurons' Fund allocation of its maximum swap participation amount among its neurons. This snapshot is computed at the execution time of the NNS proposal leading to the swap opening.
optional swap_participation_limits = 3
Absolute constraints for direct participants of this swap needed in Matched Funding computations.
optional uint64 direct_participation_icp_e8s = 4
Neurons' Fund participation is computed for this amount of direct participation.
optional uint64 total_maturity_equivalent_icp_e8s = 5
Total amount of maturity in the Neurons' Fund at the time when the Neurons' Fund participation was created.
optional uint64 max_neurons_fund_swap_participation_icp_e8s = 6
Maximum amount that the Neurons' Fund will participate with in this SNS swap, regardless of how large the value of `direct_participation_icp_e8s` is.
optional uint64 intended_neurons_fund_participation_icp_e8s = 7
How much the Neurons' Fund would ideally like to participate with in this SNS swap, given the direct participation amount (`direct_participation_icp_e8s`) and matching function (`ideal_matched_participation_function`).
optional uint64 allocated_neurons_fund_participation_icp_e8s = 8
How much from `intended_neurons_fund_participation_icp_e8s` was the Neurons' Fund actually able to allocate, given the specific composition of neurons at the time of execution of the proposal through which this SNS was created and the participation limits of this SNS.
message
governance.proto:1490The snapshot of the Neurons' Fund allocation of its maximum swap participation amount among its neurons. This snapshot is computed at the execution time of the NNS proposal leading to the swap opening; it is then used at the end of a swap to compute the refund amounts per Neuron' Fund neuron.
Used in: , ,
repeated neurons_fund_neuron_portions = 1
message
governance.proto:1492Represents one NNS neuron from the Neurons' Fund participating in this swap.
Used in:
optional nns_neuron_id = 1
The NNS neuron ID of the participating neuron.
optional uint64 amount_icp_e8s = 2
Portion of maturity taken from this neuron. Must be less than or equal to `maturity_equivalent_icp_e8s`.
optional uint64 maturity_equivalent_icp_e8s = 3
Overall amount of maturity of the neuron from which this portion is taken.
optional hotkey_principal = 4
The principal that can vote on behalf of this neuron.
optional bool is_capped = 5
Whether the portion specified by `amount_icp_e8s` is limited due to SNS-specific participation constraints.
List of NNS functions that can be called by proposals.
Used in:
NNS_FUNCTION_UNSPECIFIED = 0
This exists because proto3 defaults to the 0 value on enums.
NNS_FUNCTION_CREATE_SUBNET = 1
Combine a specified set of nodes, typically drawn from data centers and operators in such a way as to guarantee their independence, into a new decentralized subnet. The execution of this NNS function first initiates a new instance of the distributed key generation protocol. The transcript of that protocol is written to a new subnet record in the registry, together with initial configuration information for the subnet, from where the nodes comprising the subnet pick it up.
NNS_FUNCTION_ADD_NODE_TO_SUBNET = 2
Add a new node to a subnet. The node cannot be currently assigned to a subnet. The execution of this proposal changes an existing subnet record to add a node. From the perspective of the NNS, this update is a simple update of the subnet record in the registry.
NNS_FUNCTION_NNS_CANISTER_INSTALL = 3
A proposal to add a new canister to be installed and executed in the NNS subnetwork. The root canister, which controls all canisters on the NNS except for itself, handles this proposal type. The call also expects the Wasm module that shall be installed.
NNS_FUNCTION_NNS_CANISTER_UPGRADE = 4
A proposal to upgrade an existing canister in the NNS subnetwork. This proposal type is executed by the root canister. Beyond upgrading the Wasm module of the target canister, the proposal can also set the authorization information and the allocations.
NNS_FUNCTION_BLESS_REPLICA_VERSION = 5
A proposal to bless a new version to which the replicas can be upgraded. The proposal registers a replica version (identified by the hash of the installation image) in the registry. Besides creating a record for that version, the proposal also appends that version to the list of "blessed versions" that can be installed on a subnet. By itself, this proposal does not effect any upgrade.
NNS_FUNCTION_RECOVER_SUBNET = 6
Update a subnet's recovery CUP (used to recover subnets that have stalled). Nodes that find a recovery CUP for their subnet will load that CUP from the registry and restart the replica from that CUP.
NNS_FUNCTION_UPDATE_CONFIG_OF_SUBNET = 7
Update a subnet's configuration. This proposal updates the subnet record in the registry, with the changes being picked up by the nodes on the subnet when they reference the respective registry version. Subnet configuration comprises protocol parameters that must be consistent across the subnet (e.g. message sizes).
NNS_FUNCTION_ASSIGN_NOID = 8
Assign an identity to a node operator, such as a funding partner, associating key information regarding its ownership, the jurisdiction in which it is located, and other information. The node operator is stored as a record in the registry. It contains the remaining node allowance for that node operator, that is the number of nodes the node operator can still add to the IC. When an additional node is added by the node operator, the remaining allowance is decreased.
NNS_FUNCTION_NNS_ROOT_UPGRADE = 9
A proposal to upgrade the root canister in the NNS subnetwork. The proposal is processed by the Lifeline canister, which controls the root canister. The proposal updates the Wasm module as well as the authorization settings.
NNS_FUNCTION_ICP_XDR_CONVERSION_RATE = 10
Update the ICP/XDR conversion rate. Changes the ICP-to-XDR conversion rate in the governance canister. This setting affects cycles pricing (as the value of cycles shall be constant with respect to IMF SDRs) as well as the rewards paid for nodes, which are expected to be specified in terms of IMF SDRs as well.
NNS_FUNCTION_DEPLOY_GUESTOS_TO_ALL_SUBNET_NODES = 11
Deploy a GuestOS version to a given subnet. The proposal changes the GuestOS version that is used on the specified subnet. The version must be contained in the list of elected GuestOS versions. The upgrade is completed when the subnet creates the next regular CUP.
NNS_FUNCTION_CLEAR_PROVISIONAL_WHITELIST = 12
Clear the provisional whitelist. The proposal changes the provisional whitelist to the empty list.
NNS_FUNCTION_REMOVE_NODES_FROM_SUBNET = 13
Removes a node from a subnet. The node must be currently assigned to a subnet. The execution of this proposal changes an existing subnet record to remove a node. From the perspective of the NNS, this update is a simple update of the subnet record in the registry.
NNS_FUNCTION_SET_AUTHORIZED_SUBNETWORKS = 14
Informs the cycles minting canister that a certain principal is authorized to use certain subnetworks (from a list). Can also be used to set the "default" list of subnetworks that principals without special authorization are allowed to use.
NNS_FUNCTION_SET_FIREWALL_CONFIG = 15
Change the Firewall configuration in the registry. (TODO: Remove when IC-1026 is fully integrated)
NNS_FUNCTION_UPDATE_NODE_OPERATOR_CONFIG = 16
Change a Node Operator's allowance in the registry.
NNS_FUNCTION_STOP_OR_START_NNS_CANISTER = 17
Stop or start an NNS canister.
NNS_FUNCTION_REMOVE_NODES = 18
Remove unassigned nodes from the registry.
NNS_FUNCTION_UNINSTALL_CODE = 19
Uninstall code of a canister.
NNS_FUNCTION_UPDATE_NODE_REWARDS_TABLE = 20
Update the node rewards table.
NNS_FUNCTION_ADD_OR_REMOVE_DATA_CENTERS = 21
Add or remove Data Center records.
NNS_FUNCTION_UPDATE_UNASSIGNED_NODES_CONFIG = 22
(obsolete) Update the config for all unassigned nodes.
NNS_FUNCTION_REMOVE_NODE_OPERATORS = 23
Remove Node Operator from the registry.
NNS_FUNCTION_REROUTE_CANISTER_RANGES = 24
Update the routing table in the registry.
NNS_FUNCTION_ADD_FIREWALL_RULES = 25
Add firewall rules in the registry
NNS_FUNCTION_REMOVE_FIREWALL_RULES = 26
Remove firewall rules in the registry
NNS_FUNCTION_UPDATE_FIREWALL_RULES = 27
Update firewall rules in the registry
NNS_FUNCTION_PREPARE_CANISTER_MIGRATION = 28
Insert or update `canister_migrations` entries.
NNS_FUNCTION_COMPLETE_CANISTER_MIGRATION = 29
Remove `canister_migrations` entries.
NNS_FUNCTION_ADD_SNS_WASM = 30
Add a new SNS canister WASM
NNS_FUNCTION_CHANGE_SUBNET_MEMBERSHIP = 31
Change the subnet node membership. In a way, this function combines the separate functions for adding and removing nodes from the subnet record, but adds the property of atomic node replacement (node swap) on top. The nodes that are being added to the subnet must be currently unassigned. The nodes that are being removed from the subnet must be currently assigned to the subnet.
NNS_FUNCTION_UPDATE_SUBNET_TYPE = 32
Updates the available subnet types in the cycles minting canister.
NNS_FUNCTION_CHANGE_SUBNET_TYPE_ASSIGNMENT = 33
Changes the assignment of subnets to subnet types in the cycles minting canister.
NNS_FUNCTION_UPDATE_SNS_WASM_SNS_SUBNET_IDS = 34
Update the list of SNS subnet IDs that SNS WASM will deploy SNS instances to.
NNS_FUNCTION_UPDATE_ALLOWED_PRINCIPALS = 35
Update the SNS-wasm canister's list of allowed principals. This list guards which principals can deploy an SNS.
NNS_FUNCTION_RETIRE_REPLICA_VERSION = 36
A proposal to retire previously elected and unused replica versions. The specified versions are removed from the registry and the "blessed versions" record. This ensures that the replica cannot upgrade to these versions anymore.
NNS_FUNCTION_INSERT_SNS_WASM_UPGRADE_PATH_ENTRIES = 37
Insert custom upgrade path entries into SNS-W for all SNSes, or for an SNS specified by its governance canister ID.
NNS_FUNCTION_REVISE_ELECTED_GUESTOS_VERSIONS = 38
A proposal to change the set of elected GuestOS versions. The version to elect (identified by the hash of the installation image) is added to the registry. Besides creating a record for that version, the proposal also appends that version to the list of elected versions that can be installed on nodes of a subnet. Only elected GuestOS versions can be deployed.
NNS_FUNCTION_BITCOIN_SET_CONFIG = 39
NNS_FUNCTION_UPDATE_ELECTED_HOSTOS_VERSIONS = 40
OBSOLETE: use NNS_FUNCTION_REVISE_ELECTED_HOSTOS_VERSIONS instead
NNS_FUNCTION_UPDATE_NODES_HOSTOS_VERSION = 41
OBSOLETE: use NNS_FUNCTION_UPGRADE_HOSTOS_FOR_SOME_NODES instead
NNS_FUNCTION_HARD_RESET_NNS_ROOT_TO_VERSION = 42
Uninstall and Install Root with the WASM provided in the function. If InitArgs are provided They will be passed to the canister_init function of the WASM provided. This function is meant as a Break Glass mechanism for when an open call context in the Root canister is preventing root or another canister from upgrading (in the case of proxied calls).
NNS_FUNCTION_ADD_API_BOUNDARY_NODES = 43
A proposal to add a set of new API Boundary Nodes using unassigned nodes
NNS_FUNCTION_REMOVE_API_BOUNDARY_NODES = 44
A proposal to remove a set of API Boundary Nodes, which will designate them as unassigned nodes
NNS_FUNCTION_UPDATE_API_BOUNDARY_NODES_VERSION = 46
(obsolete) A proposal to update the version of a set of API Boundary Nodes
NNS_FUNCTION_DEPLOY_GUESTOS_TO_SOME_API_BOUNDARY_NODES = 47
A proposal to update the version of a set of API Boundary Nodes
NNS_FUNCTION_DEPLOY_GUESTOS_TO_ALL_UNASSIGNED_NODES = 48
A proposal to update the version of all unassigned nodes
NNS_FUNCTION_UPDATE_SSH_READONLY_ACCESS_FOR_ALL_UNASSIGNED_NODES = 49
A proposal to update SSH readonly access for all unassigned nodes
NNS_FUNCTION_REVISE_ELECTED_HOSTOS_VERSIONS = 50
A proposal to change the set of currently elected HostOS versions, by electing a new version, and/or unelecting some priorly elected versions. HostOS versions are identified by the hash of the installation image. The version to elect is added to the Registry, and the versions to unelect are removed from the Registry, ensuring that HostOS cannot upgrade to these versions anymore. This proposal does not actually perform the upgrade; for deployment of an elected version, please refer to `NNS_FUNCTION_DEPLOY_HOSTOS_TO_SOME_NODES`.
NNS_FUNCTION_DEPLOY_HOSTOS_TO_SOME_NODES = 51
Deploy a HostOS version to a given set of nodes. The proposal changes the HostOS version that is used on the specified nodes.
message
governance.proto:21The entity that owns the nodes that run the network. Note that this is different from a node operator, the entity that operates the nodes. In terms of responsibilities, the node operator is responsible for adding/removing and generally making sure that the nodes are working, while the NodeProvider is the entity that is compensated. Note: The NodeOperatorRecord is defined in: rs/protobuf/def/registry/node_operator/v1/node_operator.proto.
Used in: , , ,
optional id = 1
The ID of the node provider.
optional reward_account = 2
The account where rewards earned from providing nodes will be sent.
message
governance.proto:1853Proposal action to call the "open" method of an SNS token swap canister.
Used in:
optional target_swap_canister_id = 1
The ID of the canister where the command will be sent (assuming that the proposal is adopted, of course).
optional params = 2
Various limits on the swap.
optional uint64 community_fund_investment_e8s = 3
The amount that the community fund will collectively spend in maturity on the swap.
message
governance.proto:761A proposal is the immutable input of a proposal submission. This contains all the information from the original proposal submission. Making a proposal implicitly votes yes.
Used in: , , ,
optional string title = 20
Must be present (enforced at the application layer, not by PB). A brief description of what the proposal does. Size in bytes must be in the interval [5, 256].
string summary = 1
Text providing a short description of the proposal, composed using a maximum of 30000 bytes of characters.
string url = 2
The Web address of additional content required to evaluate the proposal, specified using HTTPS. For example, the address might describe content supporting the assignment of a DCID (data center id) to a new data center. The URL string must not be longer than 2000 bytes.
oneof action
This section describes the action that the proposal proposes to take.
manage_neuron = 10
This type of proposal calls a major function on a specified target neuron. Only the followees of the target neuron (on the topic [Topic::ManageNeuron]) may vote on these proposals, which effectively provides the followees with control over the target neuron. This can provide a convenient and highly secure means for a team of individuals to manage an important neuron. For example, a neuron might hold a large balance, or belong to an organization of high repute, and be publicized so that many other neurons can follow its vote. In both cases, managing the private key of the principal securely could be problematic (either a single copy is held, which is very insecure and provides for a single party to take control, or a group of individuals must divide responsibility, for example using threshold cryptography, which is complex and time consuming). To address this, using this proposal type, the important neuron can be configured to follow the neurons controlled by individual members of a team. Now they can submit proposals to make the important neuron perform actions, which are adopted if and only if a majority of them vote to adopt. Nearly any command on the target neuron can be executed, including commands that change the follow rules, allowing the set of team members to be dynamic. Only the final step of dissolving the neuron once its dissolve delay reaches zero cannot be performed using this type of proposal (since this would allow control/“ownership” over the locked balances to be transferred). To prevent a neuron falling under the malign control of the principal’s private key by accident, the private key can be destroyed so that the neuron can only be controlled by its followees, although this makes it impossible to subsequently unlock the balance.
manage_network_economics = 12
Propose a change to some network parameters of network economics.
motion = 13
See [Motion]
execute_nns_function = 14
A update affecting something outside of the Governance canister.
approve_genesis_kyc = 15
Approve Genesis KYC for a given list of principals.
add_or_remove_node_provider = 16
Add/remove NodeProvider from the list of NodeProviders
reward_node_provider = 17
Reward a NodeProvider
set_default_followees = 18
Set the default following
reward_node_providers = 19
Reward multiple NodeProvider
register_known_neuron = 21
Register Known Neuron
set_sns_token_swap_open_time_window = 22
Obsolete. Superseded by CreateServiceNervousSystem. Kept for Candid compatibility.
open_sns_token_swap = 23
Call the open method on an SNS swap canister. This is still supported but will soon be superseded by CreateServiceNervousSystem.
create_service_nervous_system = 24
Create a new SNS.
message
governance.proto:1289A ProposalData contains everything related to an open proposal: the proposal itself (immutable), as well as mutable data such as ballots.
Used in:
optional id = 1
This is stored here temporarily. It is also stored on the map that contains proposals. Immutable: The unique id for this proposal.
optional proposer = 2
Immutable: The ID of the neuron that made this proposal.
uint64 reject_cost_e8s = 3
Immutable: The amount of ICP in E8s to be charged to the proposer if the proposal is rejected.
optional proposal = 4
Immutable: The proposal originally submitted.
uint64 proposal_timestamp_seconds = 5
Immutable: The timestamp, in seconds from the Unix epoch, when this proposal was made.
map<fixed64, > ballots = 6
Map neuron ID to to the neuron's vote and voting power. Only present for as long as the proposal is not yet settled with respect to rewards.
optional latest_tally = 7
Latest tally. Recomputed for every vote. Even after the proposal has been decided, the latest_tally will still be updated based on the recent vote, until the voting deadline.
uint64 decided_timestamp_seconds = 8
If specified: the timestamp when this proposal was adopted or rejected. If not specified, this proposal is still 'open'.
uint64 executed_timestamp_seconds = 12
When an adopted proposal has been executed, this is set to current timestamp.
uint64 failed_timestamp_seconds = 13
When an adopted proposal has failed to be executed, this is set to the current timestamp.
optional failure_reason = 15
When an adopted proposal has failed to executed, this is set the reason for the failure.
uint64 reward_event_round = 14
The reward event round at which rewards for votes on this proposal was distributed. Rounds do not have to be consecutive. Rounds start at one: a value of zero indicates that no reward event taking this proposal into consideration happened yet. This field matches field day_after_genesis in RewardEvent.
optional wait_for_quiet_state = 16
Wait-for-quiet state that needs to be saved in stable memory.
optional uint64 original_total_community_fund_maturity_e8s_equivalent = 17
This is populated when an OpenSnsTokenSwap proposal is first made.
repeated cf_participants = 18
This is populated when OpenSnsTokenSwap is executed. It is used when our conclude_community_fund_participation Candid method is called to either mint ICP, or restore CF neuron maturity.
optional ic_sns_swap.pb.v1.Lifecycle sns_token_swap_lifecycle = 19
This gets set to one of the terminal values (i.e. Committed or Aborted) when the swap canister calls our conclude_community_fund_participation Candid method. Initially, it is set to Open, because swap is supposed to enter that state when we call its open Candid method, which is the main operation in the execution of an OpenSnsTokenSwap proposal.
optional derived_proposal_information = 20
optional neurons_fund_data = 21
This structure contains data for settling the Neurons' Fund participation at the end of a swap. TODO[NNS1-2566]: deprecate `original_total_community_fund_maturity_e8s_equivalent` and `cf_participants` and use only this field for managing the Neurons' Fund swap participation.
message
governance.proto:1621This is a view of the ProposalData returned by API queries and is NOT used for storage. The ballots are restricted to those of the caller's neurons and additionally it has the computed fields, topic, status, and reward_status.
Used in:
optional id = 1
The unique id for this proposal.
optional proposer = 2
The ID of the neuron that made this proposal.
uint64 reject_cost_e8s = 3
The amount of ICP in E8s to be charged to the proposer if the proposal is rejected.
optional proposal = 4
The proposal originally submitted.
uint64 proposal_timestamp_seconds = 5
The timestamp, in seconds from the Unix epoch, when this proposal was made.
map<fixed64, > ballots = 6
See [ProposalData::ballots].
optional latest_tally = 7
See [ProposalData::latest_tally].
uint64 decided_timestamp_seconds = 8
See [ProposalData::decided_timestamp_seconds].
uint64 executed_timestamp_seconds = 12
See [ProposalData::executed_timestamp_seconds].
uint64 failed_timestamp_seconds = 13
See [ProposalData::failed_timestamp_seconds].
optional failure_reason = 18
See [ProposalData::failure_reason].
uint64 reward_event_round = 14
See [ProposalData::reward_event_round].
Topic topic = 15
Derived - see [Topic] for more information
ProposalStatus status = 16
Derived - see [ProposalStatus] for more information
ProposalRewardStatus reward_status = 17
Derived - see [ProposalRewardStatus] for more information
optional uint64 deadline_timestamp_seconds = 19
optional derived_proposal_information = 20
The proposal status, with respect to reward distribution. See also ProposalStatus.
Used in: ,
PROPOSAL_REWARD_STATUS_UNSPECIFIED = 0
PROPOSAL_REWARD_STATUS_ACCEPT_VOTES = 1
The proposal still accept votes, for the purpose of vote rewards. This implies nothing on the ProposalStatus.
PROPOSAL_REWARD_STATUS_READY_TO_SETTLE = 2
The proposal no longer accepts votes. It is due to settle at the next reward event.
PROPOSAL_REWARD_STATUS_SETTLED = 3
The proposal has been taken into account in a reward event.
PROPOSAL_REWARD_STATUS_INELIGIBLE = 4
The proposal is not eligible to be taken into account in a reward event.
The proposal status, with respect to decision making and execution. See also ProposalRewardStatus.
Used in: ,
PROPOSAL_STATUS_UNSPECIFIED = 0
PROPOSAL_STATUS_OPEN = 1
A decision (adopt/reject) has yet to be made.
PROPOSAL_STATUS_REJECTED = 2
The proposal has been rejected.
PROPOSAL_STATUS_ADOPTED = 3
The proposal has been adopted (sometimes also called "accepted"). At this time, either execution as not yet started, or it has but the outcome is not yet known.
PROPOSAL_STATUS_EXECUTED = 4
The proposal was adopted and successfully executed.
PROPOSAL_STATUS_FAILED = 5
The proposal was adopted, but execution failed.
message
governance.proto:2600The summary of the restore aging event.
Used in:
optional uint64 timestamp_seconds = 1
The timestamp of the restore aging event.
repeated groups = 2
Groups of neurons that were considered for restoring their aging.
Used in:
NEURON_GROUP_TYPE_UNSPECIFIED = 0
NEURON_GROUP_TYPE_NOT_PRE_AGING = 1
The neurons in this group were not pre-aging. We don't restore their aging.
NEURON_GROUP_TYPE_DISSOLVING_OR_DISSOLVED = 2
The neurons in this group are dissolving or dissolved. We don't restore their aging because it's invalid for a dissolving/dissolved neuron to have age.
NEURON_GROUP_TYPE_STAKE_CHANGED = 3
The neurons in this group have their stake changed. We restore them to be pre-aged.
NEURON_GROUP_TYPE_STAKE_SAME_AGING_CHANGED = 4
The neurons in this group have their stake remain the same and aging changed. We restore them to be pre-aged.
NEURON_GROUP_TYPE_STAKE_SAME_AGING_SAME = 5
The neurons in this group have their stake remain the same and aging remain the same. We restore them to be pre-aged.
message
governance.proto:2623Used in:
NeuronGroupType group_type = 1
optional uint64 count = 2
The number of neurons in this group.
optional uint64 previous_total_stake_e8s = 3
The previous total stake of neurons in this group when the aging was reset.
optional uint64 current_total_stake_e8s = 4
The current total stake of neurons in this group when considering to restore aging.
message
governance.proto:1781A reward event is an event at which neuron maturity is increased
Used in:
uint64 day_after_genesis = 1
This reward event correspond to a time interval that ends at the end of genesis + day_after_genesis days. For instance: when this is 0, this is for a period that ends at genesis -- there can never be a reward for this. When this is 1, this is for the first day after genesis. On rare occasions, the reward event may cover several days ending at genesis + day_after_genesis days, when it was not possible to proceed to a reward event for a while. This makes that day_after_genesis does not have to be consecutive.
uint64 actual_timestamp_seconds = 2
The timestamp at which this reward event took place, in seconds since the unix epoch. This does not match the date taken into account for reward computation, which should always be an integer number of days after genesis.
repeated settled_proposals = 3
The list of proposals that were taken into account during this reward event.
uint64 distributed_e8s_equivalent = 4
The total amount of reward that was distributed during this reward event. The unit is "e8s equivalent" to insist that, while this quantity is on the same scale as ICPs, maturity is not directly convertible to ICPs: conversion requires a minting event to spawn a new neuron.
uint64 total_available_e8s_equivalent = 5
The total amount of rewards that was available during the reward event.
optional uint64 latest_round_available_e8s_equivalent = 7
The amount of rewards that was available during the last round included in this event. This will only be different from `total_available_e8s_equivalent` if there were "rollover rounds" included in this event.
optional uint64 rounds_since_last_distribution = 6
In some cases, the rewards that would have been distributed in one round are "rolled over" into the next reward event. This field keeps track of how many rounds have passed since the last time rewards were distributed (rather than being rolled over). For the genesis reward event, this field will be zero. In normal operation, this field will almost always be 1. There are two reasons that rewards might not be distributed in a given round. 1. "Missed" rounds: there was a long period when we did calculate rewards (longer than 1 round). (I.e. distribute_rewards was not called by heartbeat for whatever reason, most likely some kind of bug.) 2. Rollover: We tried to distribute rewards, but there were no proposals settled to distribute rewards for. In both of these cases, the rewards purse rolls over into the next round.
message
governance.proto:685This proposal payload is used to reward a node provider by minting ICPs directly to the node provider's ledger account, or into a new neuron created on behalf of the node provider.
Used in: , ,
optional node_provider = 1
The NodeProvider to reward.
uint64 amount_e8s = 2
The amount of e8s to mint to reward the node provider.
oneof reward_mode
reward_to_neuron = 4
If this is specified, executing this proposal will create a neuron instead of directly minting ICP into the node provider's account.
reward_to_account = 5
If this is specified, executing this proposal will mint to the specified account.
message
governance.proto:714Used in:
optional to_account = 1
message
governance.proto:710This message specifies how to create a new neuron on behalf of the node provider. - The controller of the new neuron is the node provider's principal. - The account is chosen at random. - The stake of the new neuron is `amount_e8s`. - `dissolve_delay_seconds` is as specified in the proto. - `kyc_verified` is set to true, as node providers are (implicitly) KYC'ed. - `not_for_profit` is set to false. - All other values are set as for other neurons: timestamp is now, following is set up per default, maturity is 0, neuron fee is 0.
Used in:
uint64 dissolve_delay_seconds = 1
message
governance.proto:732Used in:
repeated rewards = 1
optional bool use_registry_derived_rewards = 2
If true, reward Node Providers with the rewards returned by the Registry's get_node_providers_monthly_xdr_rewards method
message
governance.proto:743Changes the default followees to match the one provided. This completely replaces the default followees so entries for all Topics (except ManageNeuron) must be provided on each proposal.
Used in:
map<int32, > default_followees = 1
message
governance.proto:748Obsolete. Superseded by OpenSnsTokenSwap.
Used in:
optional swap_canister_id = 1
The swap canister to send the request to.
optional request = 2
Arguments that get sent to the swap canister when its set_open_time_window Candid method is called.
message
governance.proto:2397TODO(NNS1-1589): Until the Jira ticket gets solved, changes here need to be manually propagated to (sns) swap.proto. This message is obsolete; please use SettleNeuronsFundParticipation instead.
optional uint64 open_sns_token_swap_proposal_id = 1
The caller's principal ID must match the value in the target_swap_canister_id field in the proposal (more precisely, in the OpenSnsTokenSwap).
oneof result
Each of the possibilities here corresponds to one of two ways that a swap can terminate. See also sns_swap_pb::Lifecycle::is_terminal.
committed = 2
aborted = 3
message
governance.proto:2427When this happens, maturity needs to be restored to CF neurons. The amounts to be refunded can be found in the ProposalData's cf_participants field.
Used in:
(message has no fields)
message
governance.proto:2414When this happens, ICP needs to be minted, and sent to the SNS governance canister's main account on the ICP Ledger. As with Aborted, the amount of ICP that needs to be minted can be deduced from the ProposalData's cf_participants field.
Used in:
optional sns_governance_canister_id = 1
This is where the minted ICP will be sent. In principal, this could be fetched using the swap canister's get_state method.
optional uint64 total_direct_contribution_icp_e8s = 2
Total contribution amount from direct swap participants.
optional uint64 total_neurons_fund_contribution_icp_e8s = 3
Total contribution amount from the Neuron's Fund. TODO[NNS1-2570]: Ensure this field is set.
message
governance.proto:2464Request to settle the Neurons' Fund participation in this SNS Swap. When a swap ends, the Swap canister notifies the Neurons' Fund of the swap's ultimate result, which can be either `Committed` or `Aborted`. Note that currently, the Neurons' Fund is managed by the NNS Governance canister. * If the result is `Committed`: - Neurons' Fund computes the "effective" participation amount for each of its neurons (as per the Matched Funding rules). This computation is based on the total direct participation amount, which is thus a field of `Committed`. - Neurons' Fund converts the "effective" amount of maturity into ICP by: - Requesting the ICP Ledger to mint an appropriate amount of ICP tokens and sending them to the SNS treasury. - Refunding whatever maturity is left over (the maximum possible maturity is reserved by the Neurons' Fund before the swap begins). - Neurons' Fund returns the Neurons' Fund participants back to the Swap canister (see SettleNeuronsFundParticipationResponse). - The Swap canister then creates SNS neurons for the Neurons' Fund participants. * If the result is Aborted, the Neurons' Fund is refunded for all maturity reserved for this SNS. This design assumes trust between the Neurons' Fund and the SNS Swap canisters. In the one hand, the Swap trusts that the Neurons' Fund sends the correct amount of ICP to the SNS treasury, and that the Neurons' Fund allocates its participants following the Matched Funding rules. On the other hand, the Neurons' Fund trusts that the Swap will indeed create appropriate SNS neurons for the Neurons' Fund participants. The justification for this trust assumption is as follows. The Neurons' Fund can be trusted as it is controlled by the NNS. The SNS Swap can be trusted as it is (1) deployed by SNS-W, which is also part of the NNS and (2) upgraded via an NNS proposal (unlike all other SNS canisters). This request may be submitted only by the Swap canister of an SNS instance created by a CreateServiceNervousSystem proposal. TODO(NNS1-1589): Until the Jira ticket gets solved, changes here need to be manually propagated to (sns) swap.proto.
optional uint64 nns_proposal_id = 1
Proposal ID of the CreateServiceNervousSystem proposal that created this SNS instance.
oneof result
Each of the possibilities here corresponds to one of two ways that a swap can terminate. See also sns_swap_pb::Lifecycle::is_terminal.
committed = 2
aborted = 3
message
governance.proto:2506When this happens, all priorly reserved maturity for this SNS instance needs to be restored to the Neurons' Fund neurons.
Used in:
(message has no fields)
message
governance.proto:2494When this happens, the NNS Governance needs to do several things: (1) Compute the effective amount of ICP per neuron of the Neurons' Fund as a function of `total_direct_participation_icp_e8s`. The overall Neurons' Fund participation should equal `total_neurons_fund_contribution_icp_e8s`. (2) Mint (via the ICP Ledger) and sent to the SNS governance the amount of `total_neurons_fund_contribution_icp_e8s`. (3) Respond to this request with `SettleNeuronsFundParticipationResponse`, providing the set of `NeuronsFundParticipant`s with the effective amount of ICP per neuron, as computed in step (1). (4) Refund each neuron of the Neurons' Fund with (reserved - effective) amount of ICP. Effective amounts depend on `total_direct_participation_icp_e8s` and the participation limits of a particular SNS instance, namely, each participation must be between `min_participant_icp_e8s` and `max_participant_icp_e8s`. - If a neuron of the Neurons' Fund has less than `min_participant_icp_e8s` worth of maturity, then it is ineligible to participate. - If a neuron of the Neurons' Fund has more than `max_participant_icp_e8s` worth of maturity, then its participation amount is limited to `max_participant_icp_e8s`. Reserved amounts are computed as the minimal upper bound on the effective amounts, i.e., when the value `total_direct_participation_icp_e8s` reaches its theoretical maximum.
Used in:
optional sns_governance_canister_id = 1
This is where the minted ICP will be sent.
optional uint64 total_direct_participation_icp_e8s = 2
Total amount of participation from direct swap participants.
optional uint64 total_neurons_fund_participation_icp_e8s = 3
Total amount of participation from the Neurons' Fund. TODO[NNS1-2570]: Ensure this field is set.
message
governance.proto:2521Handling the Neurons' Fund and transferring some of its maturity to an SNS treasury is thus the responsibility of the NNS Governance. When a swap succeeds, a Swap canister should send a `settle_neurons_fund_participation` request to the NNS Governance, specifying its `result` field as `committed`. The NNS Governance then computes the ultimate distribution of maturity in the Neurons' Fund. However, this distribution also needs to be made available to the SNS Swap that will use this information to create SNS neurons of an appropriate size for each Neurons' Fund (as well as direct) participant. That is why in the `committed` case, the NNS Governance should populate the `neurons_fund_participants` field, while in the `aborted` case it should be empty. TODO(NNS1-1589): Until the Jira ticket gets solved, changes here need to be manually propagated to (sns) swap.proto.
oneof result
err = 1
ok = 2
message
governance.proto:2523Represents one NNS neuron from the Neurons' Fund participating in this swap.
Used in:
optional uint64 nns_neuron_id = 1
The NNS neuron ID of the participating neuron.
optional uint64 amount_icp_e8s = 2
The amount of Neurons' Fund participation associated with this neuron.
optional string hotkey_principal = 3
The principal that can vote on behalf of this neuron.
optional bool is_capped = 4
Whether the amount maturity amount of Neurons' Fund participation associated with this neuron has been capped to reflect the maximum participation amount for this SNS swap.
message
governance.proto:2536Request was completed successfully.
Used in:
repeated neurons_fund_neuron_portions = 1
message
governance.proto:1542Additional information about the SNS that's being "swapped". This data is fetched from other canisters. Currently, the swap canister itself, and the root canister are queried, but additional canisters could be queried later. In particular, the ID of the root canister is discovered via the swap canister. (See Governance::fetch_swap_background_information for how this is compiled.)
Obsolete. Superseded by newer fields.
Used in:
repeated fallback_controller_principal_ids = 7
optional root_canister_summary = 8
optional governance_canister_summary = 9
optional ledger_canister_summary = 10
optional swap_canister_summary = 11
repeated ledger_archive_canister_summaries = 12
optional ledger_index_canister_summary = 13
repeated dapp_canister_summaries = 14
message
governance.proto:1584Used in:
optional CanisterStatusType status = 1
bytes module_hash = 2
repeated controllers = 3
optional uint64 memory_size = 4
optional uint64 cycles = 5
optional uint64 freezing_threshold = 6
optional uint64 idle_cycles_burned_per_day = 7
A canister can be stopped by calling stop_canister. The effect of stop_canister can be undone by calling start_canister. Stopping is an intermediate state where new method calls are rejected, but in-flight method calls are allowed to be fully serviced.
Used in:
CANISTER_STATUS_TYPE_UNSPECIFIED = 0
CANISTER_STATUS_TYPE_RUNNING = 1
CANISTER_STATUS_TYPE_STOPPING = 2
CANISTER_STATUS_TYPE_STOPPED = 3
message
governance.proto:1579Transcribed from sns/root.
Used in:
optional canister_id = 1
optional status = 2
message
governance.proto:1512Absolute constraints of this swap needed that the Neurons' Fund need to be aware of. The fields correspond to those in Swap's `Init` message.
Used in:
optional uint64 min_direct_participation_icp_e8s = 1
optional uint64 max_direct_participation_icp_e8s = 2
optional uint64 min_participant_icp_e8s = 3
optional uint64 max_participant_icp_e8s = 4
message
governance.proto:1271A tally of votes.
Used in: ,
uint64 timestamp_seconds = 1
When was this tally made
uint64 yes = 2
Yeses, in voting power unit.
uint64 no = 3
Noes, in voting power unit.
uint64 total = 4
Total voting power unit of eligible neurons. Should always be greater than or equal to yes + no.
Proposal types are organized into topics. Neurons can automatically vote based on following other neurons, and these follow relationships are defined per topic.
Used in: , ,
TOPIC_UNSPECIFIED = 0
The `Unspecified` topic is used as a fallback when following. That is, if no followees are specified for a given topic, the followees for this topic are used instead.
TOPIC_NEURON_MANAGEMENT = 1
A special topic by means of which a neuron can be managed by the followees for this topic (in this case, there is no fallback to 'unspecified'). Votes on this topic are not included in the voting history of the neuron (cf., `recent_ballots` in `Neuron`). For proposals on this topic, only followees on the 'neuron management' topic of the neuron that the proposals pertains to are allowed to vote. As the set of eligible voters on this topic is restricted, proposals on this topic have a *short voting period*.
TOPIC_EXCHANGE_RATE = 2
All proposals that provide “real time” information about the value of ICP, as measured by an IMF SDR, which allows the NNS to convert ICP to cycles (which power computation) at a rate which keeps their real world cost constant. Votes on this topic are not included in the voting history of the neuron (cf., `recent_ballots` in `Neuron`). Proposals on this topic have a *short voting period* due to their frequency.
TOPIC_NETWORK_ECONOMICS = 3
All proposals that administer network economics, for example, determining what rewards should be paid to node operators.
TOPIC_GOVERNANCE = 4
All proposals that administer governance, for example to freeze malicious canisters that are harming the network.
TOPIC_NODE_ADMIN = 5
All proposals that administer node machines, including, but not limited to, upgrading or configuring the OS, upgrading or configuring the virtual machine framework and upgrading or configuring the node replica software.
TOPIC_PARTICIPANT_MANAGEMENT = 6
All proposals that administer network participants, for example, granting and revoking DCIDs (data center identities) or NOIDs (node operator identities).
TOPIC_SUBNET_MANAGEMENT = 7
All proposals that administer network subnets, for example creating new subnets, adding and removing subnet nodes, and splitting subnets.
TOPIC_NETWORK_CANISTER_MANAGEMENT = 8
Installing and upgrading “system” canisters that belong to the network. For example, upgrading the NNS.
TOPIC_KYC = 9
Proposals that update KYC information for regulatory purposes, for example during the initial Genesis distribution of ICP in the form of neurons.
TOPIC_NODE_PROVIDER_REWARDS = 10
Topic for proposals to reward node providers.
TOPIC_IC_OS_VERSION_DEPLOYMENT = 12
IC OS upgrade proposals ----------------------- ICP runs on a distributed network of nodes grouped into subnets. Each node runs a stack of operating systems, including HostOS (runs on bare metal) and GuestOS (runs inside HostOS; contains, e.g., the ICP replica process). HostOS and GuestOS are distributed via separate disk images. The umbrella term IC OS refers to the whole stack. The IC OS upgrade process involves two phases, where the first phase is the election of a new IC OS version and the second phase is the deployment of a previously elected IC OS version on all nodes of a subnet or on some number of nodes (including nodes comprising subnets and unassigned nodes). A special case is for API boundary nodes, special nodes that route API requests to a replica of the right subnet. API boundary nodes run a different process than the replica, but their executable is distributed via the same disk image as GuestOS. Therefore, electing a new GuestOS version also results in a new version of boundary node software being elected. Proposals handling the deployment of IC OS to some nodes. It is possible to deploy only the versions of IC OS that are in the set of elected IC OS versions.
TOPIC_IC_OS_VERSION_ELECTION = 13
Proposals for changing the set of elected IC OS versions.
TOPIC_SNS_AND_COMMUNITY_FUND = 14
Proposals related to SNS and Community Fund.
TOPIC_API_BOUNDARY_NODE_MANAGEMENT = 15
Proposals related to the management of API Boundary Nodes
message
governance.proto:33Used to update node provider records There is no need to specify a node provider Principal ID here, as Governance uses the Principal ID of the caller as the Node Provider Principal ID.
optional reward_account = 1
The account where rewards earned from providing nodes will be sent.
The types of votes the Neuron can issue.
Used in: , ,
VOTE_UNSPECIFIED = 0
This exists because proto3 defaults to the 0 value on enums. This is not a valid choice, i.e., a vote with this choice will not be counted.
VOTE_YES = 1
Vote for the proposal to be adopted.
VOTE_NO = 2
Vote for the proposal to be rejected.
message
governance.proto:1614Stores data relevant to the "wait for quiet" implementation.
Used in:
uint64 current_deadline_timestamp_seconds = 1
message
governance.proto:2271Used in:
optional uint64 timestamp_seconds = 1
/ Time at which this rate has been fetched.
optional uint64 xdr_permyriad_per_icp = 2
/ One ICP is worth this number of 1/10,000ths parts of an XDR.