@dfinity/nns 0.4.0 → 0.4.1

package/dist/candid/genesis_token.certified.idl.js

@@ -0,0 +1,37 @@
+/* Do not edit.  Compiled with ./scripts/compile-idl-js from candid/genesis_token.did */
+export const idlFactory = ({ IDL }) => {
+  const NeuronId = IDL.Record({ 'id' : IDL.Nat64 });
+  const Result = IDL.Variant({ 'Ok' : IDL.Vec(NeuronId), 'Err' : IDL.Text });
+  const Result_1 = IDL.Variant({ 'Ok' : IDL.Null, 'Err' : IDL.Text });
+  const TransferredNeuron = IDL.Record({
+    'error' : IDL.Opt(IDL.Text),
+    'timestamp_seconds' : IDL.Nat64,
+    'neuron_id' : IDL.Opt(NeuronId),
+  });
+  const AccountState = IDL.Record({
+    'authenticated_principal_id' : IDL.Opt(IDL.Principal),
+    'successfully_transferred_neurons' : IDL.Vec(TransferredNeuron),
+    'is_whitelisted_for_forwarding' : IDL.Bool,
+    'has_donated' : IDL.Bool,
+    'failed_transferred_neurons' : IDL.Vec(TransferredNeuron),
+    'neuron_ids' : IDL.Vec(NeuronId),
+    'has_claimed' : IDL.Bool,
+    'has_forwarded' : IDL.Bool,
+    'icpts' : IDL.Nat32,
+  });
+  const Result_2 = IDL.Variant({ 'Ok' : AccountState, 'Err' : IDL.Text });
+  return IDL.Service({
+    'balance' : IDL.Func([IDL.Text], [IDL.Nat32], []),
+    'claim_neurons' : IDL.Func([IDL.Text], [Result], []),
+    'donate_account' : IDL.Func([IDL.Text], [Result_1], []),
+    'forward_whitelisted_unclaimed_accounts' : IDL.Func(
+        [IDL.Null],
+        [Result_1],
+        [],
+      ),
+    'get_account' : IDL.Func([IDL.Text], [Result_2], []),
+    'len' : IDL.Func([], [IDL.Nat16], []),
+    'total' : IDL.Func([], [IDL.Nat32], []),
+  });
+};
+export const init = ({ IDL }) => { return []; };

package/dist/candid/genesis_token.did

@@ -0,0 +1,30 @@
+type AccountState = record {
+    authenticated_principal_id : opt principal;
+    successfully_transferred_neurons : vec TransferredNeuron;
+    is_whitelisted_for_forwarding : bool;
+    has_donated : bool;
+    failed_transferred_neurons : vec TransferredNeuron;
+    neuron_ids : vec NeuronId;
+    has_claimed : bool;
+    has_forwarded : bool;
+    icpts : nat32;
+  };
+type NeuronId = record { id : nat64 };
+type Result = variant { Ok : vec NeuronId; Err : text };
+type Result_1 = variant { Ok; Err : text };
+type Result_2 = variant { Ok : AccountState; Err : text };
+type TransferredNeuron = record {
+    error : opt text;
+    timestamp_seconds : nat64;
+    neuron_id : opt NeuronId;
+};
+service : {
+    balance : (text) -> (nat32) query;
+    claim_neurons : (text) -> (Result);
+    donate_account : (text) -> (Result_1);
+    forward_whitelisted_unclaimed_accounts : (null) -> (Result_1);
+    get_account : (text) -> (Result_2) query;
+    len : () -> (nat16) query;
+    total : () -> (nat32) query;
+}
+

package/dist/candid/genesis_token.idl.d.ts

@@ -0,0 +1,10 @@
+import type { IDL } from "@dfinity/candid";
+export const idlFactory: IDL.InterfaceFactory;
+export interface NeuronId {
+  id: bigint;
+}
+
+export type Result = { Ok: NeuronId[] } | { Err: string };
+export interface GenesisTokenService {
+  claim_neurons: (arg_0: string) => Promise<Result>;
+}

package/dist/candid/genesis_token.idl.js

