@dfinity/sns 4.1.2 → 5.0.0-next-2025-10-20
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/dist/candid/sns_governance.certified.idl.d.ts +1 -1
- package/dist/candid/sns_governance.certified.idl.js +1003 -1005
- package/dist/candid/sns_governance.d.ts +11 -3
- package/dist/candid/sns_governance.idl.d.ts +1 -1
- package/dist/candid/sns_governance.idl.js +1011 -1021
- package/dist/candid/sns_governance_test.certified.idl.d.ts +1 -1
- package/dist/candid/sns_governance_test.certified.idl.js +1021 -1023
- package/dist/candid/sns_governance_test.d.ts +11 -3
- package/dist/candid/sns_governance_test.idl.d.ts +1 -1
- package/dist/candid/sns_governance_test.idl.js +1029 -1039
- package/dist/candid/sns_root.certified.idl.d.ts +1 -1
- package/dist/candid/sns_root.certified.idl.js +183 -177
- package/dist/candid/sns_root.d.ts +11 -3
- package/dist/candid/sns_root.idl.d.ts +1 -1
- package/dist/candid/sns_root.idl.js +183 -177
- package/dist/candid/sns_swap.certified.idl.d.ts +1 -1
- package/dist/candid/sns_swap.certified.idl.js +359 -355
- package/dist/candid/sns_swap.d.ts +11 -3
- package/dist/candid/sns_swap.idl.d.ts +1 -1
- package/dist/candid/sns_swap.idl.js +367 -363
- package/dist/{types/converters → converters}/governance.converters.d.ts +1 -1
- package/dist/{types/converters → converters}/swap.converters.d.ts +1 -1
- package/dist/{types/errors → errors}/swap.errors.d.ts +1 -1
- package/dist/{types/governance.canister.d.ts → governance.canister.d.ts} +1 -1
- package/dist/{types/governance_test.canister.d.ts → governance_test.canister.d.ts} +1 -1
- package/dist/{types/index.d.ts → index.d.ts} +3 -3
- package/dist/index.js +7 -1
- package/dist/index.js.map +7 -0
- package/dist/index.mjs +9 -0
- package/dist/index.mjs.map +7 -0
- package/dist/{types/root.canister.d.ts → root.canister.d.ts} +1 -1
- package/dist/{types/sns.d.ts → sns.d.ts} +2 -2
- package/dist/{types/sns.wrapper.d.ts → sns.wrapper.d.ts} +3 -3
- package/dist/{types/swap.canister.d.ts → swap.canister.d.ts} +1 -1
- package/dist/types/{types/actions.d.ts → actions.d.ts} +2 -2
- package/dist/types/{types/canister.options.d.ts → canister.options.d.ts} +1 -1
- package/dist/types/{types/governance.params.d.ts → governance.params.d.ts} +2 -2
- package/dist/types/{types/governance_test.params.d.ts → governance_test.params.d.ts} +1 -1
- package/dist/{types/utils → utils}/governance.utils.d.ts +1 -1
- package/package.json +23 -12
- package/dist/cjs/index.cjs.js +0 -7
- package/dist/cjs/index.cjs.js.map +0 -7
- package/dist/esm/chunk-4E6G4JED.js +0 -2
- package/dist/esm/chunk-4E6G4JED.js.map +0 -7
- package/dist/esm/chunk-4INNMFYU.js +0 -2
- package/dist/esm/chunk-4INNMFYU.js.map +0 -7
- package/dist/esm/chunk-4OISOQSJ.js +0 -2
- package/dist/esm/chunk-4OISOQSJ.js.map +0 -7
- package/dist/esm/chunk-BJBCLIED.js +0 -2
- package/dist/esm/chunk-BJBCLIED.js.map +0 -7
- package/dist/esm/chunk-EYIWJ4DL.js +0 -2
- package/dist/esm/chunk-EYIWJ4DL.js.map +0 -7
- package/dist/esm/chunk-Y6XGADSI.js +0 -7
- package/dist/esm/chunk-Y6XGADSI.js.map +0 -7
- package/dist/esm/governance.canister.js +0 -2
- package/dist/esm/governance.canister.js.map +0 -7
- package/dist/esm/index.js +0 -2
- package/dist/esm/index.js.map +0 -7
- package/dist/esm/root.canister.js +0 -2
- package/dist/esm/root.canister.js.map +0 -7
- package/dist/esm/sns.js +0 -2
- package/dist/esm/sns.js.map +0 -7
- package/dist/esm/sns.wrapper.js +0 -2
- package/dist/esm/sns.wrapper.js.map +0 -7
- package/dist/esm/swap.canister.js +0 -2
- package/dist/esm/swap.canister.js.map +0 -7
- package/dist/index.cjs.js +0 -1
- /package/dist/{types/constants → constants}/governance.constants.d.ts +0 -0
- /package/dist/{types/enums → enums}/governance.enums.d.ts +0 -0
- /package/dist/{types/enums → enums}/swap.enums.d.ts +0 -0
- /package/dist/{types/errors → errors}/common.errors.d.ts +0 -0
- /package/dist/{types/errors → errors}/governance.errors.d.ts +0 -0
- /package/dist/types/{types/common.d.ts → common.d.ts} +0 -0
- /package/dist/types/{types/swap.params.d.ts → swap.params.d.ts} +0 -0
- /package/dist/{types/utils → utils}/error.utils.d.ts +0 -0
|
@@ -1,1478 +1,1468 @@
|
|
|
1
|
-
/*
|
|
1
|
+
/* eslint-disable */
|
|
2
|
+
|
|
3
|
+
// @ts-nocheck
|
|
4
|
+
|
|
5
|
+
// This file was automatically generated by @icp-sdk/bindgen@0.2.0-patch-typed-arrays.
|
|
6
|
+
// You should NOT make any changes in this file as it will be overwritten.
|
|
7
|
+
// Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.
|
|
8
|
+
|
|
2
9
|
export const idlFactory = ({ IDL }) => {
|
|
3
10
|
const PreciseValue = IDL.Rec();
|
|
4
11
|
const Timers = IDL.Record({
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
12
|
+
last_spawned_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
13
|
+
last_reset_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
14
|
+
requires_periodic_tasks: IDL.Opt(IDL.Bool),
|
|
8
15
|
});
|
|
9
16
|
const Version = IDL.Record({
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
});
|
|
17
|
-
const Versions = IDL.Record({
|
|
17
|
+
archive_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
18
|
+
root_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
19
|
+
swap_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
20
|
+
ledger_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
21
|
+
governance_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
22
|
+
index_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
23
|
+
});
|
|
24
|
+
const Versions = IDL.Record({ versions: IDL.Vec(Version) });
|
|
18
25
|
const CachedUpgradeSteps = IDL.Record({
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
26
|
+
upgrade_steps: IDL.Opt(Versions),
|
|
27
|
+
response_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
28
|
+
requested_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
22
29
|
});
|
|
23
30
|
const Topic = IDL.Variant({
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
+
DappCanisterManagement: IDL.Null,
|
|
32
|
+
DaoCommunitySettings: IDL.Null,
|
|
33
|
+
ApplicationBusinessLogic: IDL.Null,
|
|
34
|
+
CriticalDappOperations: IDL.Null,
|
|
35
|
+
TreasuryAssetManagement: IDL.Null,
|
|
36
|
+
Governance: IDL.Null,
|
|
37
|
+
SnsFrameworkManagement: IDL.Null,
|
|
31
38
|
});
|
|
32
39
|
const GenericNervousSystemFunction = IDL.Record({
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
40
|
+
topic: IDL.Opt(Topic),
|
|
41
|
+
validator_canister_id: IDL.Opt(IDL.Principal),
|
|
42
|
+
target_canister_id: IDL.Opt(IDL.Principal),
|
|
43
|
+
validator_method_name: IDL.Opt(IDL.Text),
|
|
44
|
+
target_method_name: IDL.Opt(IDL.Text),
|
|
38
45
|
});
|
|
39
46
|
const FunctionType = IDL.Variant({
|
|
40
|
-
|
|
41
|
-
|
|
47
|
+
NativeNervousSystemFunction: IDL.Record({}),
|
|
48
|
+
GenericNervousSystemFunction: GenericNervousSystemFunction,
|
|
42
49
|
});
|
|
43
50
|
const NervousSystemFunction = IDL.Record({
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
51
|
+
id: IDL.Nat64,
|
|
52
|
+
name: IDL.Text,
|
|
53
|
+
description: IDL.Opt(IDL.Text),
|
|
54
|
+
function_type: IDL.Opt(FunctionType),
|
|
48
55
|
});
|
|
49
|
-
const Subaccount = IDL.Record({
|
|
56
|
+
const Subaccount = IDL.Record({ subaccount: IDL.Vec(IDL.Nat8) });
|
|
50
57
|
const Account = IDL.Record({
|
|
51
|
-
|
|
52
|
-
|
|
58
|
+
owner: IDL.Opt(IDL.Principal),
|
|
59
|
+
subaccount: IDL.Opt(Subaccount),
|
|
53
60
|
});
|
|
54
61
|
const TreasuryMetrics = IDL.Record({
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
+
name: IDL.Opt(IDL.Text),
|
|
63
|
+
original_amount_e8s: IDL.Opt(IDL.Nat64),
|
|
64
|
+
amount_e8s: IDL.Opt(IDL.Nat64),
|
|
65
|
+
account: IDL.Opt(Account),
|
|
66
|
+
ledger_canister_id: IDL.Opt(IDL.Principal),
|
|
67
|
+
treasury: IDL.Int32,
|
|
68
|
+
timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
62
69
|
});
|
|
63
70
|
const VotingPowerMetrics = IDL.Record({
|
|
64
|
-
|
|
65
|
-
|
|
71
|
+
governance_total_potential_voting_power: IDL.Opt(IDL.Nat64),
|
|
72
|
+
timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
66
73
|
});
|
|
67
74
|
const GovernanceCachedMetrics = IDL.Record({
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
IDL.Tuple(IDL.Nat64, IDL.Float64)
|
|
75
|
+
treasury_metrics: IDL.Vec(TreasuryMetrics),
|
|
76
|
+
not_dissolving_neurons_e8s_buckets: IDL.Vec(
|
|
77
|
+
IDL.Tuple(IDL.Nat64, IDL.Float64),
|
|
71
78
|
),
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
IDL.Tuple(IDL.Nat64, IDL.Nat64)
|
|
79
|
+
garbage_collectable_neurons_count: IDL.Nat64,
|
|
80
|
+
neurons_with_invalid_stake_count: IDL.Nat64,
|
|
81
|
+
not_dissolving_neurons_count_buckets: IDL.Vec(
|
|
82
|
+
IDL.Tuple(IDL.Nat64, IDL.Nat64),
|
|
76
83
|
),
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
),
|
|
88
|
-
|
|
89
|
-
'dissolving_neurons_e8s_buckets' : IDL.Vec(
|
|
90
|
-
IDL.Tuple(IDL.Nat64, IDL.Float64)
|
|
91
|
-
),
|
|
92
|
-
'timestamp_seconds' : IDL.Nat64,
|
|
84
|
+
neurons_with_less_than_6_months_dissolve_delay_count: IDL.Nat64,
|
|
85
|
+
dissolved_neurons_count: IDL.Nat64,
|
|
86
|
+
total_staked_e8s: IDL.Nat64,
|
|
87
|
+
total_supply_governance_tokens: IDL.Nat64,
|
|
88
|
+
voting_power_metrics: IDL.Opt(VotingPowerMetrics),
|
|
89
|
+
not_dissolving_neurons_count: IDL.Nat64,
|
|
90
|
+
dissolved_neurons_e8s: IDL.Nat64,
|
|
91
|
+
neurons_with_less_than_6_months_dissolve_delay_e8s: IDL.Nat64,
|
|
92
|
+
dissolving_neurons_count_buckets: IDL.Vec(IDL.Tuple(IDL.Nat64, IDL.Nat64)),
|
|
93
|
+
dissolving_neurons_count: IDL.Nat64,
|
|
94
|
+
dissolving_neurons_e8s_buckets: IDL.Vec(IDL.Tuple(IDL.Nat64, IDL.Float64)),
|
|
95
|
+
timestamp_seconds: IDL.Nat64,
|
|
93
96
|
});
|
|
94
97
|
const MaturityModulation = IDL.Record({
|
|
95
|
-
|
|
96
|
-
|
|
98
|
+
current_basis_points: IDL.Opt(IDL.Int32),
|
|
99
|
+
updated_at_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
97
100
|
});
|
|
98
101
|
const TargetVersionSet = IDL.Record({
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
+
old_target_version: IDL.Opt(Version),
|
|
103
|
+
new_target_version: IDL.Opt(Version),
|
|
104
|
+
is_advanced_automatically: IDL.Opt(IDL.Bool),
|
|
102
105
|
});
|
|
103
106
|
const UpgradeStepsReset = IDL.Record({
|
|
104
|
-
|
|
105
|
-
|
|
107
|
+
human_readable: IDL.Opt(IDL.Text),
|
|
108
|
+
upgrade_steps: IDL.Opt(Versions),
|
|
106
109
|
});
|
|
107
110
|
const UpgradeOutcome = IDL.Record({
|
|
108
|
-
|
|
111
|
+
status: IDL.Opt(
|
|
109
112
|
IDL.Variant({
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
})
|
|
113
|
+
Success: IDL.Record({}),
|
|
114
|
+
Timeout: IDL.Record({}),
|
|
115
|
+
ExternalFailure: IDL.Record({}),
|
|
116
|
+
InvalidState: IDL.Record({ version: IDL.Opt(Version) }),
|
|
117
|
+
}),
|
|
115
118
|
),
|
|
116
|
-
|
|
119
|
+
human_readable: IDL.Opt(IDL.Text),
|
|
117
120
|
});
|
|
118
|
-
const ProposalId = IDL.Record({
|
|
121
|
+
const ProposalId = IDL.Record({ id: IDL.Nat64 });
|
|
119
122
|
const UpgradeStarted = IDL.Record({
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
+
current_version: IDL.Opt(Version),
|
|
124
|
+
expected_version: IDL.Opt(Version),
|
|
125
|
+
reason: IDL.Opt(
|
|
123
126
|
IDL.Variant({
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
})
|
|
127
|
+
UpgradeSnsToNextVersionProposal: ProposalId,
|
|
128
|
+
BehindTargetVersion: IDL.Record({}),
|
|
129
|
+
}),
|
|
127
130
|
),
|
|
128
131
|
});
|
|
129
132
|
const UpgradeStepsRefreshed = IDL.Record({
|
|
130
|
-
|
|
133
|
+
upgrade_steps: IDL.Opt(Versions),
|
|
131
134
|
});
|
|
132
135
|
const TargetVersionReset = IDL.Record({
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
+
human_readable: IDL.Opt(IDL.Text),
|
|
137
|
+
old_target_version: IDL.Opt(Version),
|
|
138
|
+
new_target_version: IDL.Opt(Version),
|
|
136
139
|
});
|
|
137
140
|
const UpgradeJournalEntry = IDL.Record({
|
|
138
|
-
|
|
141
|
+
event: IDL.Opt(
|
|
139
142
|
IDL.Variant({
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
})
|
|
143
|
+
TargetVersionSet: TargetVersionSet,
|
|
144
|
+
UpgradeStepsReset: UpgradeStepsReset,
|
|
145
|
+
UpgradeOutcome: UpgradeOutcome,
|
|
146
|
+
UpgradeStarted: UpgradeStarted,
|
|
147
|
+
UpgradeStepsRefreshed: UpgradeStepsRefreshed,
|
|
148
|
+
TargetVersionReset: TargetVersionReset,
|
|
149
|
+
}),
|
|
147
150
|
),
|
|
148
|
-
|
|
151
|
+
timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
149
152
|
});
|
|
150
153
|
const UpgradeJournal = IDL.Record({
|
|
151
|
-
|
|
154
|
+
entries: IDL.Vec(UpgradeJournalEntry),
|
|
152
155
|
});
|
|
153
|
-
const NeuronId = IDL.Record({
|
|
154
|
-
const Followees = IDL.Record({
|
|
156
|
+
const NeuronId = IDL.Record({ id: IDL.Vec(IDL.Nat8) });
|
|
157
|
+
const Followees = IDL.Record({ followees: IDL.Vec(NeuronId) });
|
|
155
158
|
const DefaultFollowees = IDL.Record({
|
|
156
|
-
|
|
159
|
+
followees: IDL.Vec(IDL.Tuple(IDL.Nat64, Followees)),
|
|
157
160
|
});
|
|
158
161
|
const NeuronPermissionList = IDL.Record({
|
|
159
|
-
|
|
162
|
+
permissions: IDL.Vec(IDL.Int32),
|
|
160
163
|
});
|
|
161
164
|
const VotingRewardsParameters = IDL.Record({
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
165
|
+
final_reward_rate_basis_points: IDL.Opt(IDL.Nat64),
|
|
166
|
+
initial_reward_rate_basis_points: IDL.Opt(IDL.Nat64),
|
|
167
|
+
reward_rate_transition_duration_seconds: IDL.Opt(IDL.Nat64),
|
|
168
|
+
round_duration_seconds: IDL.Opt(IDL.Nat64),
|
|
166
169
|
});
|
|
167
170
|
const NervousSystemParameters = IDL.Record({
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
171
|
+
default_followees: IDL.Opt(DefaultFollowees),
|
|
172
|
+
max_dissolve_delay_seconds: IDL.Opt(IDL.Nat64),
|
|
173
|
+
max_dissolve_delay_bonus_percentage: IDL.Opt(IDL.Nat64),
|
|
174
|
+
max_followees_per_function: IDL.Opt(IDL.Nat64),
|
|
175
|
+
automatically_advance_target_version: IDL.Opt(IDL.Bool),
|
|
176
|
+
neuron_claimer_permissions: IDL.Opt(NeuronPermissionList),
|
|
177
|
+
neuron_minimum_stake_e8s: IDL.Opt(IDL.Nat64),
|
|
178
|
+
max_neuron_age_for_age_bonus: IDL.Opt(IDL.Nat64),
|
|
179
|
+
initial_voting_period_seconds: IDL.Opt(IDL.Nat64),
|
|
180
|
+
neuron_minimum_dissolve_delay_to_vote_seconds: IDL.Opt(IDL.Nat64),
|
|
181
|
+
reject_cost_e8s: IDL.Opt(IDL.Nat64),
|
|
182
|
+
max_proposals_to_keep_per_action: IDL.Opt(IDL.Nat32),
|
|
183
|
+
wait_for_quiet_deadline_increase_seconds: IDL.Opt(IDL.Nat64),
|
|
184
|
+
max_number_of_neurons: IDL.Opt(IDL.Nat64),
|
|
185
|
+
transaction_fee_e8s: IDL.Opt(IDL.Nat64),
|
|
186
|
+
max_number_of_proposals_with_ballots: IDL.Opt(IDL.Nat64),
|
|
187
|
+
max_age_bonus_percentage: IDL.Opt(IDL.Nat64),
|
|
188
|
+
neuron_grantable_permissions: IDL.Opt(NeuronPermissionList),
|
|
189
|
+
voting_rewards_parameters: IDL.Opt(VotingRewardsParameters),
|
|
190
|
+
maturity_modulation_disabled: IDL.Opt(IDL.Bool),
|
|
191
|
+
max_number_of_principals_per_neuron: IDL.Opt(IDL.Nat64),
|
|
189
192
|
});
|
|
190
193
|
const RewardEvent = IDL.Record({
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
194
|
+
rounds_since_last_distribution: IDL.Opt(IDL.Nat64),
|
|
195
|
+
actual_timestamp_seconds: IDL.Nat64,
|
|
196
|
+
end_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
197
|
+
total_available_e8s_equivalent: IDL.Opt(IDL.Nat64),
|
|
198
|
+
distributed_e8s_equivalent: IDL.Nat64,
|
|
199
|
+
round: IDL.Nat64,
|
|
200
|
+
settled_proposals: IDL.Vec(ProposalId),
|
|
198
201
|
});
|
|
199
202
|
const PendingVersion = IDL.Record({
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
203
|
+
mark_failed_at_seconds: IDL.Nat64,
|
|
204
|
+
checking_upgrade_lock: IDL.Nat64,
|
|
205
|
+
proposal_id: IDL.Opt(IDL.Nat64),
|
|
206
|
+
target_version: IDL.Opt(Version),
|
|
204
207
|
});
|
|
205
208
|
const GovernanceError = IDL.Record({
|
|
206
|
-
|
|
207
|
-
|
|
209
|
+
error_message: IDL.Text,
|
|
210
|
+
error_type: IDL.Int32,
|
|
208
211
|
});
|
|
209
|
-
const Decimal = IDL.Record({
|
|
210
|
-
const Tokens = IDL.Record({
|
|
212
|
+
const Decimal = IDL.Record({ human_readable: IDL.Opt(IDL.Text) });
|
|
213
|
+
const Tokens = IDL.Record({ e8s: IDL.Opt(IDL.Nat64) });
|
|
211
214
|
const ValuationFactors = IDL.Record({
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
+
xdrs_per_icp: IDL.Opt(Decimal),
|
|
216
|
+
icps_per_token: IDL.Opt(Decimal),
|
|
217
|
+
tokens: IDL.Opt(Tokens),
|
|
215
218
|
});
|
|
216
219
|
const Valuation = IDL.Record({
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
220
|
+
token: IDL.Opt(IDL.Int32),
|
|
221
|
+
account: IDL.Opt(Account),
|
|
222
|
+
valuation_factors: IDL.Opt(ValuationFactors),
|
|
223
|
+
timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
221
224
|
});
|
|
222
225
|
const MintSnsTokensActionAuxiliary = IDL.Record({
|
|
223
|
-
|
|
226
|
+
valuation: IDL.Opt(Valuation),
|
|
224
227
|
});
|
|
225
228
|
const SnsVersion = IDL.Record({
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
229
|
+
archive_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
230
|
+
root_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
231
|
+
swap_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
232
|
+
ledger_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
233
|
+
governance_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
234
|
+
index_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
232
235
|
});
|
|
233
236
|
const AdvanceSnsTargetVersionActionAuxiliary = IDL.Record({
|
|
234
|
-
|
|
237
|
+
target_version: IDL.Opt(SnsVersion),
|
|
235
238
|
});
|
|
236
239
|
const ActionAuxiliary = IDL.Variant({
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
+
TransferSnsTreasuryFunds: MintSnsTokensActionAuxiliary,
|
|
241
|
+
MintSnsTokens: MintSnsTokensActionAuxiliary,
|
|
242
|
+
AdvanceSnsTargetVersion: AdvanceSnsTargetVersionActionAuxiliary,
|
|
240
243
|
});
|
|
241
244
|
const Ballot = IDL.Record({
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
+
vote: IDL.Int32,
|
|
246
|
+
cast_timestamp_seconds: IDL.Nat64,
|
|
247
|
+
voting_power: IDL.Nat64,
|
|
245
248
|
});
|
|
246
|
-
const Percentage = IDL.Record({
|
|
249
|
+
const Percentage = IDL.Record({ basis_points: IDL.Opt(IDL.Nat64) });
|
|
247
250
|
const Tally = IDL.Record({
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
251
|
+
no: IDL.Nat64,
|
|
252
|
+
yes: IDL.Nat64,
|
|
253
|
+
total: IDL.Nat64,
|
|
254
|
+
timestamp_seconds: IDL.Nat64,
|
|
252
255
|
});
|
|
253
256
|
const ManageDappCanisterSettings = IDL.Record({
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
257
|
+
freezing_threshold: IDL.Opt(IDL.Nat64),
|
|
258
|
+
wasm_memory_threshold: IDL.Opt(IDL.Nat64),
|
|
259
|
+
canister_ids: IDL.Vec(IDL.Principal),
|
|
260
|
+
reserved_cycles_limit: IDL.Opt(IDL.Nat64),
|
|
261
|
+
log_visibility: IDL.Opt(IDL.Int32),
|
|
262
|
+
wasm_memory_limit: IDL.Opt(IDL.Nat64),
|
|
263
|
+
memory_allocation: IDL.Opt(IDL.Nat64),
|
|
264
|
+
compute_allocation: IDL.Opt(IDL.Nat64),
|
|
262
265
|
});
|
|
263
266
|
PreciseValue.fill(
|
|
264
267
|
IDL.Variant({
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
})
|
|
268
|
+
Int: IDL.Int64,
|
|
269
|
+
Map: IDL.Vec(IDL.Tuple(IDL.Text, PreciseValue)),
|
|
270
|
+
Nat: IDL.Nat64,
|
|
271
|
+
Blob: IDL.Vec(IDL.Nat8),
|
|
272
|
+
Bool: IDL.Bool,
|
|
273
|
+
Text: IDL.Text,
|
|
274
|
+
Array: IDL.Vec(PreciseValue),
|
|
275
|
+
}),
|
|
273
276
|
);
|
|
274
|
-
const ExtensionOperationArg = IDL.Record({
|
|
277
|
+
const ExtensionOperationArg = IDL.Record({ value: IDL.Opt(PreciseValue) });
|
|
275
278
|
const ExecuteExtensionOperation = IDL.Record({
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
+
extension_canister_id: IDL.Opt(IDL.Principal),
|
|
280
|
+
operation_name: IDL.Opt(IDL.Text),
|
|
281
|
+
operation_arg: IDL.Opt(ExtensionOperationArg),
|
|
279
282
|
});
|
|
280
283
|
const ChunkedCanisterWasm = IDL.Record({
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
+
wasm_module_hash: IDL.Vec(IDL.Nat8),
|
|
285
|
+
chunk_hashes_list: IDL.Vec(IDL.Vec(IDL.Nat8)),
|
|
286
|
+
store_canister_id: IDL.Opt(IDL.Principal),
|
|
284
287
|
});
|
|
285
288
|
const Wasm = IDL.Variant({
|
|
286
|
-
|
|
287
|
-
|
|
289
|
+
Chunked: ChunkedCanisterWasm,
|
|
290
|
+
Bytes: IDL.Vec(IDL.Nat8),
|
|
288
291
|
});
|
|
289
|
-
const ExtensionUpgradeArg = IDL.Record({
|
|
292
|
+
const ExtensionUpgradeArg = IDL.Record({ value: IDL.Opt(PreciseValue) });
|
|
290
293
|
const UpgradeExtension = IDL.Record({
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
+
extension_canister_id: IDL.Opt(IDL.Principal),
|
|
295
|
+
wasm: IDL.Opt(Wasm),
|
|
296
|
+
canister_upgrade_arg: IDL.Opt(ExtensionUpgradeArg),
|
|
294
297
|
});
|
|
295
298
|
const SetTopicsForCustomProposals = IDL.Record({
|
|
296
|
-
|
|
299
|
+
custom_function_id_to_topic: IDL.Vec(IDL.Tuple(IDL.Nat64, Topic)),
|
|
297
300
|
});
|
|
298
|
-
const ExtensionInit = IDL.Record({
|
|
301
|
+
const ExtensionInit = IDL.Record({ value: IDL.Opt(PreciseValue) });
|
|
299
302
|
const RegisterExtension = IDL.Record({
|
|
300
|
-
|
|
301
|
-
|
|
303
|
+
chunked_canister_wasm: IDL.Opt(ChunkedCanisterWasm),
|
|
304
|
+
extension_init: IDL.Opt(ExtensionInit),
|
|
302
305
|
});
|
|
303
306
|
const RegisterDappCanisters = IDL.Record({
|
|
304
|
-
|
|
307
|
+
canister_ids: IDL.Vec(IDL.Principal),
|
|
305
308
|
});
|
|
306
309
|
const TransferSnsTreasuryFunds = IDL.Record({
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
310
|
+
from_treasury: IDL.Int32,
|
|
311
|
+
to_principal: IDL.Opt(IDL.Principal),
|
|
312
|
+
to_subaccount: IDL.Opt(Subaccount),
|
|
313
|
+
memo: IDL.Opt(IDL.Nat64),
|
|
314
|
+
amount_e8s: IDL.Nat64,
|
|
312
315
|
});
|
|
313
316
|
const UpgradeSnsControlledCanister = IDL.Record({
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
317
|
+
new_canister_wasm: IDL.Vec(IDL.Nat8),
|
|
318
|
+
mode: IDL.Opt(IDL.Int32),
|
|
319
|
+
canister_id: IDL.Opt(IDL.Principal),
|
|
320
|
+
chunked_canister_wasm: IDL.Opt(ChunkedCanisterWasm),
|
|
321
|
+
canister_upgrade_arg: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
319
322
|
});
|
|
320
323
|
const DeregisterDappCanisters = IDL.Record({
|
|
321
|
-
|
|
322
|
-
|
|
324
|
+
canister_ids: IDL.Vec(IDL.Principal),
|
|
325
|
+
new_controllers: IDL.Vec(IDL.Principal),
|
|
323
326
|
});
|
|
324
327
|
const MintSnsTokens = IDL.Record({
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
328
|
+
to_principal: IDL.Opt(IDL.Principal),
|
|
329
|
+
to_subaccount: IDL.Opt(Subaccount),
|
|
330
|
+
memo: IDL.Opt(IDL.Nat64),
|
|
331
|
+
amount_e8s: IDL.Opt(IDL.Nat64),
|
|
329
332
|
});
|
|
330
333
|
const AdvanceSnsTargetVersion = IDL.Record({
|
|
331
|
-
|
|
334
|
+
new_target: IDL.Opt(SnsVersion),
|
|
332
335
|
});
|
|
333
336
|
const ManageSnsMetadata = IDL.Record({
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
337
|
+
url: IDL.Opt(IDL.Text),
|
|
338
|
+
logo: IDL.Opt(IDL.Text),
|
|
339
|
+
name: IDL.Opt(IDL.Text),
|
|
340
|
+
description: IDL.Opt(IDL.Text),
|
|
338
341
|
});
|
|
339
342
|
const ExecuteGenericNervousSystemFunction = IDL.Record({
|
|
340
|
-
|
|
341
|
-
|
|
343
|
+
function_id: IDL.Nat64,
|
|
344
|
+
payload: IDL.Vec(IDL.Nat8),
|
|
342
345
|
});
|
|
343
346
|
const ManageLedgerParameters = IDL.Record({
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
347
|
+
token_symbol: IDL.Opt(IDL.Text),
|
|
348
|
+
transfer_fee: IDL.Opt(IDL.Nat64),
|
|
349
|
+
token_logo: IDL.Opt(IDL.Text),
|
|
350
|
+
token_name: IDL.Opt(IDL.Text),
|
|
348
351
|
});
|
|
349
|
-
const Motion = IDL.Record({
|
|
352
|
+
const Motion = IDL.Record({ motion_text: IDL.Text });
|
|
350
353
|
const Action = IDL.Variant({
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
354
|
+
ManageNervousSystemParameters: NervousSystemParameters,
|
|
355
|
+
AddGenericNervousSystemFunction: NervousSystemFunction,
|
|
356
|
+
ManageDappCanisterSettings: ManageDappCanisterSettings,
|
|
357
|
+
ExecuteExtensionOperation: ExecuteExtensionOperation,
|
|
358
|
+
UpgradeExtension: UpgradeExtension,
|
|
359
|
+
RemoveGenericNervousSystemFunction: IDL.Nat64,
|
|
360
|
+
SetTopicsForCustomProposals: SetTopicsForCustomProposals,
|
|
361
|
+
RegisterExtension: RegisterExtension,
|
|
362
|
+
UpgradeSnsToNextVersion: IDL.Record({}),
|
|
363
|
+
RegisterDappCanisters: RegisterDappCanisters,
|
|
364
|
+
TransferSnsTreasuryFunds: TransferSnsTreasuryFunds,
|
|
365
|
+
UpgradeSnsControlledCanister: UpgradeSnsControlledCanister,
|
|
366
|
+
DeregisterDappCanisters: DeregisterDappCanisters,
|
|
367
|
+
MintSnsTokens: MintSnsTokens,
|
|
368
|
+
AdvanceSnsTargetVersion: AdvanceSnsTargetVersion,
|
|
369
|
+
Unspecified: IDL.Record({}),
|
|
370
|
+
ManageSnsMetadata: ManageSnsMetadata,
|
|
371
|
+
ExecuteGenericNervousSystemFunction: ExecuteGenericNervousSystemFunction,
|
|
372
|
+
ManageLedgerParameters: ManageLedgerParameters,
|
|
373
|
+
Motion: Motion,
|
|
371
374
|
});
|
|
372
375
|
const Proposal = IDL.Record({
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
376
|
+
url: IDL.Text,
|
|
377
|
+
title: IDL.Text,
|
|
378
|
+
action: IDL.Opt(Action),
|
|
379
|
+
summary: IDL.Text,
|
|
377
380
|
});
|
|
378
381
|
const WaitForQuietState = IDL.Record({
|
|
379
|
-
|
|
382
|
+
current_deadline_timestamp_seconds: IDL.Nat64,
|
|
380
383
|
});
|
|
381
384
|
const ProposalData = IDL.Record({
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
});
|
|
406
|
-
const Split = IDL.Record({
|
|
385
|
+
id: IDL.Opt(ProposalId),
|
|
386
|
+
payload_text_rendering: IDL.Opt(IDL.Text),
|
|
387
|
+
topic: IDL.Opt(Topic),
|
|
388
|
+
action: IDL.Nat64,
|
|
389
|
+
failure_reason: IDL.Opt(GovernanceError),
|
|
390
|
+
action_auxiliary: IDL.Opt(ActionAuxiliary),
|
|
391
|
+
ballots: IDL.Vec(IDL.Tuple(IDL.Text, Ballot)),
|
|
392
|
+
minimum_yes_proportion_of_total: IDL.Opt(Percentage),
|
|
393
|
+
reward_event_round: IDL.Nat64,
|
|
394
|
+
failed_timestamp_seconds: IDL.Nat64,
|
|
395
|
+
reward_event_end_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
396
|
+
proposal_creation_timestamp_seconds: IDL.Nat64,
|
|
397
|
+
initial_voting_period_seconds: IDL.Nat64,
|
|
398
|
+
reject_cost_e8s: IDL.Nat64,
|
|
399
|
+
latest_tally: IDL.Opt(Tally),
|
|
400
|
+
wait_for_quiet_deadline_increase_seconds: IDL.Nat64,
|
|
401
|
+
decided_timestamp_seconds: IDL.Nat64,
|
|
402
|
+
proposal: IDL.Opt(Proposal),
|
|
403
|
+
proposer: IDL.Opt(NeuronId),
|
|
404
|
+
wait_for_quiet_state: IDL.Opt(WaitForQuietState),
|
|
405
|
+
minimum_yes_proportion_of_exercised: IDL.Opt(Percentage),
|
|
406
|
+
is_eligible_for_rewards: IDL.Bool,
|
|
407
|
+
executed_timestamp_seconds: IDL.Nat64,
|
|
408
|
+
});
|
|
409
|
+
const Split = IDL.Record({ memo: IDL.Nat64, amount_e8s: IDL.Nat64 });
|
|
407
410
|
const Follow = IDL.Record({
|
|
408
|
-
|
|
409
|
-
|
|
411
|
+
function_id: IDL.Nat64,
|
|
412
|
+
followees: IDL.Vec(NeuronId),
|
|
410
413
|
});
|
|
411
414
|
const DisburseMaturity = IDL.Record({
|
|
412
|
-
|
|
413
|
-
|
|
415
|
+
to_account: IDL.Opt(Account),
|
|
416
|
+
percentage_to_disburse: IDL.Nat32,
|
|
414
417
|
});
|
|
415
418
|
const ChangeAutoStakeMaturity = IDL.Record({
|
|
416
|
-
|
|
419
|
+
requested_setting_for_auto_stake_maturity: IDL.Bool,
|
|
417
420
|
});
|
|
418
421
|
const IncreaseDissolveDelay = IDL.Record({
|
|
419
|
-
|
|
422
|
+
additional_dissolve_delay_seconds: IDL.Nat32,
|
|
420
423
|
});
|
|
421
424
|
const SetDissolveTimestamp = IDL.Record({
|
|
422
|
-
|
|
425
|
+
dissolve_timestamp_seconds: IDL.Nat64,
|
|
423
426
|
});
|
|
424
427
|
const Operation = IDL.Variant({
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
428
|
+
ChangeAutoStakeMaturity: ChangeAutoStakeMaturity,
|
|
429
|
+
StopDissolving: IDL.Record({}),
|
|
430
|
+
StartDissolving: IDL.Record({}),
|
|
431
|
+
IncreaseDissolveDelay: IncreaseDissolveDelay,
|
|
432
|
+
SetDissolveTimestamp: SetDissolveTimestamp,
|
|
430
433
|
});
|
|
431
|
-
const Configure = IDL.Record({
|
|
434
|
+
const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
|
|
432
435
|
const RegisterVote = IDL.Record({
|
|
433
|
-
|
|
434
|
-
|
|
436
|
+
vote: IDL.Int32,
|
|
437
|
+
proposal: IDL.Opt(ProposalId),
|
|
435
438
|
});
|
|
436
439
|
const Followee = IDL.Record({
|
|
437
|
-
|
|
438
|
-
|
|
440
|
+
alias: IDL.Opt(IDL.Text),
|
|
441
|
+
neuron_id: IDL.Opt(NeuronId),
|
|
439
442
|
});
|
|
440
443
|
const FolloweesForTopic = IDL.Record({
|
|
441
|
-
|
|
442
|
-
|
|
444
|
+
topic: IDL.Opt(Topic),
|
|
445
|
+
followees: IDL.Vec(Followee),
|
|
443
446
|
});
|
|
444
447
|
const SetFollowing = IDL.Record({
|
|
445
|
-
|
|
448
|
+
topic_following: IDL.Vec(FolloweesForTopic),
|
|
446
449
|
});
|
|
447
450
|
const FinalizeDisburseMaturity = IDL.Record({
|
|
448
|
-
|
|
449
|
-
|
|
451
|
+
amount_to_be_disbursed_e8s: IDL.Nat64,
|
|
452
|
+
to_account: IDL.Opt(Account),
|
|
450
453
|
});
|
|
451
454
|
const MemoAndController = IDL.Record({
|
|
452
|
-
|
|
453
|
-
|
|
455
|
+
controller: IDL.Opt(IDL.Principal),
|
|
456
|
+
memo: IDL.Nat64,
|
|
454
457
|
});
|
|
455
458
|
const By = IDL.Variant({
|
|
456
|
-
|
|
457
|
-
|
|
459
|
+
MemoAndController: MemoAndController,
|
|
460
|
+
NeuronId: IDL.Record({}),
|
|
458
461
|
});
|
|
459
|
-
const ClaimOrRefresh = IDL.Record({
|
|
462
|
+
const ClaimOrRefresh = IDL.Record({ by: IDL.Opt(By) });
|
|
460
463
|
const RemoveNeuronPermissions = IDL.Record({
|
|
461
|
-
|
|
462
|
-
|
|
464
|
+
permissions_to_remove: IDL.Opt(NeuronPermissionList),
|
|
465
|
+
principal_id: IDL.Opt(IDL.Principal),
|
|
463
466
|
});
|
|
464
467
|
const AddNeuronPermissions = IDL.Record({
|
|
465
|
-
|
|
466
|
-
|
|
468
|
+
permissions_to_add: IDL.Opt(NeuronPermissionList),
|
|
469
|
+
principal_id: IDL.Opt(IDL.Principal),
|
|
467
470
|
});
|
|
468
|
-
const MergeMaturity = IDL.Record({
|
|
469
|
-
const Amount = IDL.Record({
|
|
471
|
+
const MergeMaturity = IDL.Record({ percentage_to_merge: IDL.Nat32 });
|
|
472
|
+
const Amount = IDL.Record({ e8s: IDL.Nat64 });
|
|
470
473
|
const Disburse = IDL.Record({
|
|
471
|
-
|
|
472
|
-
|
|
474
|
+
to_account: IDL.Opt(Account),
|
|
475
|
+
amount: IDL.Opt(Amount),
|
|
473
476
|
});
|
|
474
477
|
const Command_2 = IDL.Variant({
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
478
|
+
Split: Split,
|
|
479
|
+
Follow: Follow,
|
|
480
|
+
DisburseMaturity: DisburseMaturity,
|
|
481
|
+
Configure: Configure,
|
|
482
|
+
RegisterVote: RegisterVote,
|
|
483
|
+
SetFollowing: SetFollowing,
|
|
484
|
+
SyncCommand: IDL.Record({}),
|
|
485
|
+
MakeProposal: Proposal,
|
|
486
|
+
FinalizeDisburseMaturity: FinalizeDisburseMaturity,
|
|
487
|
+
ClaimOrRefreshNeuron: ClaimOrRefresh,
|
|
488
|
+
RemoveNeuronPermissions: RemoveNeuronPermissions,
|
|
489
|
+
AddNeuronPermissions: AddNeuronPermissions,
|
|
490
|
+
MergeMaturity: MergeMaturity,
|
|
491
|
+
Disburse: Disburse,
|
|
489
492
|
});
|
|
490
493
|
const NeuronInFlightCommand = IDL.Record({
|
|
491
|
-
|
|
492
|
-
|
|
494
|
+
command: IDL.Opt(Command_2),
|
|
495
|
+
timestamp: IDL.Nat64,
|
|
493
496
|
});
|
|
494
497
|
const NeuronPermission = IDL.Record({
|
|
495
|
-
|
|
496
|
-
|
|
498
|
+
principal: IDL.Opt(IDL.Principal),
|
|
499
|
+
permission_type: IDL.Vec(IDL.Int32),
|
|
497
500
|
});
|
|
498
501
|
const DissolveState = IDL.Variant({
|
|
499
|
-
|
|
500
|
-
|
|
502
|
+
DissolveDelaySeconds: IDL.Nat64,
|
|
503
|
+
WhenDissolvedTimestampSeconds: IDL.Nat64,
|
|
501
504
|
});
|
|
502
505
|
const DisburseMaturityInProgress = IDL.Record({
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
506
|
+
timestamp_of_disbursement_seconds: IDL.Nat64,
|
|
507
|
+
amount_e8s: IDL.Nat64,
|
|
508
|
+
account_to_disburse_to: IDL.Opt(Account),
|
|
509
|
+
finalize_disbursement_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
507
510
|
});
|
|
508
511
|
const Neuron = IDL.Record({
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
|
|
515
|
-
|
|
512
|
+
id: IDL.Opt(NeuronId),
|
|
513
|
+
staked_maturity_e8s_equivalent: IDL.Opt(IDL.Nat64),
|
|
514
|
+
permissions: IDL.Vec(NeuronPermission),
|
|
515
|
+
maturity_e8s_equivalent: IDL.Nat64,
|
|
516
|
+
cached_neuron_stake_e8s: IDL.Nat64,
|
|
517
|
+
created_timestamp_seconds: IDL.Nat64,
|
|
518
|
+
topic_followees: IDL.Opt(
|
|
516
519
|
IDL.Record({
|
|
517
|
-
|
|
518
|
-
|
|
519
|
-
),
|
|
520
|
-
})
|
|
520
|
+
topic_id_to_followees: IDL.Vec(IDL.Tuple(IDL.Int32, FolloweesForTopic)),
|
|
521
|
+
}),
|
|
521
522
|
),
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
523
|
+
source_nns_neuron_id: IDL.Opt(IDL.Nat64),
|
|
524
|
+
auto_stake_maturity: IDL.Opt(IDL.Bool),
|
|
525
|
+
aging_since_timestamp_seconds: IDL.Nat64,
|
|
526
|
+
dissolve_state: IDL.Opt(DissolveState),
|
|
527
|
+
voting_power_percentage_multiplier: IDL.Nat64,
|
|
528
|
+
vesting_period_seconds: IDL.Opt(IDL.Nat64),
|
|
529
|
+
disburse_maturity_in_progress: IDL.Vec(DisburseMaturityInProgress),
|
|
530
|
+
followees: IDL.Vec(IDL.Tuple(IDL.Nat64, Followees)),
|
|
531
|
+
neuron_fees_e8s: IDL.Nat64,
|
|
531
532
|
});
|
|
532
533
|
const Governance = IDL.Record({
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
537
|
-
IDL.Tuple(IDL.Nat64, NervousSystemFunction)
|
|
534
|
+
root_canister_id: IDL.Opt(IDL.Principal),
|
|
535
|
+
timers: IDL.Opt(Timers),
|
|
536
|
+
cached_upgrade_steps: IDL.Opt(CachedUpgradeSteps),
|
|
537
|
+
id_to_nervous_system_functions: IDL.Vec(
|
|
538
|
+
IDL.Tuple(IDL.Nat64, NervousSystemFunction),
|
|
538
539
|
),
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
|
|
544
|
-
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
|
|
550
|
-
|
|
551
|
-
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
540
|
+
metrics: IDL.Opt(GovernanceCachedMetrics),
|
|
541
|
+
maturity_modulation: IDL.Opt(MaturityModulation),
|
|
542
|
+
upgrade_journal: IDL.Opt(UpgradeJournal),
|
|
543
|
+
mode: IDL.Int32,
|
|
544
|
+
parameters: IDL.Opt(NervousSystemParameters),
|
|
545
|
+
is_finalizing_disburse_maturity: IDL.Opt(IDL.Bool),
|
|
546
|
+
deployed_version: IDL.Opt(Version),
|
|
547
|
+
sns_initialization_parameters: IDL.Text,
|
|
548
|
+
latest_reward_event: IDL.Opt(RewardEvent),
|
|
549
|
+
pending_version: IDL.Opt(PendingVersion),
|
|
550
|
+
swap_canister_id: IDL.Opt(IDL.Principal),
|
|
551
|
+
ledger_canister_id: IDL.Opt(IDL.Principal),
|
|
552
|
+
proposals: IDL.Vec(IDL.Tuple(IDL.Nat64, ProposalData)),
|
|
553
|
+
in_flight_commands: IDL.Vec(IDL.Tuple(IDL.Text, NeuronInFlightCommand)),
|
|
554
|
+
sns_metadata: IDL.Opt(ManageSnsMetadata),
|
|
555
|
+
neurons: IDL.Vec(IDL.Tuple(IDL.Text, Neuron)),
|
|
556
|
+
target_version: IDL.Opt(Version),
|
|
557
|
+
genesis_timestamp_seconds: IDL.Nat64,
|
|
557
558
|
});
|
|
558
559
|
const AddMaturityRequest = IDL.Record({
|
|
559
|
-
|
|
560
|
-
|
|
560
|
+
id: IDL.Opt(NeuronId),
|
|
561
|
+
amount_e8s: IDL.Opt(IDL.Nat64),
|
|
561
562
|
});
|
|
562
563
|
const AddMaturityResponse = IDL.Record({
|
|
563
|
-
|
|
564
|
+
new_maturity_e8s: IDL.Opt(IDL.Nat64),
|
|
564
565
|
});
|
|
565
566
|
const AdvanceTargetVersionRequest = IDL.Record({
|
|
566
|
-
|
|
567
|
+
target_version: IDL.Opt(Version),
|
|
567
568
|
});
|
|
568
569
|
const AdvanceTargetVersionResponse = IDL.Record({});
|
|
569
|
-
const Principals = IDL.Record({
|
|
570
|
+
const Principals = IDL.Record({ principals: IDL.Vec(IDL.Principal) });
|
|
570
571
|
const NeuronsFund = IDL.Record({
|
|
571
|
-
|
|
572
|
-
|
|
573
|
-
|
|
572
|
+
nns_neuron_hotkeys: IDL.Opt(Principals),
|
|
573
|
+
nns_neuron_controller: IDL.Opt(IDL.Principal),
|
|
574
|
+
nns_neuron_id: IDL.Opt(IDL.Nat64),
|
|
574
575
|
});
|
|
575
576
|
const Participant = IDL.Variant({
|
|
576
|
-
|
|
577
|
-
|
|
577
|
+
NeuronsFund: NeuronsFund,
|
|
578
|
+
Direct: IDL.Record({}),
|
|
578
579
|
});
|
|
579
|
-
const NeuronIds = IDL.Record({
|
|
580
|
+
const NeuronIds = IDL.Record({ neuron_ids: IDL.Vec(NeuronId) });
|
|
580
581
|
const NeuronRecipe = IDL.Record({
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
|
|
582
|
+
controller: IDL.Opt(IDL.Principal),
|
|
583
|
+
dissolve_delay_seconds: IDL.Opt(IDL.Nat64),
|
|
584
|
+
participant: IDL.Opt(Participant),
|
|
585
|
+
stake_e8s: IDL.Opt(IDL.Nat64),
|
|
586
|
+
followees: IDL.Opt(NeuronIds),
|
|
587
|
+
neuron_id: IDL.Opt(NeuronId),
|
|
587
588
|
});
|
|
588
589
|
const NeuronRecipes = IDL.Record({
|
|
589
|
-
|
|
590
|
+
neuron_recipes: IDL.Vec(NeuronRecipe),
|
|
590
591
|
});
|
|
591
592
|
const ClaimSwapNeuronsRequest = IDL.Record({
|
|
592
|
-
|
|
593
|
+
neuron_recipes: IDL.Opt(NeuronRecipes),
|
|
593
594
|
});
|
|
594
595
|
const SwapNeuron = IDL.Record({
|
|
595
|
-
|
|
596
|
-
|
|
596
|
+
id: IDL.Opt(NeuronId),
|
|
597
|
+
status: IDL.Int32,
|
|
597
598
|
});
|
|
598
599
|
const ClaimedSwapNeurons = IDL.Record({
|
|
599
|
-
|
|
600
|
+
swap_neurons: IDL.Vec(SwapNeuron),
|
|
600
601
|
});
|
|
601
602
|
const ClaimSwapNeuronsResult = IDL.Variant({
|
|
602
|
-
|
|
603
|
-
|
|
603
|
+
Ok: ClaimedSwapNeurons,
|
|
604
|
+
Err: IDL.Int32,
|
|
604
605
|
});
|
|
605
606
|
const ClaimSwapNeuronsResponse = IDL.Record({
|
|
606
|
-
|
|
607
|
+
claim_swap_neurons_result: IDL.Opt(ClaimSwapNeuronsResult),
|
|
607
608
|
});
|
|
608
609
|
const GetMaturityModulationResponse = IDL.Record({
|
|
609
|
-
|
|
610
|
+
maturity_modulation: IDL.Opt(MaturityModulation),
|
|
610
611
|
});
|
|
611
612
|
const GetMetadataResponse = IDL.Record({
|
|
612
|
-
|
|
613
|
-
|
|
614
|
-
|
|
615
|
-
|
|
613
|
+
url: IDL.Opt(IDL.Text),
|
|
614
|
+
logo: IDL.Opt(IDL.Text),
|
|
615
|
+
name: IDL.Opt(IDL.Text),
|
|
616
|
+
description: IDL.Opt(IDL.Text),
|
|
616
617
|
});
|
|
617
618
|
const GetMetricsRequest = IDL.Record({
|
|
618
|
-
|
|
619
|
+
time_window_seconds: IDL.Opt(IDL.Nat64),
|
|
619
620
|
});
|
|
620
621
|
const Metrics = IDL.Record({
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
626
|
-
|
|
622
|
+
treasury_metrics: IDL.Opt(IDL.Vec(TreasuryMetrics)),
|
|
623
|
+
voting_power_metrics: IDL.Opt(VotingPowerMetrics),
|
|
624
|
+
last_ledger_block_timestamp: IDL.Opt(IDL.Nat64),
|
|
625
|
+
num_recently_executed_proposals: IDL.Opt(IDL.Nat64),
|
|
626
|
+
num_recently_submitted_proposals: IDL.Opt(IDL.Nat64),
|
|
627
|
+
genesis_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
627
628
|
});
|
|
628
629
|
const GetMetricsResult = IDL.Variant({
|
|
629
|
-
|
|
630
|
-
|
|
630
|
+
Ok: Metrics,
|
|
631
|
+
Err: GovernanceError,
|
|
631
632
|
});
|
|
632
633
|
const GetMetricsResponse = IDL.Record({
|
|
633
|
-
|
|
634
|
+
get_metrics_result: IDL.Opt(GetMetricsResult),
|
|
634
635
|
});
|
|
635
|
-
const GetModeResponse = IDL.Record({
|
|
636
|
-
const GetNeuron = IDL.Record({
|
|
637
|
-
const Result = IDL.Variant({
|
|
638
|
-
const GetNeuronResponse = IDL.Record({
|
|
639
|
-
const GetProposal = IDL.Record({
|
|
636
|
+
const GetModeResponse = IDL.Record({ mode: IDL.Opt(IDL.Int32) });
|
|
637
|
+
const GetNeuron = IDL.Record({ neuron_id: IDL.Opt(NeuronId) });
|
|
638
|
+
const Result = IDL.Variant({ Error: GovernanceError, Neuron: Neuron });
|
|
639
|
+
const GetNeuronResponse = IDL.Record({ result: IDL.Opt(Result) });
|
|
640
|
+
const GetProposal = IDL.Record({ proposal_id: IDL.Opt(ProposalId) });
|
|
640
641
|
const Result_1 = IDL.Variant({
|
|
641
|
-
|
|
642
|
-
|
|
642
|
+
Error: GovernanceError,
|
|
643
|
+
Proposal: ProposalData,
|
|
643
644
|
});
|
|
644
|
-
const GetProposalResponse = IDL.Record({
|
|
645
|
+
const GetProposalResponse = IDL.Record({ result: IDL.Opt(Result_1) });
|
|
645
646
|
const MemoryMetrics = IDL.Record({
|
|
646
|
-
|
|
647
|
-
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
|
|
651
|
-
|
|
652
|
-
|
|
653
|
-
|
|
647
|
+
wasm_binary_size: IDL.Opt(IDL.Nat),
|
|
648
|
+
wasm_chunk_store_size: IDL.Opt(IDL.Nat),
|
|
649
|
+
canister_history_size: IDL.Opt(IDL.Nat),
|
|
650
|
+
stable_memory_size: IDL.Opt(IDL.Nat),
|
|
651
|
+
snapshots_size: IDL.Opt(IDL.Nat),
|
|
652
|
+
wasm_memory_size: IDL.Opt(IDL.Nat),
|
|
653
|
+
global_memory_size: IDL.Opt(IDL.Nat),
|
|
654
|
+
custom_sections_size: IDL.Opt(IDL.Nat),
|
|
654
655
|
});
|
|
655
656
|
const CanisterStatusType = IDL.Variant({
|
|
656
|
-
|
|
657
|
-
|
|
658
|
-
|
|
657
|
+
stopped: IDL.Null,
|
|
658
|
+
stopping: IDL.Null,
|
|
659
|
+
running: IDL.Null,
|
|
659
660
|
});
|
|
660
661
|
const DefiniteCanisterSettingsArgs = IDL.Record({
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
662
|
+
freezing_threshold: IDL.Nat,
|
|
663
|
+
wasm_memory_threshold: IDL.Opt(IDL.Nat),
|
|
664
|
+
controllers: IDL.Vec(IDL.Principal),
|
|
665
|
+
wasm_memory_limit: IDL.Opt(IDL.Nat),
|
|
666
|
+
memory_allocation: IDL.Nat,
|
|
667
|
+
compute_allocation: IDL.Nat,
|
|
667
668
|
});
|
|
668
669
|
const QueryStats = IDL.Record({
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
|
|
672
|
-
|
|
670
|
+
response_payload_bytes_total: IDL.Opt(IDL.Nat),
|
|
671
|
+
num_instructions_total: IDL.Opt(IDL.Nat),
|
|
672
|
+
num_calls_total: IDL.Opt(IDL.Nat),
|
|
673
|
+
request_payload_bytes_total: IDL.Opt(IDL.Nat),
|
|
673
674
|
});
|
|
674
675
|
const CanisterStatusResultV2 = IDL.Record({
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
676
|
+
memory_metrics: IDL.Opt(MemoryMetrics),
|
|
677
|
+
status: CanisterStatusType,
|
|
678
|
+
memory_size: IDL.Nat,
|
|
679
|
+
cycles: IDL.Nat,
|
|
680
|
+
settings: DefiniteCanisterSettingsArgs,
|
|
681
|
+
query_stats: IDL.Opt(QueryStats),
|
|
682
|
+
idle_cycles_burned_per_day: IDL.Nat,
|
|
683
|
+
module_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
683
684
|
});
|
|
684
685
|
const GetRunningSnsVersionResponse = IDL.Record({
|
|
685
|
-
|
|
686
|
-
|
|
686
|
+
deployed_version: IDL.Opt(Version),
|
|
687
|
+
pending_version: IDL.Opt(
|
|
687
688
|
IDL.Record({
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
})
|
|
689
|
+
mark_failed_at_seconds: IDL.Nat64,
|
|
690
|
+
checking_upgrade_lock: IDL.Nat64,
|
|
691
|
+
proposal_id: IDL.Nat64,
|
|
692
|
+
target_version: IDL.Opt(Version),
|
|
693
|
+
}),
|
|
693
694
|
),
|
|
694
695
|
});
|
|
695
696
|
const GetSnsInitializationParametersResponse = IDL.Record({
|
|
696
|
-
|
|
697
|
+
sns_initialization_parameters: IDL.Text,
|
|
697
698
|
});
|
|
698
|
-
const GetTimersResponse = IDL.Record({
|
|
699
|
+
const GetTimersResponse = IDL.Record({ timers: IDL.Opt(Timers) });
|
|
699
700
|
const GetUpgradeJournalRequest = IDL.Record({
|
|
700
|
-
|
|
701
|
-
|
|
701
|
+
offset: IDL.Opt(IDL.Nat64),
|
|
702
|
+
limit: IDL.Opt(IDL.Nat64),
|
|
702
703
|
});
|
|
703
704
|
const GetUpgradeJournalResponse = IDL.Record({
|
|
704
|
-
|
|
705
|
-
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
|
|
705
|
+
upgrade_journal: IDL.Opt(UpgradeJournal),
|
|
706
|
+
upgrade_steps: IDL.Opt(Versions),
|
|
707
|
+
response_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
708
|
+
deployed_version: IDL.Opt(Version),
|
|
709
|
+
target_version: IDL.Opt(Version),
|
|
710
|
+
upgrade_journal_entry_count: IDL.Opt(IDL.Nat64),
|
|
710
711
|
});
|
|
711
712
|
const ListNervousSystemFunctionsResponse = IDL.Record({
|
|
712
|
-
|
|
713
|
-
|
|
713
|
+
reserved_ids: IDL.Vec(IDL.Nat64),
|
|
714
|
+
functions: IDL.Vec(NervousSystemFunction),
|
|
714
715
|
});
|
|
715
716
|
const ListNeurons = IDL.Record({
|
|
716
|
-
|
|
717
|
-
|
|
718
|
-
|
|
717
|
+
of_principal: IDL.Opt(IDL.Principal),
|
|
718
|
+
limit: IDL.Nat32,
|
|
719
|
+
start_page_at: IDL.Opt(NeuronId),
|
|
719
720
|
});
|
|
720
|
-
const ListNeuronsResponse = IDL.Record({
|
|
721
|
-
const TopicSelector = IDL.Record({
|
|
721
|
+
const ListNeuronsResponse = IDL.Record({ neurons: IDL.Vec(Neuron) });
|
|
722
|
+
const TopicSelector = IDL.Record({ topic: IDL.Opt(Topic) });
|
|
722
723
|
const ListProposals = IDL.Record({
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
|
|
728
|
-
|
|
724
|
+
include_reward_status: IDL.Vec(IDL.Int32),
|
|
725
|
+
before_proposal: IDL.Opt(ProposalId),
|
|
726
|
+
limit: IDL.Nat32,
|
|
727
|
+
exclude_type: IDL.Vec(IDL.Nat64),
|
|
728
|
+
include_topics: IDL.Opt(IDL.Vec(TopicSelector)),
|
|
729
|
+
include_status: IDL.Vec(IDL.Int32),
|
|
729
730
|
});
|
|
730
731
|
const ListProposalsResponse = IDL.Record({
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
|
|
732
|
+
include_ballots_by_caller: IDL.Opt(IDL.Bool),
|
|
733
|
+
proposals: IDL.Vec(ProposalData),
|
|
734
|
+
include_topic_filtering: IDL.Opt(IDL.Bool),
|
|
734
735
|
});
|
|
735
736
|
const ListTopicsRequest = IDL.Record({});
|
|
736
737
|
const ExtensionOperationType = IDL.Variant({
|
|
737
|
-
|
|
738
|
-
|
|
738
|
+
TreasuryManagerWithdraw: IDL.Null,
|
|
739
|
+
TreasuryManagerDeposit: IDL.Null,
|
|
739
740
|
});
|
|
740
|
-
const ExtensionType = IDL.Variant({
|
|
741
|
+
const ExtensionType = IDL.Variant({ TreasuryManager: IDL.Null });
|
|
741
742
|
const ExtensionOperationSpec = IDL.Record({
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
743
|
+
topic: IDL.Opt(Topic),
|
|
744
|
+
operation_type: IDL.Opt(ExtensionOperationType),
|
|
745
|
+
description: IDL.Opt(IDL.Text),
|
|
746
|
+
extension_type: IDL.Opt(ExtensionType),
|
|
746
747
|
});
|
|
747
748
|
const RegisteredExtensionOperationSpec = IDL.Record({
|
|
748
|
-
|
|
749
|
-
|
|
749
|
+
spec: IDL.Opt(ExtensionOperationSpec),
|
|
750
|
+
canister_id: IDL.Opt(IDL.Principal),
|
|
750
751
|
});
|
|
751
752
|
const TopicInfo = IDL.Record({
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
753
|
+
extension_operations: IDL.Opt(IDL.Vec(RegisteredExtensionOperationSpec)),
|
|
754
|
+
native_functions: IDL.Opt(IDL.Vec(NervousSystemFunction)),
|
|
755
|
+
topic: IDL.Opt(Topic),
|
|
756
|
+
is_critical: IDL.Opt(IDL.Bool),
|
|
757
|
+
name: IDL.Opt(IDL.Text),
|
|
758
|
+
description: IDL.Opt(IDL.Text),
|
|
759
|
+
custom_functions: IDL.Opt(IDL.Vec(NervousSystemFunction)),
|
|
759
760
|
});
|
|
760
761
|
const ListTopicsResponse = IDL.Record({
|
|
761
|
-
|
|
762
|
-
|
|
762
|
+
uncategorized_functions: IDL.Opt(IDL.Vec(NervousSystemFunction)),
|
|
763
|
+
topics: IDL.Opt(IDL.Vec(TopicInfo)),
|
|
763
764
|
});
|
|
764
765
|
const StakeMaturity = IDL.Record({
|
|
765
|
-
|
|
766
|
+
percentage_to_stake: IDL.Opt(IDL.Nat32),
|
|
766
767
|
});
|
|
767
768
|
const Command = IDL.Variant({
|
|
768
|
-
|
|
769
|
-
|
|
770
|
-
|
|
771
|
-
|
|
772
|
-
|
|
773
|
-
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
769
|
+
Split: Split,
|
|
770
|
+
Follow: Follow,
|
|
771
|
+
DisburseMaturity: DisburseMaturity,
|
|
772
|
+
ClaimOrRefresh: ClaimOrRefresh,
|
|
773
|
+
Configure: Configure,
|
|
774
|
+
RegisterVote: RegisterVote,
|
|
775
|
+
SetFollowing: SetFollowing,
|
|
776
|
+
MakeProposal: Proposal,
|
|
777
|
+
StakeMaturity: StakeMaturity,
|
|
778
|
+
RemoveNeuronPermissions: RemoveNeuronPermissions,
|
|
779
|
+
AddNeuronPermissions: AddNeuronPermissions,
|
|
780
|
+
MergeMaturity: MergeMaturity,
|
|
781
|
+
Disburse: Disburse,
|
|
781
782
|
});
|
|
782
783
|
const ManageNeuron = IDL.Record({
|
|
783
|
-
|
|
784
|
-
|
|
784
|
+
subaccount: IDL.Vec(IDL.Nat8),
|
|
785
|
+
command: IDL.Opt(Command),
|
|
785
786
|
});
|
|
786
|
-
const SplitResponse = IDL.Record({
|
|
787
|
+
const SplitResponse = IDL.Record({ created_neuron_id: IDL.Opt(NeuronId) });
|
|
787
788
|
const DisburseMaturityResponse = IDL.Record({
|
|
788
|
-
|
|
789
|
-
|
|
789
|
+
amount_disbursed_e8s: IDL.Nat64,
|
|
790
|
+
amount_deducted_e8s: IDL.Opt(IDL.Nat64),
|
|
790
791
|
});
|
|
791
792
|
const ClaimOrRefreshResponse = IDL.Record({
|
|
792
|
-
|
|
793
|
+
refreshed_neuron_id: IDL.Opt(NeuronId),
|
|
793
794
|
});
|
|
794
795
|
const StakeMaturityResponse = IDL.Record({
|
|
795
|
-
|
|
796
|
-
|
|
796
|
+
maturity_e8s: IDL.Nat64,
|
|
797
|
+
staked_maturity_e8s: IDL.Nat64,
|
|
797
798
|
});
|
|
798
799
|
const MergeMaturityResponse = IDL.Record({
|
|
799
|
-
|
|
800
|
-
|
|
800
|
+
merged_maturity_e8s: IDL.Nat64,
|
|
801
|
+
new_stake_e8s: IDL.Nat64,
|
|
801
802
|
});
|
|
802
|
-
const DisburseResponse = IDL.Record({
|
|
803
|
+
const DisburseResponse = IDL.Record({ transfer_block_height: IDL.Nat64 });
|
|
803
804
|
const Command_1 = IDL.Variant({
|
|
804
|
-
|
|
805
|
-
|
|
806
|
-
|
|
807
|
-
|
|
808
|
-
|
|
809
|
-
|
|
810
|
-
|
|
811
|
-
|
|
812
|
-
|
|
813
|
-
|
|
814
|
-
|
|
815
|
-
|
|
816
|
-
|
|
817
|
-
|
|
818
|
-
});
|
|
819
|
-
const ManageNeuronResponse = IDL.Record({
|
|
805
|
+
Error: GovernanceError,
|
|
806
|
+
Split: SplitResponse,
|
|
807
|
+
Follow: IDL.Record({}),
|
|
808
|
+
DisburseMaturity: DisburseMaturityResponse,
|
|
809
|
+
ClaimOrRefresh: ClaimOrRefreshResponse,
|
|
810
|
+
Configure: IDL.Record({}),
|
|
811
|
+
RegisterVote: IDL.Record({}),
|
|
812
|
+
SetFollowing: IDL.Record({}),
|
|
813
|
+
MakeProposal: GetProposal,
|
|
814
|
+
RemoveNeuronPermission: IDL.Record({}),
|
|
815
|
+
StakeMaturity: StakeMaturityResponse,
|
|
816
|
+
MergeMaturity: MergeMaturityResponse,
|
|
817
|
+
Disburse: DisburseResponse,
|
|
818
|
+
AddNeuronPermission: IDL.Record({}),
|
|
819
|
+
});
|
|
820
|
+
const ManageNeuronResponse = IDL.Record({ command: IDL.Opt(Command_1) });
|
|
820
821
|
const MintTokensRequest = IDL.Record({
|
|
821
|
-
|
|
822
|
-
|
|
822
|
+
recipient: IDL.Opt(Account),
|
|
823
|
+
amount_e8s: IDL.Opt(IDL.Nat64),
|
|
823
824
|
});
|
|
824
|
-
const SetMode = IDL.Record({
|
|
825
|
+
const SetMode = IDL.Record({ mode: IDL.Int32 });
|
|
826
|
+
|
|
825
827
|
return IDL.Service({
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
833
|
-
|
|
834
|
-
|
|
835
|
-
|
|
836
|
-
|
|
837
|
-
|
|
838
|
-
|
|
839
|
-
|
|
840
|
-
|
|
841
|
-
|
|
842
|
-
|
|
843
|
-
|
|
844
|
-
|
|
845
|
-
|
|
846
|
-
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
|
|
854
|
-
|
|
855
|
-
|
|
856
|
-
|
|
857
|
-
|
|
858
|
-
|
|
859
|
-
|
|
860
|
-
|
|
861
|
-
|
|
862
|
-
|
|
863
|
-
|
|
864
|
-
|
|
865
|
-
|
|
866
|
-
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
|
|
871
|
-
|
|
872
|
-
|
|
873
|
-
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
|
|
879
|
-
|
|
880
|
-
|
|
881
|
-
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
|
|
885
|
-
|
|
886
|
-
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
896
|
-
|
|
897
|
-
|
|
898
|
-
|
|
899
|
-
|
|
900
|
-
|
|
901
|
-
|
|
902
|
-
|
|
903
|
-
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
910
|
-
|
|
911
|
-
'refresh_cached_upgrade_steps' : IDL.Func(
|
|
912
|
-
[IDL.Record({})],
|
|
913
|
-
[IDL.Record({})],
|
|
914
|
-
[],
|
|
915
|
-
),
|
|
916
|
-
'reset_timers' : IDL.Func([IDL.Record({})], [IDL.Record({})], []),
|
|
917
|
-
'set_mode' : IDL.Func([SetMode], [IDL.Record({})], []),
|
|
918
|
-
'update_neuron' : IDL.Func([Neuron], [IDL.Opt(GovernanceError)], []),
|
|
828
|
+
add_maturity: IDL.Func([AddMaturityRequest], [AddMaturityResponse], []),
|
|
829
|
+
advance_target_version: IDL.Func(
|
|
830
|
+
[AdvanceTargetVersionRequest],
|
|
831
|
+
[AdvanceTargetVersionResponse],
|
|
832
|
+
[],
|
|
833
|
+
),
|
|
834
|
+
claim_swap_neurons: IDL.Func(
|
|
835
|
+
[ClaimSwapNeuronsRequest],
|
|
836
|
+
[ClaimSwapNeuronsResponse],
|
|
837
|
+
[],
|
|
838
|
+
),
|
|
839
|
+
fail_stuck_upgrade_in_progress: IDL.Func(
|
|
840
|
+
[IDL.Record({})],
|
|
841
|
+
[IDL.Record({})],
|
|
842
|
+
[],
|
|
843
|
+
),
|
|
844
|
+
get_build_metadata: IDL.Func([], [IDL.Text], ["query"]),
|
|
845
|
+
get_latest_reward_event: IDL.Func([], [RewardEvent], ["query"]),
|
|
846
|
+
get_maturity_modulation: IDL.Func(
|
|
847
|
+
[IDL.Record({})],
|
|
848
|
+
[GetMaturityModulationResponse],
|
|
849
|
+
[],
|
|
850
|
+
),
|
|
851
|
+
get_metadata: IDL.Func([IDL.Record({})], [GetMetadataResponse], ["query"]),
|
|
852
|
+
get_metrics: IDL.Func(
|
|
853
|
+
[GetMetricsRequest],
|
|
854
|
+
[GetMetricsResponse],
|
|
855
|
+
["composite_query"],
|
|
856
|
+
),
|
|
857
|
+
get_metrics_replicated: IDL.Func(
|
|
858
|
+
[GetMetricsRequest],
|
|
859
|
+
[GetMetricsResponse],
|
|
860
|
+
[],
|
|
861
|
+
),
|
|
862
|
+
get_mode: IDL.Func([IDL.Record({})], [GetModeResponse], ["query"]),
|
|
863
|
+
get_nervous_system_parameters: IDL.Func(
|
|
864
|
+
[IDL.Null],
|
|
865
|
+
[NervousSystemParameters],
|
|
866
|
+
["query"],
|
|
867
|
+
),
|
|
868
|
+
get_neuron: IDL.Func([GetNeuron], [GetNeuronResponse], ["query"]),
|
|
869
|
+
get_proposal: IDL.Func([GetProposal], [GetProposalResponse], ["query"]),
|
|
870
|
+
get_root_canister_status: IDL.Func(
|
|
871
|
+
[IDL.Null],
|
|
872
|
+
[CanisterStatusResultV2],
|
|
873
|
+
[],
|
|
874
|
+
),
|
|
875
|
+
get_running_sns_version: IDL.Func(
|
|
876
|
+
[IDL.Record({})],
|
|
877
|
+
[GetRunningSnsVersionResponse],
|
|
878
|
+
["query"],
|
|
879
|
+
),
|
|
880
|
+
get_sns_initialization_parameters: IDL.Func(
|
|
881
|
+
[IDL.Record({})],
|
|
882
|
+
[GetSnsInitializationParametersResponse],
|
|
883
|
+
["query"],
|
|
884
|
+
),
|
|
885
|
+
get_timers: IDL.Func([IDL.Record({})], [GetTimersResponse], ["query"]),
|
|
886
|
+
get_upgrade_journal: IDL.Func(
|
|
887
|
+
[GetUpgradeJournalRequest],
|
|
888
|
+
[GetUpgradeJournalResponse],
|
|
889
|
+
["query"],
|
|
890
|
+
),
|
|
891
|
+
list_nervous_system_functions: IDL.Func(
|
|
892
|
+
[],
|
|
893
|
+
[ListNervousSystemFunctionsResponse],
|
|
894
|
+
["query"],
|
|
895
|
+
),
|
|
896
|
+
list_neurons: IDL.Func([ListNeurons], [ListNeuronsResponse], ["query"]),
|
|
897
|
+
list_proposals: IDL.Func(
|
|
898
|
+
[ListProposals],
|
|
899
|
+
[ListProposalsResponse],
|
|
900
|
+
["query"],
|
|
901
|
+
),
|
|
902
|
+
list_topics: IDL.Func([ListTopicsRequest], [ListTopicsResponse], ["query"]),
|
|
903
|
+
manage_neuron: IDL.Func([ManageNeuron], [ManageNeuronResponse], []),
|
|
904
|
+
mint_tokens: IDL.Func([MintTokensRequest], [IDL.Record({})], []),
|
|
905
|
+
refresh_cached_upgrade_steps: IDL.Func(
|
|
906
|
+
[IDL.Record({})],
|
|
907
|
+
[IDL.Record({})],
|
|
908
|
+
[],
|
|
909
|
+
),
|
|
910
|
+
reset_timers: IDL.Func([IDL.Record({})], [IDL.Record({})], []),
|
|
911
|
+
set_mode: IDL.Func([SetMode], [IDL.Record({})], []),
|
|
912
|
+
update_neuron: IDL.Func([Neuron], [IDL.Opt(GovernanceError)], []),
|
|
919
913
|
});
|
|
920
914
|
};
|
|
915
|
+
|
|
921
916
|
export const init = ({ IDL }) => {
|
|
922
917
|
const PreciseValue = IDL.Rec();
|
|
923
918
|
const Timers = IDL.Record({
|
|
924
|
-
|
|
925
|
-
|
|
926
|
-
|
|
919
|
+
last_spawned_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
920
|
+
last_reset_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
921
|
+
requires_periodic_tasks: IDL.Opt(IDL.Bool),
|
|
927
922
|
});
|
|
928
923
|
const Version = IDL.Record({
|
|
929
|
-
|
|
930
|
-
|
|
931
|
-
|
|
932
|
-
|
|
933
|
-
|
|
934
|
-
|
|
935
|
-
});
|
|
936
|
-
const Versions = IDL.Record({
|
|
924
|
+
archive_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
925
|
+
root_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
926
|
+
swap_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
927
|
+
ledger_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
928
|
+
governance_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
929
|
+
index_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
930
|
+
});
|
|
931
|
+
const Versions = IDL.Record({ versions: IDL.Vec(Version) });
|
|
937
932
|
const CachedUpgradeSteps = IDL.Record({
|
|
938
|
-
|
|
939
|
-
|
|
940
|
-
|
|
933
|
+
upgrade_steps: IDL.Opt(Versions),
|
|
934
|
+
response_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
935
|
+
requested_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
941
936
|
});
|
|
942
937
|
const Topic = IDL.Variant({
|
|
943
|
-
|
|
944
|
-
|
|
945
|
-
|
|
946
|
-
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
|
|
938
|
+
DappCanisterManagement: IDL.Null,
|
|
939
|
+
DaoCommunitySettings: IDL.Null,
|
|
940
|
+
ApplicationBusinessLogic: IDL.Null,
|
|
941
|
+
CriticalDappOperations: IDL.Null,
|
|
942
|
+
TreasuryAssetManagement: IDL.Null,
|
|
943
|
+
Governance: IDL.Null,
|
|
944
|
+
SnsFrameworkManagement: IDL.Null,
|
|
950
945
|
});
|
|
951
946
|
const GenericNervousSystemFunction = IDL.Record({
|
|
952
|
-
|
|
953
|
-
|
|
954
|
-
|
|
955
|
-
|
|
956
|
-
|
|
947
|
+
topic: IDL.Opt(Topic),
|
|
948
|
+
validator_canister_id: IDL.Opt(IDL.Principal),
|
|
949
|
+
target_canister_id: IDL.Opt(IDL.Principal),
|
|
950
|
+
validator_method_name: IDL.Opt(IDL.Text),
|
|
951
|
+
target_method_name: IDL.Opt(IDL.Text),
|
|
957
952
|
});
|
|
958
953
|
const FunctionType = IDL.Variant({
|
|
959
|
-
|
|
960
|
-
|
|
954
|
+
NativeNervousSystemFunction: IDL.Record({}),
|
|
955
|
+
GenericNervousSystemFunction: GenericNervousSystemFunction,
|
|
961
956
|
});
|
|
962
957
|
const NervousSystemFunction = IDL.Record({
|
|
963
|
-
|
|
964
|
-
|
|
965
|
-
|
|
966
|
-
|
|
958
|
+
id: IDL.Nat64,
|
|
959
|
+
name: IDL.Text,
|
|
960
|
+
description: IDL.Opt(IDL.Text),
|
|
961
|
+
function_type: IDL.Opt(FunctionType),
|
|
967
962
|
});
|
|
968
|
-
const Subaccount = IDL.Record({
|
|
963
|
+
const Subaccount = IDL.Record({ subaccount: IDL.Vec(IDL.Nat8) });
|
|
969
964
|
const Account = IDL.Record({
|
|
970
|
-
|
|
971
|
-
|
|
965
|
+
owner: IDL.Opt(IDL.Principal),
|
|
966
|
+
subaccount: IDL.Opt(Subaccount),
|
|
972
967
|
});
|
|
973
968
|
const TreasuryMetrics = IDL.Record({
|
|
974
|
-
|
|
975
|
-
|
|
976
|
-
|
|
977
|
-
|
|
978
|
-
|
|
979
|
-
|
|
980
|
-
|
|
969
|
+
name: IDL.Opt(IDL.Text),
|
|
970
|
+
original_amount_e8s: IDL.Opt(IDL.Nat64),
|
|
971
|
+
amount_e8s: IDL.Opt(IDL.Nat64),
|
|
972
|
+
account: IDL.Opt(Account),
|
|
973
|
+
ledger_canister_id: IDL.Opt(IDL.Principal),
|
|
974
|
+
treasury: IDL.Int32,
|
|
975
|
+
timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
981
976
|
});
|
|
982
977
|
const VotingPowerMetrics = IDL.Record({
|
|
983
|
-
|
|
984
|
-
|
|
978
|
+
governance_total_potential_voting_power: IDL.Opt(IDL.Nat64),
|
|
979
|
+
timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
985
980
|
});
|
|
986
981
|
const GovernanceCachedMetrics = IDL.Record({
|
|
987
|
-
|
|
988
|
-
|
|
989
|
-
IDL.Tuple(IDL.Nat64, IDL.Float64)
|
|
990
|
-
),
|
|
991
|
-
'garbage_collectable_neurons_count' : IDL.Nat64,
|
|
992
|
-
'neurons_with_invalid_stake_count' : IDL.Nat64,
|
|
993
|
-
'not_dissolving_neurons_count_buckets' : IDL.Vec(
|
|
994
|
-
IDL.Tuple(IDL.Nat64, IDL.Nat64)
|
|
982
|
+
treasury_metrics: IDL.Vec(TreasuryMetrics),
|
|
983
|
+
not_dissolving_neurons_e8s_buckets: IDL.Vec(
|
|
984
|
+
IDL.Tuple(IDL.Nat64, IDL.Float64),
|
|
995
985
|
),
|
|
996
|
-
|
|
997
|
-
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
'voting_power_metrics' : IDL.Opt(VotingPowerMetrics),
|
|
1001
|
-
'not_dissolving_neurons_count' : IDL.Nat64,
|
|
1002
|
-
'dissolved_neurons_e8s' : IDL.Nat64,
|
|
1003
|
-
'neurons_with_less_than_6_months_dissolve_delay_e8s' : IDL.Nat64,
|
|
1004
|
-
'dissolving_neurons_count_buckets' : IDL.Vec(
|
|
1005
|
-
IDL.Tuple(IDL.Nat64, IDL.Nat64)
|
|
986
|
+
garbage_collectable_neurons_count: IDL.Nat64,
|
|
987
|
+
neurons_with_invalid_stake_count: IDL.Nat64,
|
|
988
|
+
not_dissolving_neurons_count_buckets: IDL.Vec(
|
|
989
|
+
IDL.Tuple(IDL.Nat64, IDL.Nat64),
|
|
1006
990
|
),
|
|
1007
|
-
|
|
1008
|
-
|
|
1009
|
-
|
|
1010
|
-
|
|
1011
|
-
|
|
991
|
+
neurons_with_less_than_6_months_dissolve_delay_count: IDL.Nat64,
|
|
992
|
+
dissolved_neurons_count: IDL.Nat64,
|
|
993
|
+
total_staked_e8s: IDL.Nat64,
|
|
994
|
+
total_supply_governance_tokens: IDL.Nat64,
|
|
995
|
+
voting_power_metrics: IDL.Opt(VotingPowerMetrics),
|
|
996
|
+
not_dissolving_neurons_count: IDL.Nat64,
|
|
997
|
+
dissolved_neurons_e8s: IDL.Nat64,
|
|
998
|
+
neurons_with_less_than_6_months_dissolve_delay_e8s: IDL.Nat64,
|
|
999
|
+
dissolving_neurons_count_buckets: IDL.Vec(IDL.Tuple(IDL.Nat64, IDL.Nat64)),
|
|
1000
|
+
dissolving_neurons_count: IDL.Nat64,
|
|
1001
|
+
dissolving_neurons_e8s_buckets: IDL.Vec(IDL.Tuple(IDL.Nat64, IDL.Float64)),
|
|
1002
|
+
timestamp_seconds: IDL.Nat64,
|
|
1012
1003
|
});
|
|
1013
1004
|
const MaturityModulation = IDL.Record({
|
|
1014
|
-
|
|
1015
|
-
|
|
1005
|
+
current_basis_points: IDL.Opt(IDL.Int32),
|
|
1006
|
+
updated_at_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
1016
1007
|
});
|
|
1017
1008
|
const TargetVersionSet = IDL.Record({
|
|
1018
|
-
|
|
1019
|
-
|
|
1020
|
-
|
|
1009
|
+
old_target_version: IDL.Opt(Version),
|
|
1010
|
+
new_target_version: IDL.Opt(Version),
|
|
1011
|
+
is_advanced_automatically: IDL.Opt(IDL.Bool),
|
|
1021
1012
|
});
|
|
1022
1013
|
const UpgradeStepsReset = IDL.Record({
|
|
1023
|
-
|
|
1024
|
-
|
|
1014
|
+
human_readable: IDL.Opt(IDL.Text),
|
|
1015
|
+
upgrade_steps: IDL.Opt(Versions),
|
|
1025
1016
|
});
|
|
1026
1017
|
const UpgradeOutcome = IDL.Record({
|
|
1027
|
-
|
|
1018
|
+
status: IDL.Opt(
|
|
1028
1019
|
IDL.Variant({
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
|
|
1032
|
-
|
|
1033
|
-
})
|
|
1020
|
+
Success: IDL.Record({}),
|
|
1021
|
+
Timeout: IDL.Record({}),
|
|
1022
|
+
ExternalFailure: IDL.Record({}),
|
|
1023
|
+
InvalidState: IDL.Record({ version: IDL.Opt(Version) }),
|
|
1024
|
+
}),
|
|
1034
1025
|
),
|
|
1035
|
-
|
|
1026
|
+
human_readable: IDL.Opt(IDL.Text),
|
|
1036
1027
|
});
|
|
1037
|
-
const ProposalId = IDL.Record({
|
|
1028
|
+
const ProposalId = IDL.Record({ id: IDL.Nat64 });
|
|
1038
1029
|
const UpgradeStarted = IDL.Record({
|
|
1039
|
-
|
|
1040
|
-
|
|
1041
|
-
|
|
1030
|
+
current_version: IDL.Opt(Version),
|
|
1031
|
+
expected_version: IDL.Opt(Version),
|
|
1032
|
+
reason: IDL.Opt(
|
|
1042
1033
|
IDL.Variant({
|
|
1043
|
-
|
|
1044
|
-
|
|
1045
|
-
})
|
|
1034
|
+
UpgradeSnsToNextVersionProposal: ProposalId,
|
|
1035
|
+
BehindTargetVersion: IDL.Record({}),
|
|
1036
|
+
}),
|
|
1046
1037
|
),
|
|
1047
1038
|
});
|
|
1048
1039
|
const UpgradeStepsRefreshed = IDL.Record({
|
|
1049
|
-
|
|
1040
|
+
upgrade_steps: IDL.Opt(Versions),
|
|
1050
1041
|
});
|
|
1051
1042
|
const TargetVersionReset = IDL.Record({
|
|
1052
|
-
|
|
1053
|
-
|
|
1054
|
-
|
|
1043
|
+
human_readable: IDL.Opt(IDL.Text),
|
|
1044
|
+
old_target_version: IDL.Opt(Version),
|
|
1045
|
+
new_target_version: IDL.Opt(Version),
|
|
1055
1046
|
});
|
|
1056
1047
|
const UpgradeJournalEntry = IDL.Record({
|
|
1057
|
-
|
|
1048
|
+
event: IDL.Opt(
|
|
1058
1049
|
IDL.Variant({
|
|
1059
|
-
|
|
1060
|
-
|
|
1061
|
-
|
|
1062
|
-
|
|
1063
|
-
|
|
1064
|
-
|
|
1065
|
-
})
|
|
1050
|
+
TargetVersionSet: TargetVersionSet,
|
|
1051
|
+
UpgradeStepsReset: UpgradeStepsReset,
|
|
1052
|
+
UpgradeOutcome: UpgradeOutcome,
|
|
1053
|
+
UpgradeStarted: UpgradeStarted,
|
|
1054
|
+
UpgradeStepsRefreshed: UpgradeStepsRefreshed,
|
|
1055
|
+
TargetVersionReset: TargetVersionReset,
|
|
1056
|
+
}),
|
|
1066
1057
|
),
|
|
1067
|
-
|
|
1058
|
+
timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
1068
1059
|
});
|
|
1069
1060
|
const UpgradeJournal = IDL.Record({
|
|
1070
|
-
|
|
1061
|
+
entries: IDL.Vec(UpgradeJournalEntry),
|
|
1071
1062
|
});
|
|
1072
|
-
const NeuronId = IDL.Record({
|
|
1073
|
-
const Followees = IDL.Record({
|
|
1063
|
+
const NeuronId = IDL.Record({ id: IDL.Vec(IDL.Nat8) });
|
|
1064
|
+
const Followees = IDL.Record({ followees: IDL.Vec(NeuronId) });
|
|
1074
1065
|
const DefaultFollowees = IDL.Record({
|
|
1075
|
-
|
|
1066
|
+
followees: IDL.Vec(IDL.Tuple(IDL.Nat64, Followees)),
|
|
1076
1067
|
});
|
|
1077
1068
|
const NeuronPermissionList = IDL.Record({
|
|
1078
|
-
|
|
1069
|
+
permissions: IDL.Vec(IDL.Int32),
|
|
1079
1070
|
});
|
|
1080
1071
|
const VotingRewardsParameters = IDL.Record({
|
|
1081
|
-
|
|
1082
|
-
|
|
1083
|
-
|
|
1084
|
-
|
|
1072
|
+
final_reward_rate_basis_points: IDL.Opt(IDL.Nat64),
|
|
1073
|
+
initial_reward_rate_basis_points: IDL.Opt(IDL.Nat64),
|
|
1074
|
+
reward_rate_transition_duration_seconds: IDL.Opt(IDL.Nat64),
|
|
1075
|
+
round_duration_seconds: IDL.Opt(IDL.Nat64),
|
|
1085
1076
|
});
|
|
1086
1077
|
const NervousSystemParameters = IDL.Record({
|
|
1087
|
-
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
|
|
1100
|
-
|
|
1101
|
-
|
|
1102
|
-
|
|
1103
|
-
|
|
1104
|
-
|
|
1105
|
-
|
|
1106
|
-
|
|
1107
|
-
|
|
1078
|
+
default_followees: IDL.Opt(DefaultFollowees),
|
|
1079
|
+
max_dissolve_delay_seconds: IDL.Opt(IDL.Nat64),
|
|
1080
|
+
max_dissolve_delay_bonus_percentage: IDL.Opt(IDL.Nat64),
|
|
1081
|
+
max_followees_per_function: IDL.Opt(IDL.Nat64),
|
|
1082
|
+
automatically_advance_target_version: IDL.Opt(IDL.Bool),
|
|
1083
|
+
neuron_claimer_permissions: IDL.Opt(NeuronPermissionList),
|
|
1084
|
+
neuron_minimum_stake_e8s: IDL.Opt(IDL.Nat64),
|
|
1085
|
+
max_neuron_age_for_age_bonus: IDL.Opt(IDL.Nat64),
|
|
1086
|
+
initial_voting_period_seconds: IDL.Opt(IDL.Nat64),
|
|
1087
|
+
neuron_minimum_dissolve_delay_to_vote_seconds: IDL.Opt(IDL.Nat64),
|
|
1088
|
+
reject_cost_e8s: IDL.Opt(IDL.Nat64),
|
|
1089
|
+
max_proposals_to_keep_per_action: IDL.Opt(IDL.Nat32),
|
|
1090
|
+
wait_for_quiet_deadline_increase_seconds: IDL.Opt(IDL.Nat64),
|
|
1091
|
+
max_number_of_neurons: IDL.Opt(IDL.Nat64),
|
|
1092
|
+
transaction_fee_e8s: IDL.Opt(IDL.Nat64),
|
|
1093
|
+
max_number_of_proposals_with_ballots: IDL.Opt(IDL.Nat64),
|
|
1094
|
+
max_age_bonus_percentage: IDL.Opt(IDL.Nat64),
|
|
1095
|
+
neuron_grantable_permissions: IDL.Opt(NeuronPermissionList),
|
|
1096
|
+
voting_rewards_parameters: IDL.Opt(VotingRewardsParameters),
|
|
1097
|
+
maturity_modulation_disabled: IDL.Opt(IDL.Bool),
|
|
1098
|
+
max_number_of_principals_per_neuron: IDL.Opt(IDL.Nat64),
|
|
1108
1099
|
});
|
|
1109
1100
|
const RewardEvent = IDL.Record({
|
|
1110
|
-
|
|
1111
|
-
|
|
1112
|
-
|
|
1113
|
-
|
|
1114
|
-
|
|
1115
|
-
|
|
1116
|
-
|
|
1101
|
+
rounds_since_last_distribution: IDL.Opt(IDL.Nat64),
|
|
1102
|
+
actual_timestamp_seconds: IDL.Nat64,
|
|
1103
|
+
end_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
1104
|
+
total_available_e8s_equivalent: IDL.Opt(IDL.Nat64),
|
|
1105
|
+
distributed_e8s_equivalent: IDL.Nat64,
|
|
1106
|
+
round: IDL.Nat64,
|
|
1107
|
+
settled_proposals: IDL.Vec(ProposalId),
|
|
1117
1108
|
});
|
|
1118
1109
|
const PendingVersion = IDL.Record({
|
|
1119
|
-
|
|
1120
|
-
|
|
1121
|
-
|
|
1122
|
-
|
|
1110
|
+
mark_failed_at_seconds: IDL.Nat64,
|
|
1111
|
+
checking_upgrade_lock: IDL.Nat64,
|
|
1112
|
+
proposal_id: IDL.Opt(IDL.Nat64),
|
|
1113
|
+
target_version: IDL.Opt(Version),
|
|
1123
1114
|
});
|
|
1124
1115
|
const GovernanceError = IDL.Record({
|
|
1125
|
-
|
|
1126
|
-
|
|
1116
|
+
error_message: IDL.Text,
|
|
1117
|
+
error_type: IDL.Int32,
|
|
1127
1118
|
});
|
|
1128
|
-
const Decimal = IDL.Record({
|
|
1129
|
-
const Tokens = IDL.Record({
|
|
1119
|
+
const Decimal = IDL.Record({ human_readable: IDL.Opt(IDL.Text) });
|
|
1120
|
+
const Tokens = IDL.Record({ e8s: IDL.Opt(IDL.Nat64) });
|
|
1130
1121
|
const ValuationFactors = IDL.Record({
|
|
1131
|
-
|
|
1132
|
-
|
|
1133
|
-
|
|
1122
|
+
xdrs_per_icp: IDL.Opt(Decimal),
|
|
1123
|
+
icps_per_token: IDL.Opt(Decimal),
|
|
1124
|
+
tokens: IDL.Opt(Tokens),
|
|
1134
1125
|
});
|
|
1135
1126
|
const Valuation = IDL.Record({
|
|
1136
|
-
|
|
1137
|
-
|
|
1138
|
-
|
|
1139
|
-
|
|
1127
|
+
token: IDL.Opt(IDL.Int32),
|
|
1128
|
+
account: IDL.Opt(Account),
|
|
1129
|
+
valuation_factors: IDL.Opt(ValuationFactors),
|
|
1130
|
+
timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
1140
1131
|
});
|
|
1141
1132
|
const MintSnsTokensActionAuxiliary = IDL.Record({
|
|
1142
|
-
|
|
1133
|
+
valuation: IDL.Opt(Valuation),
|
|
1143
1134
|
});
|
|
1144
1135
|
const SnsVersion = IDL.Record({
|
|
1145
|
-
|
|
1146
|
-
|
|
1147
|
-
|
|
1148
|
-
|
|
1149
|
-
|
|
1150
|
-
|
|
1136
|
+
archive_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1137
|
+
root_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1138
|
+
swap_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1139
|
+
ledger_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1140
|
+
governance_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1141
|
+
index_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1151
1142
|
});
|
|
1152
1143
|
const AdvanceSnsTargetVersionActionAuxiliary = IDL.Record({
|
|
1153
|
-
|
|
1144
|
+
target_version: IDL.Opt(SnsVersion),
|
|
1154
1145
|
});
|
|
1155
1146
|
const ActionAuxiliary = IDL.Variant({
|
|
1156
|
-
|
|
1157
|
-
|
|
1158
|
-
|
|
1147
|
+
TransferSnsTreasuryFunds: MintSnsTokensActionAuxiliary,
|
|
1148
|
+
MintSnsTokens: MintSnsTokensActionAuxiliary,
|
|
1149
|
+
AdvanceSnsTargetVersion: AdvanceSnsTargetVersionActionAuxiliary,
|
|
1159
1150
|
});
|
|
1160
1151
|
const Ballot = IDL.Record({
|
|
1161
|
-
|
|
1162
|
-
|
|
1163
|
-
|
|
1152
|
+
vote: IDL.Int32,
|
|
1153
|
+
cast_timestamp_seconds: IDL.Nat64,
|
|
1154
|
+
voting_power: IDL.Nat64,
|
|
1164
1155
|
});
|
|
1165
|
-
const Percentage = IDL.Record({
|
|
1156
|
+
const Percentage = IDL.Record({ basis_points: IDL.Opt(IDL.Nat64) });
|
|
1166
1157
|
const Tally = IDL.Record({
|
|
1167
|
-
|
|
1168
|
-
|
|
1169
|
-
|
|
1170
|
-
|
|
1158
|
+
no: IDL.Nat64,
|
|
1159
|
+
yes: IDL.Nat64,
|
|
1160
|
+
total: IDL.Nat64,
|
|
1161
|
+
timestamp_seconds: IDL.Nat64,
|
|
1171
1162
|
});
|
|
1172
1163
|
const ManageDappCanisterSettings = IDL.Record({
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
|
|
1164
|
+
freezing_threshold: IDL.Opt(IDL.Nat64),
|
|
1165
|
+
wasm_memory_threshold: IDL.Opt(IDL.Nat64),
|
|
1166
|
+
canister_ids: IDL.Vec(IDL.Principal),
|
|
1167
|
+
reserved_cycles_limit: IDL.Opt(IDL.Nat64),
|
|
1168
|
+
log_visibility: IDL.Opt(IDL.Int32),
|
|
1169
|
+
wasm_memory_limit: IDL.Opt(IDL.Nat64),
|
|
1170
|
+
memory_allocation: IDL.Opt(IDL.Nat64),
|
|
1171
|
+
compute_allocation: IDL.Opt(IDL.Nat64),
|
|
1181
1172
|
});
|
|
1182
1173
|
PreciseValue.fill(
|
|
1183
1174
|
IDL.Variant({
|
|
1184
|
-
|
|
1185
|
-
|
|
1186
|
-
|
|
1187
|
-
|
|
1188
|
-
|
|
1189
|
-
|
|
1190
|
-
|
|
1191
|
-
})
|
|
1175
|
+
Int: IDL.Int64,
|
|
1176
|
+
Map: IDL.Vec(IDL.Tuple(IDL.Text, PreciseValue)),
|
|
1177
|
+
Nat: IDL.Nat64,
|
|
1178
|
+
Blob: IDL.Vec(IDL.Nat8),
|
|
1179
|
+
Bool: IDL.Bool,
|
|
1180
|
+
Text: IDL.Text,
|
|
1181
|
+
Array: IDL.Vec(PreciseValue),
|
|
1182
|
+
}),
|
|
1192
1183
|
);
|
|
1193
|
-
const ExtensionOperationArg = IDL.Record({
|
|
1184
|
+
const ExtensionOperationArg = IDL.Record({ value: IDL.Opt(PreciseValue) });
|
|
1194
1185
|
const ExecuteExtensionOperation = IDL.Record({
|
|
1195
|
-
|
|
1196
|
-
|
|
1197
|
-
|
|
1186
|
+
extension_canister_id: IDL.Opt(IDL.Principal),
|
|
1187
|
+
operation_name: IDL.Opt(IDL.Text),
|
|
1188
|
+
operation_arg: IDL.Opt(ExtensionOperationArg),
|
|
1198
1189
|
});
|
|
1199
1190
|
const ChunkedCanisterWasm = IDL.Record({
|
|
1200
|
-
|
|
1201
|
-
|
|
1202
|
-
|
|
1191
|
+
wasm_module_hash: IDL.Vec(IDL.Nat8),
|
|
1192
|
+
chunk_hashes_list: IDL.Vec(IDL.Vec(IDL.Nat8)),
|
|
1193
|
+
store_canister_id: IDL.Opt(IDL.Principal),
|
|
1203
1194
|
});
|
|
1204
1195
|
const Wasm = IDL.Variant({
|
|
1205
|
-
|
|
1206
|
-
|
|
1196
|
+
Chunked: ChunkedCanisterWasm,
|
|
1197
|
+
Bytes: IDL.Vec(IDL.Nat8),
|
|
1207
1198
|
});
|
|
1208
|
-
const ExtensionUpgradeArg = IDL.Record({
|
|
1199
|
+
const ExtensionUpgradeArg = IDL.Record({ value: IDL.Opt(PreciseValue) });
|
|
1209
1200
|
const UpgradeExtension = IDL.Record({
|
|
1210
|
-
|
|
1211
|
-
|
|
1212
|
-
|
|
1201
|
+
extension_canister_id: IDL.Opt(IDL.Principal),
|
|
1202
|
+
wasm: IDL.Opt(Wasm),
|
|
1203
|
+
canister_upgrade_arg: IDL.Opt(ExtensionUpgradeArg),
|
|
1213
1204
|
});
|
|
1214
1205
|
const SetTopicsForCustomProposals = IDL.Record({
|
|
1215
|
-
|
|
1206
|
+
custom_function_id_to_topic: IDL.Vec(IDL.Tuple(IDL.Nat64, Topic)),
|
|
1216
1207
|
});
|
|
1217
|
-
const ExtensionInit = IDL.Record({
|
|
1208
|
+
const ExtensionInit = IDL.Record({ value: IDL.Opt(PreciseValue) });
|
|
1218
1209
|
const RegisterExtension = IDL.Record({
|
|
1219
|
-
|
|
1220
|
-
|
|
1210
|
+
chunked_canister_wasm: IDL.Opt(ChunkedCanisterWasm),
|
|
1211
|
+
extension_init: IDL.Opt(ExtensionInit),
|
|
1221
1212
|
});
|
|
1222
1213
|
const RegisterDappCanisters = IDL.Record({
|
|
1223
|
-
|
|
1214
|
+
canister_ids: IDL.Vec(IDL.Principal),
|
|
1224
1215
|
});
|
|
1225
1216
|
const TransferSnsTreasuryFunds = IDL.Record({
|
|
1226
|
-
|
|
1227
|
-
|
|
1228
|
-
|
|
1229
|
-
|
|
1230
|
-
|
|
1217
|
+
from_treasury: IDL.Int32,
|
|
1218
|
+
to_principal: IDL.Opt(IDL.Principal),
|
|
1219
|
+
to_subaccount: IDL.Opt(Subaccount),
|
|
1220
|
+
memo: IDL.Opt(IDL.Nat64),
|
|
1221
|
+
amount_e8s: IDL.Nat64,
|
|
1231
1222
|
});
|
|
1232
1223
|
const UpgradeSnsControlledCanister = IDL.Record({
|
|
1233
|
-
|
|
1234
|
-
|
|
1235
|
-
|
|
1236
|
-
|
|
1237
|
-
|
|
1224
|
+
new_canister_wasm: IDL.Vec(IDL.Nat8),
|
|
1225
|
+
mode: IDL.Opt(IDL.Int32),
|
|
1226
|
+
canister_id: IDL.Opt(IDL.Principal),
|
|
1227
|
+
chunked_canister_wasm: IDL.Opt(ChunkedCanisterWasm),
|
|
1228
|
+
canister_upgrade_arg: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1238
1229
|
});
|
|
1239
1230
|
const DeregisterDappCanisters = IDL.Record({
|
|
1240
|
-
|
|
1241
|
-
|
|
1231
|
+
canister_ids: IDL.Vec(IDL.Principal),
|
|
1232
|
+
new_controllers: IDL.Vec(IDL.Principal),
|
|
1242
1233
|
});
|
|
1243
1234
|
const MintSnsTokens = IDL.Record({
|
|
1244
|
-
|
|
1245
|
-
|
|
1246
|
-
|
|
1247
|
-
|
|
1235
|
+
to_principal: IDL.Opt(IDL.Principal),
|
|
1236
|
+
to_subaccount: IDL.Opt(Subaccount),
|
|
1237
|
+
memo: IDL.Opt(IDL.Nat64),
|
|
1238
|
+
amount_e8s: IDL.Opt(IDL.Nat64),
|
|
1248
1239
|
});
|
|
1249
1240
|
const AdvanceSnsTargetVersion = IDL.Record({
|
|
1250
|
-
|
|
1241
|
+
new_target: IDL.Opt(SnsVersion),
|
|
1251
1242
|
});
|
|
1252
1243
|
const ManageSnsMetadata = IDL.Record({
|
|
1253
|
-
|
|
1254
|
-
|
|
1255
|
-
|
|
1256
|
-
|
|
1244
|
+
url: IDL.Opt(IDL.Text),
|
|
1245
|
+
logo: IDL.Opt(IDL.Text),
|
|
1246
|
+
name: IDL.Opt(IDL.Text),
|
|
1247
|
+
description: IDL.Opt(IDL.Text),
|
|
1257
1248
|
});
|
|
1258
1249
|
const ExecuteGenericNervousSystemFunction = IDL.Record({
|
|
1259
|
-
|
|
1260
|
-
|
|
1250
|
+
function_id: IDL.Nat64,
|
|
1251
|
+
payload: IDL.Vec(IDL.Nat8),
|
|
1261
1252
|
});
|
|
1262
1253
|
const ManageLedgerParameters = IDL.Record({
|
|
1263
|
-
|
|
1264
|
-
|
|
1265
|
-
|
|
1266
|
-
|
|
1254
|
+
token_symbol: IDL.Opt(IDL.Text),
|
|
1255
|
+
transfer_fee: IDL.Opt(IDL.Nat64),
|
|
1256
|
+
token_logo: IDL.Opt(IDL.Text),
|
|
1257
|
+
token_name: IDL.Opt(IDL.Text),
|
|
1267
1258
|
});
|
|
1268
|
-
const Motion = IDL.Record({
|
|
1259
|
+
const Motion = IDL.Record({ motion_text: IDL.Text });
|
|
1269
1260
|
const Action = IDL.Variant({
|
|
1270
|
-
|
|
1271
|
-
|
|
1272
|
-
|
|
1273
|
-
|
|
1274
|
-
|
|
1275
|
-
|
|
1276
|
-
|
|
1277
|
-
|
|
1278
|
-
|
|
1279
|
-
|
|
1280
|
-
|
|
1281
|
-
|
|
1282
|
-
|
|
1283
|
-
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
|
|
1287
|
-
|
|
1288
|
-
|
|
1289
|
-
|
|
1261
|
+
ManageNervousSystemParameters: NervousSystemParameters,
|
|
1262
|
+
AddGenericNervousSystemFunction: NervousSystemFunction,
|
|
1263
|
+
ManageDappCanisterSettings: ManageDappCanisterSettings,
|
|
1264
|
+
ExecuteExtensionOperation: ExecuteExtensionOperation,
|
|
1265
|
+
UpgradeExtension: UpgradeExtension,
|
|
1266
|
+
RemoveGenericNervousSystemFunction: IDL.Nat64,
|
|
1267
|
+
SetTopicsForCustomProposals: SetTopicsForCustomProposals,
|
|
1268
|
+
RegisterExtension: RegisterExtension,
|
|
1269
|
+
UpgradeSnsToNextVersion: IDL.Record({}),
|
|
1270
|
+
RegisterDappCanisters: RegisterDappCanisters,
|
|
1271
|
+
TransferSnsTreasuryFunds: TransferSnsTreasuryFunds,
|
|
1272
|
+
UpgradeSnsControlledCanister: UpgradeSnsControlledCanister,
|
|
1273
|
+
DeregisterDappCanisters: DeregisterDappCanisters,
|
|
1274
|
+
MintSnsTokens: MintSnsTokens,
|
|
1275
|
+
AdvanceSnsTargetVersion: AdvanceSnsTargetVersion,
|
|
1276
|
+
Unspecified: IDL.Record({}),
|
|
1277
|
+
ManageSnsMetadata: ManageSnsMetadata,
|
|
1278
|
+
ExecuteGenericNervousSystemFunction: ExecuteGenericNervousSystemFunction,
|
|
1279
|
+
ManageLedgerParameters: ManageLedgerParameters,
|
|
1280
|
+
Motion: Motion,
|
|
1290
1281
|
});
|
|
1291
1282
|
const Proposal = IDL.Record({
|
|
1292
|
-
|
|
1293
|
-
|
|
1294
|
-
|
|
1295
|
-
|
|
1283
|
+
url: IDL.Text,
|
|
1284
|
+
title: IDL.Text,
|
|
1285
|
+
action: IDL.Opt(Action),
|
|
1286
|
+
summary: IDL.Text,
|
|
1296
1287
|
});
|
|
1297
1288
|
const WaitForQuietState = IDL.Record({
|
|
1298
|
-
|
|
1289
|
+
current_deadline_timestamp_seconds: IDL.Nat64,
|
|
1299
1290
|
});
|
|
1300
1291
|
const ProposalData = IDL.Record({
|
|
1301
|
-
|
|
1302
|
-
|
|
1303
|
-
|
|
1304
|
-
|
|
1305
|
-
|
|
1306
|
-
|
|
1307
|
-
|
|
1308
|
-
|
|
1309
|
-
|
|
1310
|
-
|
|
1311
|
-
|
|
1312
|
-
|
|
1313
|
-
|
|
1314
|
-
|
|
1315
|
-
|
|
1316
|
-
|
|
1317
|
-
|
|
1318
|
-
|
|
1319
|
-
|
|
1320
|
-
|
|
1321
|
-
|
|
1322
|
-
|
|
1323
|
-
|
|
1324
|
-
});
|
|
1325
|
-
const Split = IDL.Record({
|
|
1292
|
+
id: IDL.Opt(ProposalId),
|
|
1293
|
+
payload_text_rendering: IDL.Opt(IDL.Text),
|
|
1294
|
+
topic: IDL.Opt(Topic),
|
|
1295
|
+
action: IDL.Nat64,
|
|
1296
|
+
failure_reason: IDL.Opt(GovernanceError),
|
|
1297
|
+
action_auxiliary: IDL.Opt(ActionAuxiliary),
|
|
1298
|
+
ballots: IDL.Vec(IDL.Tuple(IDL.Text, Ballot)),
|
|
1299
|
+
minimum_yes_proportion_of_total: IDL.Opt(Percentage),
|
|
1300
|
+
reward_event_round: IDL.Nat64,
|
|
1301
|
+
failed_timestamp_seconds: IDL.Nat64,
|
|
1302
|
+
reward_event_end_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
1303
|
+
proposal_creation_timestamp_seconds: IDL.Nat64,
|
|
1304
|
+
initial_voting_period_seconds: IDL.Nat64,
|
|
1305
|
+
reject_cost_e8s: IDL.Nat64,
|
|
1306
|
+
latest_tally: IDL.Opt(Tally),
|
|
1307
|
+
wait_for_quiet_deadline_increase_seconds: IDL.Nat64,
|
|
1308
|
+
decided_timestamp_seconds: IDL.Nat64,
|
|
1309
|
+
proposal: IDL.Opt(Proposal),
|
|
1310
|
+
proposer: IDL.Opt(NeuronId),
|
|
1311
|
+
wait_for_quiet_state: IDL.Opt(WaitForQuietState),
|
|
1312
|
+
minimum_yes_proportion_of_exercised: IDL.Opt(Percentage),
|
|
1313
|
+
is_eligible_for_rewards: IDL.Bool,
|
|
1314
|
+
executed_timestamp_seconds: IDL.Nat64,
|
|
1315
|
+
});
|
|
1316
|
+
const Split = IDL.Record({ memo: IDL.Nat64, amount_e8s: IDL.Nat64 });
|
|
1326
1317
|
const Follow = IDL.Record({
|
|
1327
|
-
|
|
1328
|
-
|
|
1318
|
+
function_id: IDL.Nat64,
|
|
1319
|
+
followees: IDL.Vec(NeuronId),
|
|
1329
1320
|
});
|
|
1330
1321
|
const DisburseMaturity = IDL.Record({
|
|
1331
|
-
|
|
1332
|
-
|
|
1322
|
+
to_account: IDL.Opt(Account),
|
|
1323
|
+
percentage_to_disburse: IDL.Nat32,
|
|
1333
1324
|
});
|
|
1334
1325
|
const ChangeAutoStakeMaturity = IDL.Record({
|
|
1335
|
-
|
|
1326
|
+
requested_setting_for_auto_stake_maturity: IDL.Bool,
|
|
1336
1327
|
});
|
|
1337
1328
|
const IncreaseDissolveDelay = IDL.Record({
|
|
1338
|
-
|
|
1329
|
+
additional_dissolve_delay_seconds: IDL.Nat32,
|
|
1339
1330
|
});
|
|
1340
1331
|
const SetDissolveTimestamp = IDL.Record({
|
|
1341
|
-
|
|
1332
|
+
dissolve_timestamp_seconds: IDL.Nat64,
|
|
1342
1333
|
});
|
|
1343
1334
|
const Operation = IDL.Variant({
|
|
1344
|
-
|
|
1345
|
-
|
|
1346
|
-
|
|
1347
|
-
|
|
1348
|
-
|
|
1335
|
+
ChangeAutoStakeMaturity: ChangeAutoStakeMaturity,
|
|
1336
|
+
StopDissolving: IDL.Record({}),
|
|
1337
|
+
StartDissolving: IDL.Record({}),
|
|
1338
|
+
IncreaseDissolveDelay: IncreaseDissolveDelay,
|
|
1339
|
+
SetDissolveTimestamp: SetDissolveTimestamp,
|
|
1349
1340
|
});
|
|
1350
|
-
const Configure = IDL.Record({
|
|
1341
|
+
const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
|
|
1351
1342
|
const RegisterVote = IDL.Record({
|
|
1352
|
-
|
|
1353
|
-
|
|
1343
|
+
vote: IDL.Int32,
|
|
1344
|
+
proposal: IDL.Opt(ProposalId),
|
|
1354
1345
|
});
|
|
1355
1346
|
const Followee = IDL.Record({
|
|
1356
|
-
|
|
1357
|
-
|
|
1347
|
+
alias: IDL.Opt(IDL.Text),
|
|
1348
|
+
neuron_id: IDL.Opt(NeuronId),
|
|
1358
1349
|
});
|
|
1359
1350
|
const FolloweesForTopic = IDL.Record({
|
|
1360
|
-
|
|
1361
|
-
|
|
1351
|
+
topic: IDL.Opt(Topic),
|
|
1352
|
+
followees: IDL.Vec(Followee),
|
|
1362
1353
|
});
|
|
1363
1354
|
const SetFollowing = IDL.Record({
|
|
1364
|
-
|
|
1355
|
+
topic_following: IDL.Vec(FolloweesForTopic),
|
|
1365
1356
|
});
|
|
1366
1357
|
const FinalizeDisburseMaturity = IDL.Record({
|
|
1367
|
-
|
|
1368
|
-
|
|
1358
|
+
amount_to_be_disbursed_e8s: IDL.Nat64,
|
|
1359
|
+
to_account: IDL.Opt(Account),
|
|
1369
1360
|
});
|
|
1370
1361
|
const MemoAndController = IDL.Record({
|
|
1371
|
-
|
|
1372
|
-
|
|
1362
|
+
controller: IDL.Opt(IDL.Principal),
|
|
1363
|
+
memo: IDL.Nat64,
|
|
1373
1364
|
});
|
|
1374
1365
|
const By = IDL.Variant({
|
|
1375
|
-
|
|
1376
|
-
|
|
1366
|
+
MemoAndController: MemoAndController,
|
|
1367
|
+
NeuronId: IDL.Record({}),
|
|
1377
1368
|
});
|
|
1378
|
-
const ClaimOrRefresh = IDL.Record({
|
|
1369
|
+
const ClaimOrRefresh = IDL.Record({ by: IDL.Opt(By) });
|
|
1379
1370
|
const RemoveNeuronPermissions = IDL.Record({
|
|
1380
|
-
|
|
1381
|
-
|
|
1371
|
+
permissions_to_remove: IDL.Opt(NeuronPermissionList),
|
|
1372
|
+
principal_id: IDL.Opt(IDL.Principal),
|
|
1382
1373
|
});
|
|
1383
1374
|
const AddNeuronPermissions = IDL.Record({
|
|
1384
|
-
|
|
1385
|
-
|
|
1375
|
+
permissions_to_add: IDL.Opt(NeuronPermissionList),
|
|
1376
|
+
principal_id: IDL.Opt(IDL.Principal),
|
|
1386
1377
|
});
|
|
1387
|
-
const MergeMaturity = IDL.Record({
|
|
1388
|
-
const Amount = IDL.Record({
|
|
1378
|
+
const MergeMaturity = IDL.Record({ percentage_to_merge: IDL.Nat32 });
|
|
1379
|
+
const Amount = IDL.Record({ e8s: IDL.Nat64 });
|
|
1389
1380
|
const Disburse = IDL.Record({
|
|
1390
|
-
|
|
1391
|
-
|
|
1381
|
+
to_account: IDL.Opt(Account),
|
|
1382
|
+
amount: IDL.Opt(Amount),
|
|
1392
1383
|
});
|
|
1393
1384
|
const Command_2 = IDL.Variant({
|
|
1394
|
-
|
|
1395
|
-
|
|
1396
|
-
|
|
1397
|
-
|
|
1398
|
-
|
|
1399
|
-
|
|
1400
|
-
|
|
1401
|
-
|
|
1402
|
-
|
|
1403
|
-
|
|
1404
|
-
|
|
1405
|
-
|
|
1406
|
-
|
|
1407
|
-
|
|
1385
|
+
Split: Split,
|
|
1386
|
+
Follow: Follow,
|
|
1387
|
+
DisburseMaturity: DisburseMaturity,
|
|
1388
|
+
Configure: Configure,
|
|
1389
|
+
RegisterVote: RegisterVote,
|
|
1390
|
+
SetFollowing: SetFollowing,
|
|
1391
|
+
SyncCommand: IDL.Record({}),
|
|
1392
|
+
MakeProposal: Proposal,
|
|
1393
|
+
FinalizeDisburseMaturity: FinalizeDisburseMaturity,
|
|
1394
|
+
ClaimOrRefreshNeuron: ClaimOrRefresh,
|
|
1395
|
+
RemoveNeuronPermissions: RemoveNeuronPermissions,
|
|
1396
|
+
AddNeuronPermissions: AddNeuronPermissions,
|
|
1397
|
+
MergeMaturity: MergeMaturity,
|
|
1398
|
+
Disburse: Disburse,
|
|
1408
1399
|
});
|
|
1409
1400
|
const NeuronInFlightCommand = IDL.Record({
|
|
1410
|
-
|
|
1411
|
-
|
|
1401
|
+
command: IDL.Opt(Command_2),
|
|
1402
|
+
timestamp: IDL.Nat64,
|
|
1412
1403
|
});
|
|
1413
1404
|
const NeuronPermission = IDL.Record({
|
|
1414
|
-
|
|
1415
|
-
|
|
1405
|
+
principal: IDL.Opt(IDL.Principal),
|
|
1406
|
+
permission_type: IDL.Vec(IDL.Int32),
|
|
1416
1407
|
});
|
|
1417
1408
|
const DissolveState = IDL.Variant({
|
|
1418
|
-
|
|
1419
|
-
|
|
1409
|
+
DissolveDelaySeconds: IDL.Nat64,
|
|
1410
|
+
WhenDissolvedTimestampSeconds: IDL.Nat64,
|
|
1420
1411
|
});
|
|
1421
1412
|
const DisburseMaturityInProgress = IDL.Record({
|
|
1422
|
-
|
|
1423
|
-
|
|
1424
|
-
|
|
1425
|
-
|
|
1413
|
+
timestamp_of_disbursement_seconds: IDL.Nat64,
|
|
1414
|
+
amount_e8s: IDL.Nat64,
|
|
1415
|
+
account_to_disburse_to: IDL.Opt(Account),
|
|
1416
|
+
finalize_disbursement_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
1426
1417
|
});
|
|
1427
1418
|
const Neuron = IDL.Record({
|
|
1428
|
-
|
|
1429
|
-
|
|
1430
|
-
|
|
1431
|
-
|
|
1432
|
-
|
|
1433
|
-
|
|
1434
|
-
|
|
1419
|
+
id: IDL.Opt(NeuronId),
|
|
1420
|
+
staked_maturity_e8s_equivalent: IDL.Opt(IDL.Nat64),
|
|
1421
|
+
permissions: IDL.Vec(NeuronPermission),
|
|
1422
|
+
maturity_e8s_equivalent: IDL.Nat64,
|
|
1423
|
+
cached_neuron_stake_e8s: IDL.Nat64,
|
|
1424
|
+
created_timestamp_seconds: IDL.Nat64,
|
|
1425
|
+
topic_followees: IDL.Opt(
|
|
1435
1426
|
IDL.Record({
|
|
1436
|
-
|
|
1437
|
-
|
|
1438
|
-
),
|
|
1439
|
-
})
|
|
1427
|
+
topic_id_to_followees: IDL.Vec(IDL.Tuple(IDL.Int32, FolloweesForTopic)),
|
|
1428
|
+
}),
|
|
1440
1429
|
),
|
|
1441
|
-
|
|
1442
|
-
|
|
1443
|
-
|
|
1444
|
-
|
|
1445
|
-
|
|
1446
|
-
|
|
1447
|
-
|
|
1448
|
-
|
|
1449
|
-
|
|
1430
|
+
source_nns_neuron_id: IDL.Opt(IDL.Nat64),
|
|
1431
|
+
auto_stake_maturity: IDL.Opt(IDL.Bool),
|
|
1432
|
+
aging_since_timestamp_seconds: IDL.Nat64,
|
|
1433
|
+
dissolve_state: IDL.Opt(DissolveState),
|
|
1434
|
+
voting_power_percentage_multiplier: IDL.Nat64,
|
|
1435
|
+
vesting_period_seconds: IDL.Opt(IDL.Nat64),
|
|
1436
|
+
disburse_maturity_in_progress: IDL.Vec(DisburseMaturityInProgress),
|
|
1437
|
+
followees: IDL.Vec(IDL.Tuple(IDL.Nat64, Followees)),
|
|
1438
|
+
neuron_fees_e8s: IDL.Nat64,
|
|
1450
1439
|
});
|
|
1451
1440
|
const Governance = IDL.Record({
|
|
1452
|
-
|
|
1453
|
-
|
|
1454
|
-
|
|
1455
|
-
|
|
1456
|
-
IDL.Tuple(IDL.Nat64, NervousSystemFunction)
|
|
1441
|
+
root_canister_id: IDL.Opt(IDL.Principal),
|
|
1442
|
+
timers: IDL.Opt(Timers),
|
|
1443
|
+
cached_upgrade_steps: IDL.Opt(CachedUpgradeSteps),
|
|
1444
|
+
id_to_nervous_system_functions: IDL.Vec(
|
|
1445
|
+
IDL.Tuple(IDL.Nat64, NervousSystemFunction),
|
|
1457
1446
|
),
|
|
1458
|
-
|
|
1459
|
-
|
|
1460
|
-
|
|
1461
|
-
|
|
1462
|
-
|
|
1463
|
-
|
|
1464
|
-
|
|
1465
|
-
|
|
1466
|
-
|
|
1467
|
-
|
|
1468
|
-
|
|
1469
|
-
|
|
1470
|
-
|
|
1471
|
-
|
|
1472
|
-
|
|
1473
|
-
|
|
1474
|
-
|
|
1475
|
-
|
|
1476
|
-
});
|
|
1447
|
+
metrics: IDL.Opt(GovernanceCachedMetrics),
|
|
1448
|
+
maturity_modulation: IDL.Opt(MaturityModulation),
|
|
1449
|
+
upgrade_journal: IDL.Opt(UpgradeJournal),
|
|
1450
|
+
mode: IDL.Int32,
|
|
1451
|
+
parameters: IDL.Opt(NervousSystemParameters),
|
|
1452
|
+
is_finalizing_disburse_maturity: IDL.Opt(IDL.Bool),
|
|
1453
|
+
deployed_version: IDL.Opt(Version),
|
|
1454
|
+
sns_initialization_parameters: IDL.Text,
|
|
1455
|
+
latest_reward_event: IDL.Opt(RewardEvent),
|
|
1456
|
+
pending_version: IDL.Opt(PendingVersion),
|
|
1457
|
+
swap_canister_id: IDL.Opt(IDL.Principal),
|
|
1458
|
+
ledger_canister_id: IDL.Opt(IDL.Principal),
|
|
1459
|
+
proposals: IDL.Vec(IDL.Tuple(IDL.Nat64, ProposalData)),
|
|
1460
|
+
in_flight_commands: IDL.Vec(IDL.Tuple(IDL.Text, NeuronInFlightCommand)),
|
|
1461
|
+
sns_metadata: IDL.Opt(ManageSnsMetadata),
|
|
1462
|
+
neurons: IDL.Vec(IDL.Tuple(IDL.Text, Neuron)),
|
|
1463
|
+
target_version: IDL.Opt(Version),
|
|
1464
|
+
genesis_timestamp_seconds: IDL.Nat64,
|
|
1465
|
+
});
|
|
1466
|
+
|
|
1477
1467
|
return [Governance];
|
|
1478
1468
|
};
|