@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,1462 +1,1460 @@
|
|
|
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
|
-
|
|
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], []),
|
|
845
|
+
get_latest_reward_event: IDL.Func([], [RewardEvent], []),
|
|
846
|
+
get_maturity_modulation: IDL.Func(
|
|
847
|
+
[IDL.Record({})],
|
|
848
|
+
[GetMaturityModulationResponse],
|
|
849
|
+
[],
|
|
850
|
+
),
|
|
851
|
+
get_metadata: IDL.Func([IDL.Record({})], [GetMetadataResponse], []),
|
|
852
|
+
get_metrics: IDL.Func([GetMetricsRequest], [GetMetricsResponse], []),
|
|
853
|
+
get_metrics_replicated: IDL.Func(
|
|
854
|
+
[GetMetricsRequest],
|
|
855
|
+
[GetMetricsResponse],
|
|
856
|
+
[],
|
|
857
|
+
),
|
|
858
|
+
get_mode: IDL.Func([IDL.Record({})], [GetModeResponse], []),
|
|
859
|
+
get_nervous_system_parameters: IDL.Func(
|
|
860
|
+
[IDL.Null],
|
|
861
|
+
[NervousSystemParameters],
|
|
862
|
+
[],
|
|
863
|
+
),
|
|
864
|
+
get_neuron: IDL.Func([GetNeuron], [GetNeuronResponse], []),
|
|
865
|
+
get_proposal: IDL.Func([GetProposal], [GetProposalResponse], []),
|
|
866
|
+
get_root_canister_status: IDL.Func(
|
|
867
|
+
[IDL.Null],
|
|
868
|
+
[CanisterStatusResultV2],
|
|
869
|
+
[],
|
|
870
|
+
),
|
|
871
|
+
get_running_sns_version: IDL.Func(
|
|
872
|
+
[IDL.Record({})],
|
|
873
|
+
[GetRunningSnsVersionResponse],
|
|
874
|
+
[],
|
|
875
|
+
),
|
|
876
|
+
get_sns_initialization_parameters: IDL.Func(
|
|
877
|
+
[IDL.Record({})],
|
|
878
|
+
[GetSnsInitializationParametersResponse],
|
|
879
|
+
[],
|
|
880
|
+
),
|
|
881
|
+
get_timers: IDL.Func([IDL.Record({})], [GetTimersResponse], []),
|
|
882
|
+
get_upgrade_journal: IDL.Func(
|
|
883
|
+
[GetUpgradeJournalRequest],
|
|
884
|
+
[GetUpgradeJournalResponse],
|
|
885
|
+
[],
|
|
886
|
+
),
|
|
887
|
+
list_nervous_system_functions: IDL.Func(
|
|
888
|
+
[],
|
|
889
|
+
[ListNervousSystemFunctionsResponse],
|
|
890
|
+
[],
|
|
891
|
+
),
|
|
892
|
+
list_neurons: IDL.Func([ListNeurons], [ListNeuronsResponse], []),
|
|
893
|
+
list_proposals: IDL.Func([ListProposals], [ListProposalsResponse], []),
|
|
894
|
+
list_topics: IDL.Func([ListTopicsRequest], [ListTopicsResponse], []),
|
|
895
|
+
manage_neuron: IDL.Func([ManageNeuron], [ManageNeuronResponse], []),
|
|
896
|
+
mint_tokens: IDL.Func([MintTokensRequest], [IDL.Record({})], []),
|
|
897
|
+
refresh_cached_upgrade_steps: IDL.Func(
|
|
898
|
+
[IDL.Record({})],
|
|
899
|
+
[IDL.Record({})],
|
|
900
|
+
[],
|
|
901
|
+
),
|
|
902
|
+
reset_timers: IDL.Func([IDL.Record({})], [IDL.Record({})], []),
|
|
903
|
+
set_mode: IDL.Func([SetMode], [IDL.Record({})], []),
|
|
904
|
+
update_neuron: IDL.Func([Neuron], [IDL.Opt(GovernanceError)], []),
|
|
903
905
|
});
|
|
904
906
|
};
|
|
907
|
+
|
|
905
908
|
export const init = ({ IDL }) => {
|
|
906
909
|
const PreciseValue = IDL.Rec();
|
|
907
910
|
const Timers = IDL.Record({
|
|
908
|
-
|
|
909
|
-
|
|
910
|
-
|
|
911
|
+
last_spawned_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
912
|
+
last_reset_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
913
|
+
requires_periodic_tasks: IDL.Opt(IDL.Bool),
|
|
911
914
|
});
|
|
912
915
|
const Version = IDL.Record({
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
|
|
916
|
-
|
|
917
|
-
|
|
918
|
-
|
|
919
|
-
});
|
|
920
|
-
const Versions = IDL.Record({
|
|
916
|
+
archive_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
917
|
+
root_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
918
|
+
swap_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
919
|
+
ledger_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
920
|
+
governance_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
921
|
+
index_wasm_hash: IDL.Vec(IDL.Nat8),
|
|
922
|
+
});
|
|
923
|
+
const Versions = IDL.Record({ versions: IDL.Vec(Version) });
|
|
921
924
|
const CachedUpgradeSteps = IDL.Record({
|
|
922
|
-
|
|
923
|
-
|
|
924
|
-
|
|
925
|
+
upgrade_steps: IDL.Opt(Versions),
|
|
926
|
+
response_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
927
|
+
requested_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
925
928
|
});
|
|
926
929
|
const Topic = IDL.Variant({
|
|
927
|
-
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
|
|
931
|
-
|
|
932
|
-
|
|
933
|
-
|
|
930
|
+
DappCanisterManagement: IDL.Null,
|
|
931
|
+
DaoCommunitySettings: IDL.Null,
|
|
932
|
+
ApplicationBusinessLogic: IDL.Null,
|
|
933
|
+
CriticalDappOperations: IDL.Null,
|
|
934
|
+
TreasuryAssetManagement: IDL.Null,
|
|
935
|
+
Governance: IDL.Null,
|
|
936
|
+
SnsFrameworkManagement: IDL.Null,
|
|
934
937
|
});
|
|
935
938
|
const GenericNervousSystemFunction = IDL.Record({
|
|
936
|
-
|
|
937
|
-
|
|
938
|
-
|
|
939
|
-
|
|
940
|
-
|
|
939
|
+
topic: IDL.Opt(Topic),
|
|
940
|
+
validator_canister_id: IDL.Opt(IDL.Principal),
|
|
941
|
+
target_canister_id: IDL.Opt(IDL.Principal),
|
|
942
|
+
validator_method_name: IDL.Opt(IDL.Text),
|
|
943
|
+
target_method_name: IDL.Opt(IDL.Text),
|
|
941
944
|
});
|
|
942
945
|
const FunctionType = IDL.Variant({
|
|
943
|
-
|
|
944
|
-
|
|
946
|
+
NativeNervousSystemFunction: IDL.Record({}),
|
|
947
|
+
GenericNervousSystemFunction: GenericNervousSystemFunction,
|
|
945
948
|
});
|
|
946
949
|
const NervousSystemFunction = IDL.Record({
|
|
947
|
-
|
|
948
|
-
|
|
949
|
-
|
|
950
|
-
|
|
950
|
+
id: IDL.Nat64,
|
|
951
|
+
name: IDL.Text,
|
|
952
|
+
description: IDL.Opt(IDL.Text),
|
|
953
|
+
function_type: IDL.Opt(FunctionType),
|
|
951
954
|
});
|
|
952
|
-
const Subaccount = IDL.Record({
|
|
955
|
+
const Subaccount = IDL.Record({ subaccount: IDL.Vec(IDL.Nat8) });
|
|
953
956
|
const Account = IDL.Record({
|
|
954
|
-
|
|
955
|
-
|
|
957
|
+
owner: IDL.Opt(IDL.Principal),
|
|
958
|
+
subaccount: IDL.Opt(Subaccount),
|
|
956
959
|
});
|
|
957
960
|
const TreasuryMetrics = IDL.Record({
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
961
|
+
name: IDL.Opt(IDL.Text),
|
|
962
|
+
original_amount_e8s: IDL.Opt(IDL.Nat64),
|
|
963
|
+
amount_e8s: IDL.Opt(IDL.Nat64),
|
|
964
|
+
account: IDL.Opt(Account),
|
|
965
|
+
ledger_canister_id: IDL.Opt(IDL.Principal),
|
|
966
|
+
treasury: IDL.Int32,
|
|
967
|
+
timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
965
968
|
});
|
|
966
969
|
const VotingPowerMetrics = IDL.Record({
|
|
967
|
-
|
|
968
|
-
|
|
970
|
+
governance_total_potential_voting_power: IDL.Opt(IDL.Nat64),
|
|
971
|
+
timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
969
972
|
});
|
|
970
973
|
const GovernanceCachedMetrics = IDL.Record({
|
|
971
|
-
|
|
972
|
-
|
|
973
|
-
IDL.Tuple(IDL.Nat64, IDL.Float64)
|
|
974
|
-
),
|
|
975
|
-
'garbage_collectable_neurons_count' : IDL.Nat64,
|
|
976
|
-
'neurons_with_invalid_stake_count' : IDL.Nat64,
|
|
977
|
-
'not_dissolving_neurons_count_buckets' : IDL.Vec(
|
|
978
|
-
IDL.Tuple(IDL.Nat64, IDL.Nat64)
|
|
974
|
+
treasury_metrics: IDL.Vec(TreasuryMetrics),
|
|
975
|
+
not_dissolving_neurons_e8s_buckets: IDL.Vec(
|
|
976
|
+
IDL.Tuple(IDL.Nat64, IDL.Float64),
|
|
979
977
|
),
|
|
980
|
-
|
|
981
|
-
|
|
982
|
-
|
|
983
|
-
|
|
984
|
-
'voting_power_metrics' : IDL.Opt(VotingPowerMetrics),
|
|
985
|
-
'not_dissolving_neurons_count' : IDL.Nat64,
|
|
986
|
-
'dissolved_neurons_e8s' : IDL.Nat64,
|
|
987
|
-
'neurons_with_less_than_6_months_dissolve_delay_e8s' : IDL.Nat64,
|
|
988
|
-
'dissolving_neurons_count_buckets' : IDL.Vec(
|
|
989
|
-
IDL.Tuple(IDL.Nat64, IDL.Nat64)
|
|
978
|
+
garbage_collectable_neurons_count: IDL.Nat64,
|
|
979
|
+
neurons_with_invalid_stake_count: IDL.Nat64,
|
|
980
|
+
not_dissolving_neurons_count_buckets: IDL.Vec(
|
|
981
|
+
IDL.Tuple(IDL.Nat64, IDL.Nat64),
|
|
990
982
|
),
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
|
|
994
|
-
|
|
995
|
-
|
|
983
|
+
neurons_with_less_than_6_months_dissolve_delay_count: IDL.Nat64,
|
|
984
|
+
dissolved_neurons_count: IDL.Nat64,
|
|
985
|
+
total_staked_e8s: IDL.Nat64,
|
|
986
|
+
total_supply_governance_tokens: IDL.Nat64,
|
|
987
|
+
voting_power_metrics: IDL.Opt(VotingPowerMetrics),
|
|
988
|
+
not_dissolving_neurons_count: IDL.Nat64,
|
|
989
|
+
dissolved_neurons_e8s: IDL.Nat64,
|
|
990
|
+
neurons_with_less_than_6_months_dissolve_delay_e8s: IDL.Nat64,
|
|
991
|
+
dissolving_neurons_count_buckets: IDL.Vec(IDL.Tuple(IDL.Nat64, IDL.Nat64)),
|
|
992
|
+
dissolving_neurons_count: IDL.Nat64,
|
|
993
|
+
dissolving_neurons_e8s_buckets: IDL.Vec(IDL.Tuple(IDL.Nat64, IDL.Float64)),
|
|
994
|
+
timestamp_seconds: IDL.Nat64,
|
|
996
995
|
});
|
|
997
996
|
const MaturityModulation = IDL.Record({
|
|
998
|
-
|
|
999
|
-
|
|
997
|
+
current_basis_points: IDL.Opt(IDL.Int32),
|
|
998
|
+
updated_at_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
1000
999
|
});
|
|
1001
1000
|
const TargetVersionSet = IDL.Record({
|
|
1002
|
-
|
|
1003
|
-
|
|
1004
|
-
|
|
1001
|
+
old_target_version: IDL.Opt(Version),
|
|
1002
|
+
new_target_version: IDL.Opt(Version),
|
|
1003
|
+
is_advanced_automatically: IDL.Opt(IDL.Bool),
|
|
1005
1004
|
});
|
|
1006
1005
|
const UpgradeStepsReset = IDL.Record({
|
|
1007
|
-
|
|
1008
|
-
|
|
1006
|
+
human_readable: IDL.Opt(IDL.Text),
|
|
1007
|
+
upgrade_steps: IDL.Opt(Versions),
|
|
1009
1008
|
});
|
|
1010
1009
|
const UpgradeOutcome = IDL.Record({
|
|
1011
|
-
|
|
1010
|
+
status: IDL.Opt(
|
|
1012
1011
|
IDL.Variant({
|
|
1013
|
-
|
|
1014
|
-
|
|
1015
|
-
|
|
1016
|
-
|
|
1017
|
-
})
|
|
1012
|
+
Success: IDL.Record({}),
|
|
1013
|
+
Timeout: IDL.Record({}),
|
|
1014
|
+
ExternalFailure: IDL.Record({}),
|
|
1015
|
+
InvalidState: IDL.Record({ version: IDL.Opt(Version) }),
|
|
1016
|
+
}),
|
|
1018
1017
|
),
|
|
1019
|
-
|
|
1018
|
+
human_readable: IDL.Opt(IDL.Text),
|
|
1020
1019
|
});
|
|
1021
|
-
const ProposalId = IDL.Record({
|
|
1020
|
+
const ProposalId = IDL.Record({ id: IDL.Nat64 });
|
|
1022
1021
|
const UpgradeStarted = IDL.Record({
|
|
1023
|
-
|
|
1024
|
-
|
|
1025
|
-
|
|
1022
|
+
current_version: IDL.Opt(Version),
|
|
1023
|
+
expected_version: IDL.Opt(Version),
|
|
1024
|
+
reason: IDL.Opt(
|
|
1026
1025
|
IDL.Variant({
|
|
1027
|
-
|
|
1028
|
-
|
|
1029
|
-
})
|
|
1026
|
+
UpgradeSnsToNextVersionProposal: ProposalId,
|
|
1027
|
+
BehindTargetVersion: IDL.Record({}),
|
|
1028
|
+
}),
|
|
1030
1029
|
),
|
|
1031
1030
|
});
|
|
1032
1031
|
const UpgradeStepsRefreshed = IDL.Record({
|
|
1033
|
-
|
|
1032
|
+
upgrade_steps: IDL.Opt(Versions),
|
|
1034
1033
|
});
|
|
1035
1034
|
const TargetVersionReset = IDL.Record({
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
|
|
1035
|
+
human_readable: IDL.Opt(IDL.Text),
|
|
1036
|
+
old_target_version: IDL.Opt(Version),
|
|
1037
|
+
new_target_version: IDL.Opt(Version),
|
|
1039
1038
|
});
|
|
1040
1039
|
const UpgradeJournalEntry = IDL.Record({
|
|
1041
|
-
|
|
1040
|
+
event: IDL.Opt(
|
|
1042
1041
|
IDL.Variant({
|
|
1043
|
-
|
|
1044
|
-
|
|
1045
|
-
|
|
1046
|
-
|
|
1047
|
-
|
|
1048
|
-
|
|
1049
|
-
})
|
|
1042
|
+
TargetVersionSet: TargetVersionSet,
|
|
1043
|
+
UpgradeStepsReset: UpgradeStepsReset,
|
|
1044
|
+
UpgradeOutcome: UpgradeOutcome,
|
|
1045
|
+
UpgradeStarted: UpgradeStarted,
|
|
1046
|
+
UpgradeStepsRefreshed: UpgradeStepsRefreshed,
|
|
1047
|
+
TargetVersionReset: TargetVersionReset,
|
|
1048
|
+
}),
|
|
1050
1049
|
),
|
|
1051
|
-
|
|
1050
|
+
timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
1052
1051
|
});
|
|
1053
1052
|
const UpgradeJournal = IDL.Record({
|
|
1054
|
-
|
|
1053
|
+
entries: IDL.Vec(UpgradeJournalEntry),
|
|
1055
1054
|
});
|
|
1056
|
-
const NeuronId = IDL.Record({
|
|
1057
|
-
const Followees = IDL.Record({
|
|
1055
|
+
const NeuronId = IDL.Record({ id: IDL.Vec(IDL.Nat8) });
|
|
1056
|
+
const Followees = IDL.Record({ followees: IDL.Vec(NeuronId) });
|
|
1058
1057
|
const DefaultFollowees = IDL.Record({
|
|
1059
|
-
|
|
1058
|
+
followees: IDL.Vec(IDL.Tuple(IDL.Nat64, Followees)),
|
|
1060
1059
|
});
|
|
1061
1060
|
const NeuronPermissionList = IDL.Record({
|
|
1062
|
-
|
|
1061
|
+
permissions: IDL.Vec(IDL.Int32),
|
|
1063
1062
|
});
|
|
1064
1063
|
const VotingRewardsParameters = IDL.Record({
|
|
1065
|
-
|
|
1066
|
-
|
|
1067
|
-
|
|
1068
|
-
|
|
1064
|
+
final_reward_rate_basis_points: IDL.Opt(IDL.Nat64),
|
|
1065
|
+
initial_reward_rate_basis_points: IDL.Opt(IDL.Nat64),
|
|
1066
|
+
reward_rate_transition_duration_seconds: IDL.Opt(IDL.Nat64),
|
|
1067
|
+
round_duration_seconds: IDL.Opt(IDL.Nat64),
|
|
1069
1068
|
});
|
|
1070
1069
|
const NervousSystemParameters = IDL.Record({
|
|
1071
|
-
|
|
1072
|
-
|
|
1073
|
-
|
|
1074
|
-
|
|
1075
|
-
|
|
1076
|
-
|
|
1077
|
-
|
|
1078
|
-
|
|
1079
|
-
|
|
1080
|
-
|
|
1081
|
-
|
|
1082
|
-
|
|
1083
|
-
|
|
1084
|
-
|
|
1085
|
-
|
|
1086
|
-
|
|
1087
|
-
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1070
|
+
default_followees: IDL.Opt(DefaultFollowees),
|
|
1071
|
+
max_dissolve_delay_seconds: IDL.Opt(IDL.Nat64),
|
|
1072
|
+
max_dissolve_delay_bonus_percentage: IDL.Opt(IDL.Nat64),
|
|
1073
|
+
max_followees_per_function: IDL.Opt(IDL.Nat64),
|
|
1074
|
+
automatically_advance_target_version: IDL.Opt(IDL.Bool),
|
|
1075
|
+
neuron_claimer_permissions: IDL.Opt(NeuronPermissionList),
|
|
1076
|
+
neuron_minimum_stake_e8s: IDL.Opt(IDL.Nat64),
|
|
1077
|
+
max_neuron_age_for_age_bonus: IDL.Opt(IDL.Nat64),
|
|
1078
|
+
initial_voting_period_seconds: IDL.Opt(IDL.Nat64),
|
|
1079
|
+
neuron_minimum_dissolve_delay_to_vote_seconds: IDL.Opt(IDL.Nat64),
|
|
1080
|
+
reject_cost_e8s: IDL.Opt(IDL.Nat64),
|
|
1081
|
+
max_proposals_to_keep_per_action: IDL.Opt(IDL.Nat32),
|
|
1082
|
+
wait_for_quiet_deadline_increase_seconds: IDL.Opt(IDL.Nat64),
|
|
1083
|
+
max_number_of_neurons: IDL.Opt(IDL.Nat64),
|
|
1084
|
+
transaction_fee_e8s: IDL.Opt(IDL.Nat64),
|
|
1085
|
+
max_number_of_proposals_with_ballots: IDL.Opt(IDL.Nat64),
|
|
1086
|
+
max_age_bonus_percentage: IDL.Opt(IDL.Nat64),
|
|
1087
|
+
neuron_grantable_permissions: IDL.Opt(NeuronPermissionList),
|
|
1088
|
+
voting_rewards_parameters: IDL.Opt(VotingRewardsParameters),
|
|
1089
|
+
maturity_modulation_disabled: IDL.Opt(IDL.Bool),
|
|
1090
|
+
max_number_of_principals_per_neuron: IDL.Opt(IDL.Nat64),
|
|
1092
1091
|
});
|
|
1093
1092
|
const RewardEvent = IDL.Record({
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
|
|
1100
|
-
|
|
1093
|
+
rounds_since_last_distribution: IDL.Opt(IDL.Nat64),
|
|
1094
|
+
actual_timestamp_seconds: IDL.Nat64,
|
|
1095
|
+
end_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
1096
|
+
total_available_e8s_equivalent: IDL.Opt(IDL.Nat64),
|
|
1097
|
+
distributed_e8s_equivalent: IDL.Nat64,
|
|
1098
|
+
round: IDL.Nat64,
|
|
1099
|
+
settled_proposals: IDL.Vec(ProposalId),
|
|
1101
1100
|
});
|
|
1102
1101
|
const PendingVersion = IDL.Record({
|
|
1103
|
-
|
|
1104
|
-
|
|
1105
|
-
|
|
1106
|
-
|
|
1102
|
+
mark_failed_at_seconds: IDL.Nat64,
|
|
1103
|
+
checking_upgrade_lock: IDL.Nat64,
|
|
1104
|
+
proposal_id: IDL.Opt(IDL.Nat64),
|
|
1105
|
+
target_version: IDL.Opt(Version),
|
|
1107
1106
|
});
|
|
1108
1107
|
const GovernanceError = IDL.Record({
|
|
1109
|
-
|
|
1110
|
-
|
|
1108
|
+
error_message: IDL.Text,
|
|
1109
|
+
error_type: IDL.Int32,
|
|
1111
1110
|
});
|
|
1112
|
-
const Decimal = IDL.Record({
|
|
1113
|
-
const Tokens = IDL.Record({
|
|
1111
|
+
const Decimal = IDL.Record({ human_readable: IDL.Opt(IDL.Text) });
|
|
1112
|
+
const Tokens = IDL.Record({ e8s: IDL.Opt(IDL.Nat64) });
|
|
1114
1113
|
const ValuationFactors = IDL.Record({
|
|
1115
|
-
|
|
1116
|
-
|
|
1117
|
-
|
|
1114
|
+
xdrs_per_icp: IDL.Opt(Decimal),
|
|
1115
|
+
icps_per_token: IDL.Opt(Decimal),
|
|
1116
|
+
tokens: IDL.Opt(Tokens),
|
|
1118
1117
|
});
|
|
1119
1118
|
const Valuation = IDL.Record({
|
|
1120
|
-
|
|
1121
|
-
|
|
1122
|
-
|
|
1123
|
-
|
|
1119
|
+
token: IDL.Opt(IDL.Int32),
|
|
1120
|
+
account: IDL.Opt(Account),
|
|
1121
|
+
valuation_factors: IDL.Opt(ValuationFactors),
|
|
1122
|
+
timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
1124
1123
|
});
|
|
1125
1124
|
const MintSnsTokensActionAuxiliary = IDL.Record({
|
|
1126
|
-
|
|
1125
|
+
valuation: IDL.Opt(Valuation),
|
|
1127
1126
|
});
|
|
1128
1127
|
const SnsVersion = IDL.Record({
|
|
1129
|
-
|
|
1130
|
-
|
|
1131
|
-
|
|
1132
|
-
|
|
1133
|
-
|
|
1134
|
-
|
|
1128
|
+
archive_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1129
|
+
root_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1130
|
+
swap_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1131
|
+
ledger_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1132
|
+
governance_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1133
|
+
index_wasm_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1135
1134
|
});
|
|
1136
1135
|
const AdvanceSnsTargetVersionActionAuxiliary = IDL.Record({
|
|
1137
|
-
|
|
1136
|
+
target_version: IDL.Opt(SnsVersion),
|
|
1138
1137
|
});
|
|
1139
1138
|
const ActionAuxiliary = IDL.Variant({
|
|
1140
|
-
|
|
1141
|
-
|
|
1142
|
-
|
|
1139
|
+
TransferSnsTreasuryFunds: MintSnsTokensActionAuxiliary,
|
|
1140
|
+
MintSnsTokens: MintSnsTokensActionAuxiliary,
|
|
1141
|
+
AdvanceSnsTargetVersion: AdvanceSnsTargetVersionActionAuxiliary,
|
|
1143
1142
|
});
|
|
1144
1143
|
const Ballot = IDL.Record({
|
|
1145
|
-
|
|
1146
|
-
|
|
1147
|
-
|
|
1144
|
+
vote: IDL.Int32,
|
|
1145
|
+
cast_timestamp_seconds: IDL.Nat64,
|
|
1146
|
+
voting_power: IDL.Nat64,
|
|
1148
1147
|
});
|
|
1149
|
-
const Percentage = IDL.Record({
|
|
1148
|
+
const Percentage = IDL.Record({ basis_points: IDL.Opt(IDL.Nat64) });
|
|
1150
1149
|
const Tally = IDL.Record({
|
|
1151
|
-
|
|
1152
|
-
|
|
1153
|
-
|
|
1154
|
-
|
|
1150
|
+
no: IDL.Nat64,
|
|
1151
|
+
yes: IDL.Nat64,
|
|
1152
|
+
total: IDL.Nat64,
|
|
1153
|
+
timestamp_seconds: IDL.Nat64,
|
|
1155
1154
|
});
|
|
1156
1155
|
const ManageDappCanisterSettings = IDL.Record({
|
|
1157
|
-
|
|
1158
|
-
|
|
1159
|
-
|
|
1160
|
-
|
|
1161
|
-
|
|
1162
|
-
|
|
1163
|
-
|
|
1164
|
-
|
|
1156
|
+
freezing_threshold: IDL.Opt(IDL.Nat64),
|
|
1157
|
+
wasm_memory_threshold: IDL.Opt(IDL.Nat64),
|
|
1158
|
+
canister_ids: IDL.Vec(IDL.Principal),
|
|
1159
|
+
reserved_cycles_limit: IDL.Opt(IDL.Nat64),
|
|
1160
|
+
log_visibility: IDL.Opt(IDL.Int32),
|
|
1161
|
+
wasm_memory_limit: IDL.Opt(IDL.Nat64),
|
|
1162
|
+
memory_allocation: IDL.Opt(IDL.Nat64),
|
|
1163
|
+
compute_allocation: IDL.Opt(IDL.Nat64),
|
|
1165
1164
|
});
|
|
1166
1165
|
PreciseValue.fill(
|
|
1167
1166
|
IDL.Variant({
|
|
1168
|
-
|
|
1169
|
-
|
|
1170
|
-
|
|
1171
|
-
|
|
1172
|
-
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
})
|
|
1167
|
+
Int: IDL.Int64,
|
|
1168
|
+
Map: IDL.Vec(IDL.Tuple(IDL.Text, PreciseValue)),
|
|
1169
|
+
Nat: IDL.Nat64,
|
|
1170
|
+
Blob: IDL.Vec(IDL.Nat8),
|
|
1171
|
+
Bool: IDL.Bool,
|
|
1172
|
+
Text: IDL.Text,
|
|
1173
|
+
Array: IDL.Vec(PreciseValue),
|
|
1174
|
+
}),
|
|
1176
1175
|
);
|
|
1177
|
-
const ExtensionOperationArg = IDL.Record({
|
|
1176
|
+
const ExtensionOperationArg = IDL.Record({ value: IDL.Opt(PreciseValue) });
|
|
1178
1177
|
const ExecuteExtensionOperation = IDL.Record({
|
|
1179
|
-
|
|
1180
|
-
|
|
1181
|
-
|
|
1178
|
+
extension_canister_id: IDL.Opt(IDL.Principal),
|
|
1179
|
+
operation_name: IDL.Opt(IDL.Text),
|
|
1180
|
+
operation_arg: IDL.Opt(ExtensionOperationArg),
|
|
1182
1181
|
});
|
|
1183
1182
|
const ChunkedCanisterWasm = IDL.Record({
|
|
1184
|
-
|
|
1185
|
-
|
|
1186
|
-
|
|
1183
|
+
wasm_module_hash: IDL.Vec(IDL.Nat8),
|
|
1184
|
+
chunk_hashes_list: IDL.Vec(IDL.Vec(IDL.Nat8)),
|
|
1185
|
+
store_canister_id: IDL.Opt(IDL.Principal),
|
|
1187
1186
|
});
|
|
1188
1187
|
const Wasm = IDL.Variant({
|
|
1189
|
-
|
|
1190
|
-
|
|
1188
|
+
Chunked: ChunkedCanisterWasm,
|
|
1189
|
+
Bytes: IDL.Vec(IDL.Nat8),
|
|
1191
1190
|
});
|
|
1192
|
-
const ExtensionUpgradeArg = IDL.Record({
|
|
1191
|
+
const ExtensionUpgradeArg = IDL.Record({ value: IDL.Opt(PreciseValue) });
|
|
1193
1192
|
const UpgradeExtension = IDL.Record({
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
|
|
1193
|
+
extension_canister_id: IDL.Opt(IDL.Principal),
|
|
1194
|
+
wasm: IDL.Opt(Wasm),
|
|
1195
|
+
canister_upgrade_arg: IDL.Opt(ExtensionUpgradeArg),
|
|
1197
1196
|
});
|
|
1198
1197
|
const SetTopicsForCustomProposals = IDL.Record({
|
|
1199
|
-
|
|
1198
|
+
custom_function_id_to_topic: IDL.Vec(IDL.Tuple(IDL.Nat64, Topic)),
|
|
1200
1199
|
});
|
|
1201
|
-
const ExtensionInit = IDL.Record({
|
|
1200
|
+
const ExtensionInit = IDL.Record({ value: IDL.Opt(PreciseValue) });
|
|
1202
1201
|
const RegisterExtension = IDL.Record({
|
|
1203
|
-
|
|
1204
|
-
|
|
1202
|
+
chunked_canister_wasm: IDL.Opt(ChunkedCanisterWasm),
|
|
1203
|
+
extension_init: IDL.Opt(ExtensionInit),
|
|
1205
1204
|
});
|
|
1206
1205
|
const RegisterDappCanisters = IDL.Record({
|
|
1207
|
-
|
|
1206
|
+
canister_ids: IDL.Vec(IDL.Principal),
|
|
1208
1207
|
});
|
|
1209
1208
|
const TransferSnsTreasuryFunds = IDL.Record({
|
|
1210
|
-
|
|
1211
|
-
|
|
1212
|
-
|
|
1213
|
-
|
|
1214
|
-
|
|
1209
|
+
from_treasury: IDL.Int32,
|
|
1210
|
+
to_principal: IDL.Opt(IDL.Principal),
|
|
1211
|
+
to_subaccount: IDL.Opt(Subaccount),
|
|
1212
|
+
memo: IDL.Opt(IDL.Nat64),
|
|
1213
|
+
amount_e8s: IDL.Nat64,
|
|
1215
1214
|
});
|
|
1216
1215
|
const UpgradeSnsControlledCanister = IDL.Record({
|
|
1217
|
-
|
|
1218
|
-
|
|
1219
|
-
|
|
1220
|
-
|
|
1221
|
-
|
|
1216
|
+
new_canister_wasm: IDL.Vec(IDL.Nat8),
|
|
1217
|
+
mode: IDL.Opt(IDL.Int32),
|
|
1218
|
+
canister_id: IDL.Opt(IDL.Principal),
|
|
1219
|
+
chunked_canister_wasm: IDL.Opt(ChunkedCanisterWasm),
|
|
1220
|
+
canister_upgrade_arg: IDL.Opt(IDL.Vec(IDL.Nat8)),
|
|
1222
1221
|
});
|
|
1223
1222
|
const DeregisterDappCanisters = IDL.Record({
|
|
1224
|
-
|
|
1225
|
-
|
|
1223
|
+
canister_ids: IDL.Vec(IDL.Principal),
|
|
1224
|
+
new_controllers: IDL.Vec(IDL.Principal),
|
|
1226
1225
|
});
|
|
1227
1226
|
const MintSnsTokens = IDL.Record({
|
|
1228
|
-
|
|
1229
|
-
|
|
1230
|
-
|
|
1231
|
-
|
|
1227
|
+
to_principal: IDL.Opt(IDL.Principal),
|
|
1228
|
+
to_subaccount: IDL.Opt(Subaccount),
|
|
1229
|
+
memo: IDL.Opt(IDL.Nat64),
|
|
1230
|
+
amount_e8s: IDL.Opt(IDL.Nat64),
|
|
1232
1231
|
});
|
|
1233
1232
|
const AdvanceSnsTargetVersion = IDL.Record({
|
|
1234
|
-
|
|
1233
|
+
new_target: IDL.Opt(SnsVersion),
|
|
1235
1234
|
});
|
|
1236
1235
|
const ManageSnsMetadata = IDL.Record({
|
|
1237
|
-
|
|
1238
|
-
|
|
1239
|
-
|
|
1240
|
-
|
|
1236
|
+
url: IDL.Opt(IDL.Text),
|
|
1237
|
+
logo: IDL.Opt(IDL.Text),
|
|
1238
|
+
name: IDL.Opt(IDL.Text),
|
|
1239
|
+
description: IDL.Opt(IDL.Text),
|
|
1241
1240
|
});
|
|
1242
1241
|
const ExecuteGenericNervousSystemFunction = IDL.Record({
|
|
1243
|
-
|
|
1244
|
-
|
|
1242
|
+
function_id: IDL.Nat64,
|
|
1243
|
+
payload: IDL.Vec(IDL.Nat8),
|
|
1245
1244
|
});
|
|
1246
1245
|
const ManageLedgerParameters = IDL.Record({
|
|
1247
|
-
|
|
1248
|
-
|
|
1249
|
-
|
|
1250
|
-
|
|
1246
|
+
token_symbol: IDL.Opt(IDL.Text),
|
|
1247
|
+
transfer_fee: IDL.Opt(IDL.Nat64),
|
|
1248
|
+
token_logo: IDL.Opt(IDL.Text),
|
|
1249
|
+
token_name: IDL.Opt(IDL.Text),
|
|
1251
1250
|
});
|
|
1252
|
-
const Motion = IDL.Record({
|
|
1251
|
+
const Motion = IDL.Record({ motion_text: IDL.Text });
|
|
1253
1252
|
const Action = IDL.Variant({
|
|
1254
|
-
|
|
1255
|
-
|
|
1256
|
-
|
|
1257
|
-
|
|
1258
|
-
|
|
1259
|
-
|
|
1260
|
-
|
|
1261
|
-
|
|
1262
|
-
|
|
1263
|
-
|
|
1264
|
-
|
|
1265
|
-
|
|
1266
|
-
|
|
1267
|
-
|
|
1268
|
-
|
|
1269
|
-
|
|
1270
|
-
|
|
1271
|
-
|
|
1272
|
-
|
|
1273
|
-
|
|
1253
|
+
ManageNervousSystemParameters: NervousSystemParameters,
|
|
1254
|
+
AddGenericNervousSystemFunction: NervousSystemFunction,
|
|
1255
|
+
ManageDappCanisterSettings: ManageDappCanisterSettings,
|
|
1256
|
+
ExecuteExtensionOperation: ExecuteExtensionOperation,
|
|
1257
|
+
UpgradeExtension: UpgradeExtension,
|
|
1258
|
+
RemoveGenericNervousSystemFunction: IDL.Nat64,
|
|
1259
|
+
SetTopicsForCustomProposals: SetTopicsForCustomProposals,
|
|
1260
|
+
RegisterExtension: RegisterExtension,
|
|
1261
|
+
UpgradeSnsToNextVersion: IDL.Record({}),
|
|
1262
|
+
RegisterDappCanisters: RegisterDappCanisters,
|
|
1263
|
+
TransferSnsTreasuryFunds: TransferSnsTreasuryFunds,
|
|
1264
|
+
UpgradeSnsControlledCanister: UpgradeSnsControlledCanister,
|
|
1265
|
+
DeregisterDappCanisters: DeregisterDappCanisters,
|
|
1266
|
+
MintSnsTokens: MintSnsTokens,
|
|
1267
|
+
AdvanceSnsTargetVersion: AdvanceSnsTargetVersion,
|
|
1268
|
+
Unspecified: IDL.Record({}),
|
|
1269
|
+
ManageSnsMetadata: ManageSnsMetadata,
|
|
1270
|
+
ExecuteGenericNervousSystemFunction: ExecuteGenericNervousSystemFunction,
|
|
1271
|
+
ManageLedgerParameters: ManageLedgerParameters,
|
|
1272
|
+
Motion: Motion,
|
|
1274
1273
|
});
|
|
1275
1274
|
const Proposal = IDL.Record({
|
|
1276
|
-
|
|
1277
|
-
|
|
1278
|
-
|
|
1279
|
-
|
|
1275
|
+
url: IDL.Text,
|
|
1276
|
+
title: IDL.Text,
|
|
1277
|
+
action: IDL.Opt(Action),
|
|
1278
|
+
summary: IDL.Text,
|
|
1280
1279
|
});
|
|
1281
1280
|
const WaitForQuietState = IDL.Record({
|
|
1282
|
-
|
|
1281
|
+
current_deadline_timestamp_seconds: IDL.Nat64,
|
|
1283
1282
|
});
|
|
1284
1283
|
const ProposalData = IDL.Record({
|
|
1285
|
-
|
|
1286
|
-
|
|
1287
|
-
|
|
1288
|
-
|
|
1289
|
-
|
|
1290
|
-
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
|
|
1294
|
-
|
|
1295
|
-
|
|
1296
|
-
|
|
1297
|
-
|
|
1298
|
-
|
|
1299
|
-
|
|
1300
|
-
|
|
1301
|
-
|
|
1302
|
-
|
|
1303
|
-
|
|
1304
|
-
|
|
1305
|
-
|
|
1306
|
-
|
|
1307
|
-
|
|
1308
|
-
});
|
|
1309
|
-
const Split = IDL.Record({
|
|
1284
|
+
id: IDL.Opt(ProposalId),
|
|
1285
|
+
payload_text_rendering: IDL.Opt(IDL.Text),
|
|
1286
|
+
topic: IDL.Opt(Topic),
|
|
1287
|
+
action: IDL.Nat64,
|
|
1288
|
+
failure_reason: IDL.Opt(GovernanceError),
|
|
1289
|
+
action_auxiliary: IDL.Opt(ActionAuxiliary),
|
|
1290
|
+
ballots: IDL.Vec(IDL.Tuple(IDL.Text, Ballot)),
|
|
1291
|
+
minimum_yes_proportion_of_total: IDL.Opt(Percentage),
|
|
1292
|
+
reward_event_round: IDL.Nat64,
|
|
1293
|
+
failed_timestamp_seconds: IDL.Nat64,
|
|
1294
|
+
reward_event_end_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
1295
|
+
proposal_creation_timestamp_seconds: IDL.Nat64,
|
|
1296
|
+
initial_voting_period_seconds: IDL.Nat64,
|
|
1297
|
+
reject_cost_e8s: IDL.Nat64,
|
|
1298
|
+
latest_tally: IDL.Opt(Tally),
|
|
1299
|
+
wait_for_quiet_deadline_increase_seconds: IDL.Nat64,
|
|
1300
|
+
decided_timestamp_seconds: IDL.Nat64,
|
|
1301
|
+
proposal: IDL.Opt(Proposal),
|
|
1302
|
+
proposer: IDL.Opt(NeuronId),
|
|
1303
|
+
wait_for_quiet_state: IDL.Opt(WaitForQuietState),
|
|
1304
|
+
minimum_yes_proportion_of_exercised: IDL.Opt(Percentage),
|
|
1305
|
+
is_eligible_for_rewards: IDL.Bool,
|
|
1306
|
+
executed_timestamp_seconds: IDL.Nat64,
|
|
1307
|
+
});
|
|
1308
|
+
const Split = IDL.Record({ memo: IDL.Nat64, amount_e8s: IDL.Nat64 });
|
|
1310
1309
|
const Follow = IDL.Record({
|
|
1311
|
-
|
|
1312
|
-
|
|
1310
|
+
function_id: IDL.Nat64,
|
|
1311
|
+
followees: IDL.Vec(NeuronId),
|
|
1313
1312
|
});
|
|
1314
1313
|
const DisburseMaturity = IDL.Record({
|
|
1315
|
-
|
|
1316
|
-
|
|
1314
|
+
to_account: IDL.Opt(Account),
|
|
1315
|
+
percentage_to_disburse: IDL.Nat32,
|
|
1317
1316
|
});
|
|
1318
1317
|
const ChangeAutoStakeMaturity = IDL.Record({
|
|
1319
|
-
|
|
1318
|
+
requested_setting_for_auto_stake_maturity: IDL.Bool,
|
|
1320
1319
|
});
|
|
1321
1320
|
const IncreaseDissolveDelay = IDL.Record({
|
|
1322
|
-
|
|
1321
|
+
additional_dissolve_delay_seconds: IDL.Nat32,
|
|
1323
1322
|
});
|
|
1324
1323
|
const SetDissolveTimestamp = IDL.Record({
|
|
1325
|
-
|
|
1324
|
+
dissolve_timestamp_seconds: IDL.Nat64,
|
|
1326
1325
|
});
|
|
1327
1326
|
const Operation = IDL.Variant({
|
|
1328
|
-
|
|
1329
|
-
|
|
1330
|
-
|
|
1331
|
-
|
|
1332
|
-
|
|
1327
|
+
ChangeAutoStakeMaturity: ChangeAutoStakeMaturity,
|
|
1328
|
+
StopDissolving: IDL.Record({}),
|
|
1329
|
+
StartDissolving: IDL.Record({}),
|
|
1330
|
+
IncreaseDissolveDelay: IncreaseDissolveDelay,
|
|
1331
|
+
SetDissolveTimestamp: SetDissolveTimestamp,
|
|
1333
1332
|
});
|
|
1334
|
-
const Configure = IDL.Record({
|
|
1333
|
+
const Configure = IDL.Record({ operation: IDL.Opt(Operation) });
|
|
1335
1334
|
const RegisterVote = IDL.Record({
|
|
1336
|
-
|
|
1337
|
-
|
|
1335
|
+
vote: IDL.Int32,
|
|
1336
|
+
proposal: IDL.Opt(ProposalId),
|
|
1338
1337
|
});
|
|
1339
1338
|
const Followee = IDL.Record({
|
|
1340
|
-
|
|
1341
|
-
|
|
1339
|
+
alias: IDL.Opt(IDL.Text),
|
|
1340
|
+
neuron_id: IDL.Opt(NeuronId),
|
|
1342
1341
|
});
|
|
1343
1342
|
const FolloweesForTopic = IDL.Record({
|
|
1344
|
-
|
|
1345
|
-
|
|
1343
|
+
topic: IDL.Opt(Topic),
|
|
1344
|
+
followees: IDL.Vec(Followee),
|
|
1346
1345
|
});
|
|
1347
1346
|
const SetFollowing = IDL.Record({
|
|
1348
|
-
|
|
1347
|
+
topic_following: IDL.Vec(FolloweesForTopic),
|
|
1349
1348
|
});
|
|
1350
1349
|
const FinalizeDisburseMaturity = IDL.Record({
|
|
1351
|
-
|
|
1352
|
-
|
|
1350
|
+
amount_to_be_disbursed_e8s: IDL.Nat64,
|
|
1351
|
+
to_account: IDL.Opt(Account),
|
|
1353
1352
|
});
|
|
1354
1353
|
const MemoAndController = IDL.Record({
|
|
1355
|
-
|
|
1356
|
-
|
|
1354
|
+
controller: IDL.Opt(IDL.Principal),
|
|
1355
|
+
memo: IDL.Nat64,
|
|
1357
1356
|
});
|
|
1358
1357
|
const By = IDL.Variant({
|
|
1359
|
-
|
|
1360
|
-
|
|
1358
|
+
MemoAndController: MemoAndController,
|
|
1359
|
+
NeuronId: IDL.Record({}),
|
|
1361
1360
|
});
|
|
1362
|
-
const ClaimOrRefresh = IDL.Record({
|
|
1361
|
+
const ClaimOrRefresh = IDL.Record({ by: IDL.Opt(By) });
|
|
1363
1362
|
const RemoveNeuronPermissions = IDL.Record({
|
|
1364
|
-
|
|
1365
|
-
|
|
1363
|
+
permissions_to_remove: IDL.Opt(NeuronPermissionList),
|
|
1364
|
+
principal_id: IDL.Opt(IDL.Principal),
|
|
1366
1365
|
});
|
|
1367
1366
|
const AddNeuronPermissions = IDL.Record({
|
|
1368
|
-
|
|
1369
|
-
|
|
1367
|
+
permissions_to_add: IDL.Opt(NeuronPermissionList),
|
|
1368
|
+
principal_id: IDL.Opt(IDL.Principal),
|
|
1370
1369
|
});
|
|
1371
|
-
const MergeMaturity = IDL.Record({
|
|
1372
|
-
const Amount = IDL.Record({
|
|
1370
|
+
const MergeMaturity = IDL.Record({ percentage_to_merge: IDL.Nat32 });
|
|
1371
|
+
const Amount = IDL.Record({ e8s: IDL.Nat64 });
|
|
1373
1372
|
const Disburse = IDL.Record({
|
|
1374
|
-
|
|
1375
|
-
|
|
1373
|
+
to_account: IDL.Opt(Account),
|
|
1374
|
+
amount: IDL.Opt(Amount),
|
|
1376
1375
|
});
|
|
1377
1376
|
const Command_2 = IDL.Variant({
|
|
1378
|
-
|
|
1379
|
-
|
|
1380
|
-
|
|
1381
|
-
|
|
1382
|
-
|
|
1383
|
-
|
|
1384
|
-
|
|
1385
|
-
|
|
1386
|
-
|
|
1387
|
-
|
|
1388
|
-
|
|
1389
|
-
|
|
1390
|
-
|
|
1391
|
-
|
|
1377
|
+
Split: Split,
|
|
1378
|
+
Follow: Follow,
|
|
1379
|
+
DisburseMaturity: DisburseMaturity,
|
|
1380
|
+
Configure: Configure,
|
|
1381
|
+
RegisterVote: RegisterVote,
|
|
1382
|
+
SetFollowing: SetFollowing,
|
|
1383
|
+
SyncCommand: IDL.Record({}),
|
|
1384
|
+
MakeProposal: Proposal,
|
|
1385
|
+
FinalizeDisburseMaturity: FinalizeDisburseMaturity,
|
|
1386
|
+
ClaimOrRefreshNeuron: ClaimOrRefresh,
|
|
1387
|
+
RemoveNeuronPermissions: RemoveNeuronPermissions,
|
|
1388
|
+
AddNeuronPermissions: AddNeuronPermissions,
|
|
1389
|
+
MergeMaturity: MergeMaturity,
|
|
1390
|
+
Disburse: Disburse,
|
|
1392
1391
|
});
|
|
1393
1392
|
const NeuronInFlightCommand = IDL.Record({
|
|
1394
|
-
|
|
1395
|
-
|
|
1393
|
+
command: IDL.Opt(Command_2),
|
|
1394
|
+
timestamp: IDL.Nat64,
|
|
1396
1395
|
});
|
|
1397
1396
|
const NeuronPermission = IDL.Record({
|
|
1398
|
-
|
|
1399
|
-
|
|
1397
|
+
principal: IDL.Opt(IDL.Principal),
|
|
1398
|
+
permission_type: IDL.Vec(IDL.Int32),
|
|
1400
1399
|
});
|
|
1401
1400
|
const DissolveState = IDL.Variant({
|
|
1402
|
-
|
|
1403
|
-
|
|
1401
|
+
DissolveDelaySeconds: IDL.Nat64,
|
|
1402
|
+
WhenDissolvedTimestampSeconds: IDL.Nat64,
|
|
1404
1403
|
});
|
|
1405
1404
|
const DisburseMaturityInProgress = IDL.Record({
|
|
1406
|
-
|
|
1407
|
-
|
|
1408
|
-
|
|
1409
|
-
|
|
1405
|
+
timestamp_of_disbursement_seconds: IDL.Nat64,
|
|
1406
|
+
amount_e8s: IDL.Nat64,
|
|
1407
|
+
account_to_disburse_to: IDL.Opt(Account),
|
|
1408
|
+
finalize_disbursement_timestamp_seconds: IDL.Opt(IDL.Nat64),
|
|
1410
1409
|
});
|
|
1411
1410
|
const Neuron = IDL.Record({
|
|
1412
|
-
|
|
1413
|
-
|
|
1414
|
-
|
|
1415
|
-
|
|
1416
|
-
|
|
1417
|
-
|
|
1418
|
-
|
|
1411
|
+
id: IDL.Opt(NeuronId),
|
|
1412
|
+
staked_maturity_e8s_equivalent: IDL.Opt(IDL.Nat64),
|
|
1413
|
+
permissions: IDL.Vec(NeuronPermission),
|
|
1414
|
+
maturity_e8s_equivalent: IDL.Nat64,
|
|
1415
|
+
cached_neuron_stake_e8s: IDL.Nat64,
|
|
1416
|
+
created_timestamp_seconds: IDL.Nat64,
|
|
1417
|
+
topic_followees: IDL.Opt(
|
|
1419
1418
|
IDL.Record({
|
|
1420
|
-
|
|
1421
|
-
|
|
1422
|
-
),
|
|
1423
|
-
})
|
|
1419
|
+
topic_id_to_followees: IDL.Vec(IDL.Tuple(IDL.Int32, FolloweesForTopic)),
|
|
1420
|
+
}),
|
|
1424
1421
|
),
|
|
1425
|
-
|
|
1426
|
-
|
|
1427
|
-
|
|
1428
|
-
|
|
1429
|
-
|
|
1430
|
-
|
|
1431
|
-
|
|
1432
|
-
|
|
1433
|
-
|
|
1422
|
+
source_nns_neuron_id: IDL.Opt(IDL.Nat64),
|
|
1423
|
+
auto_stake_maturity: IDL.Opt(IDL.Bool),
|
|
1424
|
+
aging_since_timestamp_seconds: IDL.Nat64,
|
|
1425
|
+
dissolve_state: IDL.Opt(DissolveState),
|
|
1426
|
+
voting_power_percentage_multiplier: IDL.Nat64,
|
|
1427
|
+
vesting_period_seconds: IDL.Opt(IDL.Nat64),
|
|
1428
|
+
disburse_maturity_in_progress: IDL.Vec(DisburseMaturityInProgress),
|
|
1429
|
+
followees: IDL.Vec(IDL.Tuple(IDL.Nat64, Followees)),
|
|
1430
|
+
neuron_fees_e8s: IDL.Nat64,
|
|
1434
1431
|
});
|
|
1435
1432
|
const Governance = IDL.Record({
|
|
1436
|
-
|
|
1437
|
-
|
|
1438
|
-
|
|
1439
|
-
|
|
1440
|
-
IDL.Tuple(IDL.Nat64, NervousSystemFunction)
|
|
1433
|
+
root_canister_id: IDL.Opt(IDL.Principal),
|
|
1434
|
+
timers: IDL.Opt(Timers),
|
|
1435
|
+
cached_upgrade_steps: IDL.Opt(CachedUpgradeSteps),
|
|
1436
|
+
id_to_nervous_system_functions: IDL.Vec(
|
|
1437
|
+
IDL.Tuple(IDL.Nat64, NervousSystemFunction),
|
|
1441
1438
|
),
|
|
1442
|
-
|
|
1443
|
-
|
|
1444
|
-
|
|
1445
|
-
|
|
1446
|
-
|
|
1447
|
-
|
|
1448
|
-
|
|
1449
|
-
|
|
1450
|
-
|
|
1451
|
-
|
|
1452
|
-
|
|
1453
|
-
|
|
1454
|
-
|
|
1455
|
-
|
|
1456
|
-
|
|
1457
|
-
|
|
1458
|
-
|
|
1459
|
-
|
|
1460
|
-
});
|
|
1439
|
+
metrics: IDL.Opt(GovernanceCachedMetrics),
|
|
1440
|
+
maturity_modulation: IDL.Opt(MaturityModulation),
|
|
1441
|
+
upgrade_journal: IDL.Opt(UpgradeJournal),
|
|
1442
|
+
mode: IDL.Int32,
|
|
1443
|
+
parameters: IDL.Opt(NervousSystemParameters),
|
|
1444
|
+
is_finalizing_disburse_maturity: IDL.Opt(IDL.Bool),
|
|
1445
|
+
deployed_version: IDL.Opt(Version),
|
|
1446
|
+
sns_initialization_parameters: IDL.Text,
|
|
1447
|
+
latest_reward_event: IDL.Opt(RewardEvent),
|
|
1448
|
+
pending_version: IDL.Opt(PendingVersion),
|
|
1449
|
+
swap_canister_id: IDL.Opt(IDL.Principal),
|
|
1450
|
+
ledger_canister_id: IDL.Opt(IDL.Principal),
|
|
1451
|
+
proposals: IDL.Vec(IDL.Tuple(IDL.Nat64, ProposalData)),
|
|
1452
|
+
in_flight_commands: IDL.Vec(IDL.Tuple(IDL.Text, NeuronInFlightCommand)),
|
|
1453
|
+
sns_metadata: IDL.Opt(ManageSnsMetadata),
|
|
1454
|
+
neurons: IDL.Vec(IDL.Tuple(IDL.Text, Neuron)),
|
|
1455
|
+
target_version: IDL.Opt(Version),
|
|
1456
|
+
genesis_timestamp_seconds: IDL.Nat64,
|
|
1457
|
+
});
|
|
1458
|
+
|
|
1461
1459
|
return [Governance];
|
|
1462
1460
|
};
|