@@ -0,0 +1,37 @@
+/* Do not edit.  Compiled with ./scripts/compile-idl-js from candid/genesis_token.did */
+export const idlFactory = ({ IDL }) => {
+  const NeuronId = IDL.Record({ 'id' : IDL.Nat64 });
+  const Result = IDL.Variant({ 'Ok' : IDL.Vec(NeuronId), 'Err' : IDL.Text });
+  const Result_1 = IDL.Variant({ 'Ok' : IDL.Null, 'Err' : IDL.Text });
+  const TransferredNeuron = IDL.Record({
+    'error' : IDL.Opt(IDL.Text),
+    'timestamp_seconds' : IDL.Nat64,
+    'neuron_id' : IDL.Opt(NeuronId),
+  });
+  const AccountState = IDL.Record({
+    'authenticated_principal_id' : IDL.Opt(IDL.Principal),
+    'successfully_transferred_neurons' : IDL.Vec(TransferredNeuron),
+    'is_whitelisted_for_forwarding' : IDL.Bool,
+    'has_donated' : IDL.Bool,
+    'failed_transferred_neurons' : IDL.Vec(TransferredNeuron),
+    'neuron_ids' : IDL.Vec(NeuronId),
+    'has_claimed' : IDL.Bool,
+    'has_forwarded' : IDL.Bool,
+    'icpts' : IDL.Nat32,
+  });
+  const Result_2 = IDL.Variant({ 'Ok' : AccountState, 'Err' : IDL.Text });
+  return IDL.Service({
+    'balance' : IDL.Func([IDL.Text], [IDL.Nat32], ['query']),
+    'claim_neurons' : IDL.Func([IDL.Text], [Result], []),
+    'donate_account' : IDL.Func([IDL.Text], [Result_1], []),
+    'forward_whitelisted_unclaimed_accounts' : IDL.Func(
+        [IDL.Null],
+        [Result_1],
+        [],
+      ),
+    'get_account' : IDL.Func([IDL.Text], [Result_2], ['query']),
+    'len' : IDL.Func([], [IDL.Nat16], ['query']),
+    'total' : IDL.Func([], [IDL.Nat32], ['query']),
+  });
+};
+export const init = ({ IDL }) => { return []; };

package/dist/candid/governance.certified.idl.js

@@ -79,6 +79,7 @@ export const idlFactory = ({ IDL }) => {
     'known_neuron_data' : IDL.Opt(KnownNeuronData),
   });
   const Spawn = IDL.Record({
+    'percentage_to_spawn' : IDL.Opt(IDL.Nat32),
     'new_controller' : IDL.Opt(IDL.Principal),
     'nonce' : IDL.Opt(IDL.Nat64),
   });
@@ -178,6 +179,7 @@ export const idlFactory = ({ IDL }) => {
     'default_followees' : IDL.Vec(IDL.Tuple(IDL.Int32, Followees)),
   });
   const RewardNodeProviders = IDL.Record({
+    'use_registry_derived_rewards' : IDL.Opt(IDL.Bool),
     'rewards' : IDL.Vec(RewardNodeProvider),
   });
   const ApproveGenesisKyc = IDL.Record({
@@ -308,6 +310,10 @@ export const idlFactory = ({ IDL }) => {
     'age_seconds' : IDL.Nat64,
   });
   const Result_4 = IDL.Variant({ 'Ok' : NeuronInfo, 'Err' : GovernanceError });
+  const Result_5 = IDL.Variant({
+    'Ok' : NodeProvider,
+    'Err' : GovernanceError,
+  });
   const ProposalInfo = IDL.Record({
     'id' : IDL.Opt(NeuronId),
     'status' : IDL.Int32,
@@ -337,6 +343,9 @@ export const idlFactory = ({ IDL }) => {
     'neuron_infos' : IDL.Vec(IDL.Tuple(IDL.Nat64, NeuronInfo)),
     'full_neurons' : IDL.Vec(Neuron),
   });
+  const ListNodeProvidersResponse = IDL.Record({
+    'node_providers' : IDL.Vec(NodeProvider),
+  });
   const ListProposalInfo = IDL.Record({
     'include_reward_status' : IDL.Vec(IDL.Int32),
     'before_proposal' : IDL.Opt(NeuronId),
@@ -396,6 +405,7 @@ export const idlFactory = ({ IDL }) => {
         [],
       ),
     'get_monthly_node_provider_rewards' : IDL.Func([], [Result_3], []),
+    'get_network_economics_parameters' : IDL.Func([], [NetworkEconomics], []),
     'get_neuron_ids' : IDL.Func([], [IDL.Vec(IDL.Nat64)], []),
     'get_neuron_info' : IDL.Func([IDL.Nat64], [Result_4], []),
     'get_neuron_info_by_id_or_subaccount' : IDL.Func(
@@ -403,10 +413,12 @@ export const idlFactory = ({ IDL }) => {
         [Result_4],
         [],
       ),
+    'get_node_provider_by_caller' : IDL.Func([IDL.Null], [Result_5], []),
     'get_pending_proposals' : IDL.Func([], [IDL.Vec(ProposalInfo)], []),
     'get_proposal_info' : IDL.Func([IDL.Nat64], [IDL.Opt(ProposalInfo)], []),
     'list_known_neurons' : IDL.Func([], [ListKnownNeuronsResponse], []),
     'list_neurons' : IDL.Func([ListNeurons], [ListNeuronsResponse], []),
+    'list_node_providers' : IDL.Func([], [ListNodeProvidersResponse], []),
     'list_proposals' : IDL.Func(
         [ListProposalInfo],
         [ListProposalInfoResponse],
@@ -497,6 +509,7 @@ export const init = ({ IDL }) => {
     'known_neuron_data' : IDL.Opt(KnownNeuronData),
   });
   const Spawn = IDL.Record({
+    'percentage_to_spawn' : IDL.Opt(IDL.Nat32),
     'new_controller' : IDL.Opt(IDL.Principal),
     'nonce' : IDL.Opt(IDL.Nat64),
   });
@@ -596,6 +609,7 @@ export const init = ({ IDL }) => {
     'default_followees' : IDL.Vec(IDL.Tuple(IDL.Int32, Followees)),
   });
   const RewardNodeProviders = IDL.Record({
+    'use_registry_derived_rewards' : IDL.Opt(IDL.Bool),
     'rewards' : IDL.Vec(RewardNodeProvider),
   });
   const ApproveGenesisKyc = IDL.Record({

package/dist/candid/governance.did

@@ -1,4 +1,6 @@
 // Generated from IC repo commit a7af3db3065aa1d6acd8160a79b4ca67b20ac63c by governance.update.sh
+// Updated ae1f3a3902240ff31aa4add01122a02274522c96
+
 type AccountIdentifier = record { hash : vec nat8 };
 type Action = variant {
   RegisterKnownNeuron : KnownNeuron;
@@ -138,6 +140,7 @@ type ListNeuronsResponse = record {
   neuron_infos : vec record { nat64; NeuronInfo };
   full_neurons : vec Neuron;
 };
+type ListNodeProvidersResponse = record { node_providers : vec NodeProvider };
 type ListProposalInfo = record {
   include_reward_status : vec int32;
   before_proposal : opt NeuronId;
@@ -278,6 +281,7 @@ type Result_1 = variant { Error : GovernanceError; NeuronId : NeuronId };
 type Result_2 = variant { Ok : Neuron; Err : GovernanceError };
 type Result_3 = variant { Ok : RewardNodeProviders; Err : GovernanceError };
 type Result_4 = variant { Ok : NeuronInfo; Err : GovernanceError };
+type Result_5 = variant { Ok : NodeProvider; Err : GovernanceError };
 type RewardEvent = record {
   day_after_genesis : nat64;
   actual_timestamp_seconds : nat64;
@@ -293,14 +297,21 @@ type RewardNodeProvider = record {
   reward_mode : opt RewardMode;
   amount_e8s : nat64;
 };
-type RewardNodeProviders = record { rewards : vec RewardNodeProvider };
+type RewardNodeProviders = record {
+  use_registry_derived_rewards : opt bool;
+  rewards : vec RewardNodeProvider;
+};
 type RewardToAccount = record { to_account : opt AccountIdentifier };
 type RewardToNeuron = record { dissolve_delay_seconds : nat64 };
 type SetDefaultFollowees = record {
   default_followees : vec record { int32; Followees };
 };
 type SetDissolveTimestamp = record { dissolve_timestamp_seconds : nat64 };
-type Spawn = record { new_controller : opt principal; nonce : opt nat64 };
+type Spawn = record {
+  percentage_to_spawn : opt nat32;
+  new_controller : opt principal;
+  nonce : opt nat64;
+};
 type SpawnResponse = record { created_neuron_id : opt NeuronId };
 type Split = record { amount_e8s : nat64 };
 type Tally = record {
@@ -322,17 +333,20 @@ service : (Governance) -> {
       Result_2,
     ) query;
   get_monthly_node_provider_rewards : () -> (Result_3);
+  get_network_economics_parameters : () -> (NetworkEconomics) query;
   get_neuron_ids : () -> (vec nat64) query;
   get_neuron_info : (nat64) -> (Result_4) query;
   get_neuron_info_by_id_or_subaccount : (NeuronIdOrSubaccount) -> (
       Result_4,
     ) query;
+  get_node_provider_by_caller : (null) -> (Result_5) query;
   get_pending_proposals : () -> (vec ProposalInfo) query;
   get_proposal_info : (nat64) -> (opt ProposalInfo) query;
   list_known_neurons : () -> (ListKnownNeuronsResponse) query;
   list_neurons : (ListNeurons) -> (ListNeuronsResponse) query;
+  list_node_providers : () -> (ListNodeProvidersResponse) query;
   list_proposals : (ListProposalInfo) -> (ListProposalInfoResponse) query;
   manage_neuron : (ManageNeuron) -> (ManageNeuronResponse);
   transfer_gtc_neuron : (NeuronId, NeuronId) -> (Result);
-  update_node_provider : (UpdateNodeProvider) -> (Result) query;
-}
+  update_node_provider : (UpdateNodeProvider) -> (Result);
+}

package/dist/candid/governance.idl.js

@@ -79,6 +79,7 @@ export const idlFactory = ({ IDL }) => {
     'known_neuron_data' : IDL.Opt(KnownNeuronData),
   });
   const Spawn = IDL.Record({
+    'percentage_to_spawn' : IDL.Opt(IDL.Nat32),
     'new_controller' : IDL.Opt(IDL.Principal),
     'nonce' : IDL.Opt(IDL.Nat64),
   });
@@ -178,6 +179,7 @@ export const idlFactory = ({ IDL }) => {
     'default_followees' : IDL.Vec(IDL.Tuple(IDL.Int32, Followees)),
   });
   const RewardNodeProviders = IDL.Record({
+    'use_registry_derived_rewards' : IDL.Opt(IDL.Bool),
     'rewards' : IDL.Vec(RewardNodeProvider),
   });
   const ApproveGenesisKyc = IDL.Record({
@@ -308,6 +310,10 @@ export const idlFactory = ({ IDL }) => {
     'age_seconds' : IDL.Nat64,
   });
   const Result_4 = IDL.Variant({ 'Ok' : NeuronInfo, 'Err' : GovernanceError });
+  const Result_5 = IDL.Variant({
+    'Ok' : NodeProvider,
+    'Err' : GovernanceError,
+  });
   const ProposalInfo = IDL.Record({
     'id' : IDL.Opt(NeuronId),
     'status' : IDL.Int32,
@@ -337,6 +343,9 @@ export const idlFactory = ({ IDL }) => {
     'neuron_infos' : IDL.Vec(IDL.Tuple(IDL.Nat64, NeuronInfo)),
     'full_neurons' : IDL.Vec(Neuron),
   });
+  const ListNodeProvidersResponse = IDL.Record({
+    'node_providers' : IDL.Vec(NodeProvider),
+  });
   const ListProposalInfo = IDL.Record({
     'include_reward_status' : IDL.Vec(IDL.Int32),
     'before_proposal' : IDL.Opt(NeuronId),
@@ -396,6 +405,11 @@ export const idlFactory = ({ IDL }) => {
         ['query'],
       ),
     'get_monthly_node_provider_rewards' : IDL.Func([], [Result_3], []),
+    'get_network_economics_parameters' : IDL.Func(
+        [],
+        [NetworkEconomics],
+        ['query'],
+      ),
     'get_neuron_ids' : IDL.Func([], [IDL.Vec(IDL.Nat64)], ['query']),
     'get_neuron_info' : IDL.Func([IDL.Nat64], [Result_4], ['query']),
     'get_neuron_info_by_id_or_subaccount' : IDL.Func(
@@ -403,6 +417,7 @@ export const idlFactory = ({ IDL }) => {
         [Result_4],
         ['query'],
       ),
+    'get_node_provider_by_caller' : IDL.Func([IDL.Null], [Result_5], ['query']),
     'get_pending_proposals' : IDL.Func([], [IDL.Vec(ProposalInfo)], ['query']),
     'get_proposal_info' : IDL.Func(
         [IDL.Nat64],
@@ -411,6 +426,11 @@ export const idlFactory = ({ IDL }) => {
       ),
     'list_known_neurons' : IDL.Func([], [ListKnownNeuronsResponse], ['query']),
     'list_neurons' : IDL.Func([ListNeurons], [ListNeuronsResponse], ['query']),
+    'list_node_providers' : IDL.Func(
+        [],
+        [ListNodeProvidersResponse],
+        ['query'],
+      ),
     'list_proposals' : IDL.Func(
         [ListProposalInfo],
         [ListProposalInfoResponse],
@@ -418,11 +438,7 @@ export const idlFactory = ({ IDL }) => {
       ),
     'manage_neuron' : IDL.Func([ManageNeuron], [ManageNeuronResponse], []),
     'transfer_gtc_neuron' : IDL.Func([NeuronId, NeuronId], [Result], []),
-    'update_node_provider' : IDL.Func(
-        [UpdateNodeProvider],
-        [Result],
-        ['query'],
-      ),
+    'update_node_provider' : IDL.Func([UpdateNodeProvider], [Result], []),
   });
 };
 export const init = ({ IDL }) => {
@@ -505,6 +521,7 @@ export const init = ({ IDL }) => {
     'known_neuron_data' : IDL.Opt(KnownNeuronData),
   });
   const Spawn = IDL.Record({
+    'percentage_to_spawn' : IDL.Opt(IDL.Nat32),
     'new_controller' : IDL.Opt(IDL.Principal),
     'nonce' : IDL.Opt(IDL.Nat64),
   });
@@ -604,6 +621,7 @@ export const init = ({ IDL }) => {
     'default_followees' : IDL.Vec(IDL.Tuple(IDL.Int32, Followees)),
   });
   const RewardNodeProviders = IDL.Record({
+    'use_registry_derived_rewards' : IDL.Opt(IDL.Bool),
     'rewards' : IDL.Vec(RewardNodeProvider),
   });
   const ApproveGenesisKyc = IDL.Record({

package/dist/candid/governanceTypes.d.ts

@@ -64,7 +64,7 @@ export type Command =
   | { MergeMaturity: MergeMaturity }
   | { Disburse: Disburse };
 export type Command_1 =
-  | { Error: GovernanceErrorDetail }
+  | { Error: GovernanceError }
   | { Spawn: SpawnResponse }
   | { Split: SpawnResponse }
   | { Follow: {} }
@@ -148,7 +148,7 @@ export interface GovernanceCachedMetrics {
   community_fund_total_staked_e8s: bigint;
   timestamp_seconds: bigint;
 }
-export interface GovernanceErrorDetail {
+export interface GovernanceError {
   error_message: string;
   error_type: number;
 }
@@ -174,6 +174,9 @@ export interface ListNeuronsResponse {
   neuron_infos: Array<[bigint, NeuronInfo]>;
   full_neurons: Array<Neuron>;
 }
+export interface ListNodeProvidersResponse {
+  node_providers: Array<NodeProvider>;
+}
 export interface ListProposalInfo {
   include_reward_status: Array<number>;
   before_proposal: [] | [NeuronId];
@@ -288,7 +291,7 @@ export interface Proposal {
 }
 export interface ProposalData {
   id: [] | [NeuronId];
-  failure_reason: [] | [GovernanceErrorDetail];
+  failure_reason: [] | [GovernanceError];
   ballots: Array<[bigint, Ballot]>;
   proposal_timestamp_seconds: bigint;
   reward_event_round: bigint;
@@ -305,7 +308,7 @@ export interface ProposalInfo {
   id: [] | [NeuronId];
   status: number;
   topic: number;
-  failure_reason: [] | [GovernanceErrorDetail];
+  failure_reason: [] | [GovernanceError];
   ballots: Array<[bigint, Ballot]>;
   proposal_timestamp_seconds: bigint;
   reward_event_round: bigint;
@@ -326,15 +329,12 @@ export interface RegisterVote {
 export interface RemoveHotKey {
   hot_key_to_remove: [] | [Principal];
 }
-export type Result = { Ok: null } | { Err: GovernanceErrorDetail };
-export type Result_1 =
-  | { Error: GovernanceErrorDetail }
-  | { NeuronId: NeuronId };
-export type Result_2 = { Ok: Neuron } | { Err: GovernanceErrorDetail };
-export type Result_3 =
-  | { Ok: RewardNodeProviders }
-  | { Err: GovernanceErrorDetail };
-export type Result_4 = { Ok: NeuronInfo } | { Err: GovernanceErrorDetail };
+export type Result = { Ok: null } | { Err: GovernanceError };
+export type Result_1 = { Error: GovernanceError } | { NeuronId: NeuronId };
+export type Result_2 = { Ok: Neuron } | { Err: GovernanceError };
+export type Result_3 = { Ok: RewardNodeProviders } | { Err: GovernanceError };
+export type Result_4 = { Ok: NeuronInfo } | { Err: GovernanceError };
+export type Result_5 = { Ok: NodeProvider } | { Err: GovernanceError };
 export interface RewardEvent {
   day_after_genesis: bigint;
   actual_timestamp_seconds: bigint;
@@ -350,6 +350,7 @@ export interface RewardNodeProvider {
   amount_e8s: bigint;
 }
 export interface RewardNodeProviders {
+  use_registry_derived_rewards: [] | [boolean];
   rewards: Array<RewardNodeProvider>;
 }
 export interface RewardToAccount {
@@ -365,6 +366,7 @@ export interface SetDissolveTimestamp {
   dissolve_timestamp_seconds: bigint;
 }
 export interface Spawn {
+  percentage_to_spawn: [] | [number];
   new_controller: [] | [Principal];
   nonce: [] | [bigint];
 }
@@ -394,20 +396,24 @@ export interface _SERVICE {
   claim_or_refresh_neuron_from_account: (
     arg_0: ClaimOrRefreshNeuronFromAccount
   ) => Promise<ClaimOrRefreshNeuronFromAccountResponse>;
+  get_build_metadata: () => Promise<string>;
   get_full_neuron: (arg_0: bigint) => Promise<Result_2>;
   get_full_neuron_by_id_or_subaccount: (
     arg_0: NeuronIdOrSubaccount
   ) => Promise<Result_2>;
   get_monthly_node_provider_rewards: () => Promise<Result_3>;
+  get_network_economics_parameters: () => Promise<NetworkEconomics>;
   get_neuron_ids: () => Promise<Array<bigint>>;
   get_neuron_info: (arg_0: bigint) => Promise<Result_4>;
   get_neuron_info_by_id_or_subaccount: (
     arg_0: NeuronIdOrSubaccount
   ) => Promise<Result_4>;
+  get_node_provider_by_caller: (arg_0: null) => Promise<Result_5>;
   get_pending_proposals: () => Promise<Array<ProposalInfo>>;
   get_proposal_info: (arg_0: bigint) => Promise<[] | [ProposalInfo]>;
   list_known_neurons: () => Promise<ListKnownNeuronsResponse>;
   list_neurons: (arg_0: ListNeurons) => Promise<ListNeuronsResponse>;
+  list_node_providers: () => Promise<ListNodeProvidersResponse>;
   list_proposals: (
     arg_0: ListProposalInfo
   ) => Promise<ListProposalInfoResponse>;