@dfinity/nns 0.5.0 → 0.6.0-nightly-2022-07-21

package/dist/candid/governance.idl.js

@@ -1,8 +1,30 @@
-/* Do not edit.  Compiled with ./scripts/compile-idl-js from candid/governance.did */
+/* Do not edit.  Compiled with ./scripts/compile-idl-js from packages/nns/candid/governance.did */
 export const idlFactory = ({ IDL }) => {
   const Proposal = IDL.Rec();
   const NeuronId = IDL.Record({ 'id' : IDL.Nat64 });
   const Followees = IDL.Record({ 'followees' : IDL.Vec(NeuronId) });
+  const AccountIdentifier = IDL.Record({ 'hash' : IDL.Vec(IDL.Nat8) });
+  const NodeProvider = IDL.Record({
+    'id' : IDL.Opt(IDL.Principal),
+    'reward_account' : IDL.Opt(AccountIdentifier),
+  });
+  const RewardToNeuron = IDL.Record({ 'dissolve_delay_seconds' : IDL.Nat64 });
+  const RewardToAccount = IDL.Record({
+    'to_account' : IDL.Opt(AccountIdentifier),
+  });
+  const RewardMode = IDL.Variant({
+    'RewardToNeuron' : RewardToNeuron,
+    'RewardToAccount' : RewardToAccount,
+  });
+  const RewardNodeProvider = IDL.Record({
+    'node_provider' : IDL.Opt(NodeProvider),
+    'reward_mode' : IDL.Opt(RewardMode),
+    'amount_e8s' : IDL.Nat64,
+  });
+  const MostRecentMonthlyNodeProviderRewards = IDL.Record({
+    'timestamp' : IDL.Nat64,
+    'rewards' : IDL.Vec(RewardNodeProvider),
+  });
   const GovernanceCachedMetrics = IDL.Record({
     'not_dissolving_neurons_e8s_buckets' : IDL.Vec(
       IDL.Tuple(IDL.Nat64, IDL.Float64)
@@ -29,11 +51,6 @@ export const idlFactory = ({ IDL }) => {
     'community_fund_total_staked_e8s' : IDL.Nat64,
     'timestamp_seconds' : IDL.Nat64,
   });
-  const AccountIdentifier = IDL.Record({ 'hash' : IDL.Vec(IDL.Nat8) });
-  const NodeProvider = IDL.Record({
-    'id' : IDL.Opt(IDL.Principal),
-    'reward_account' : IDL.Opt(AccountIdentifier),
-  });
   const NetworkEconomics = IDL.Record({
     'neuron_minimum_stake_e8s' : IDL.Nat64,
     'max_proposals_to_keep_per_topic' : IDL.Nat32,
@@ -115,6 +132,7 @@ export const idlFactory = ({ IDL }) => {
     'StartDissolving' : IDL.Record({}),
     'IncreaseDissolveDelay' : IncreaseDissolveDelay,
     'JoinCommunityFund' : IDL.Record({}),
+    'LeaveCommunityFund' : IDL.Record({}),
     'SetDissolveTimestamp' : SetDissolveTimestamp,
   });
   const Configure = IDL.Record({ 'operation' : IDL.Opt(Operation) });
@@ -162,18 +180,16 @@ export const idlFactory = ({ IDL }) => {
     'nns_function' : IDL.Int32,
     'payload' : IDL.Vec(IDL.Nat8),
   });
-  const RewardToNeuron = IDL.Record({ 'dissolve_delay_seconds' : IDL.Nat64 });
-  const RewardToAccount = IDL.Record({
-    'to_account' : IDL.Opt(AccountIdentifier),
+  const TimeWindow = IDL.Record({
+    'start_timestamp_seconds' : IDL.Nat64,
+    'end_timestamp_seconds' : IDL.Nat64,
   });
-  const RewardMode = IDL.Variant({
-    'RewardToNeuron' : RewardToNeuron,
-    'RewardToAccount' : RewardToAccount,
+  const SetOpenTimeWindowRequest = IDL.Record({
+    'open_time_window' : IDL.Opt(TimeWindow),
   });
-  const RewardNodeProvider = IDL.Record({
-    'node_provider' : IDL.Opt(NodeProvider),
-    'reward_mode' : IDL.Opt(RewardMode),
-    'amount_e8s' : IDL.Nat64,
+  const SetSnsTokenSwapOpenTimeWindow = IDL.Record({
+    'request' : IDL.Opt(SetOpenTimeWindowRequest),
+    'swap_canister_id' : IDL.Opt(IDL.Principal),
   });
   const SetDefaultFollowees = IDL.Record({
     'default_followees' : IDL.Vec(IDL.Tuple(IDL.Int32, Followees)),
@@ -196,6 +212,7 @@ export const idlFactory = ({ IDL }) => {
     'ManageNeuron' : ManageNeuron,
     'ExecuteNnsFunction' : ExecuteNnsFunction,
     'RewardNodeProvider' : RewardNodeProvider,
+    'SetSnsTokenSwapOpenTimeWindow' : SetSnsTokenSwapOpenTimeWindow,
     'SetDefaultFollowees' : SetDefaultFollowees,
     'RewardNodeProviders' : RewardNodeProviders,
     'ManageNetworkEconomics' : NetworkEconomics,
@@ -230,7 +247,7 @@ export const idlFactory = ({ IDL }) => {
     'executed_timestamp_seconds' : IDL.Nat64,
   });
   const Command_2 = IDL.Variant({
-    'Spawn' : Spawn,
+    'Spawn' : NeuronId,
     'Split' : Split,
     'Configure' : Configure,
     'Merge' : Merge,
@@ -269,19 +286,26 @@ export const idlFactory = ({ IDL }) => {
     'neuron_fees_e8s' : IDL.Nat64,
     'transfer' : IDL.Opt(NeuronStakeTransfer),
     'known_neuron_data' : IDL.Opt(KnownNeuronData),
+    'spawn_at_timestamp_seconds' : IDL.Opt(IDL.Nat64),
   });
   const Governance = IDL.Record({
     'default_followees' : IDL.Vec(IDL.Tuple(IDL.Int32, Followees)),
+    'most_recent_monthly_node_provider_rewards' : IDL.Opt(
+      MostRecentMonthlyNodeProviderRewards
+    ),
     'wait_for_quiet_threshold_seconds' : IDL.Nat64,
     'metrics' : IDL.Opt(GovernanceCachedMetrics),
+    'cached_daily_maturity_modulation' : IDL.Opt(IDL.Float64),
     'node_providers' : IDL.Vec(NodeProvider),
     'economics' : IDL.Opt(NetworkEconomics),
+    'spawning_neurons' : IDL.Opt(IDL.Bool),
     'latest_reward_event' : IDL.Opt(RewardEvent),
     'to_claim_transfers' : IDL.Vec(NeuronStakeTransfer),
     'short_voting_period_seconds' : IDL.Nat64,
     'proposals' : IDL.Vec(IDL.Tuple(IDL.Nat64, ProposalData)),
     'in_flight_commands' : IDL.Vec(IDL.Tuple(IDL.Nat64, NeuronInFlightCommand)),
     'neurons' : IDL.Vec(IDL.Tuple(IDL.Nat64, Neuron)),
+    'last_updated_maturity_modulation_cache' : IDL.Opt(IDL.Nat64),
     'genesis_timestamp_seconds' : IDL.Nat64,
   });
   const Result = IDL.Variant({ 'Ok' : IDL.Null, 'Err' : GovernanceError });
@@ -405,6 +429,11 @@ export const idlFactory = ({ IDL }) => {
         ['query'],
       ),
     'get_monthly_node_provider_rewards' : IDL.Func([], [Result_3], []),
+    'get_most_recent_monthly_node_provider_rewards' : IDL.Func(
+        [],
+        [IDL.Opt(MostRecentMonthlyNodeProviderRewards)],
+        ['query'],
+      ),
     'get_network_economics_parameters' : IDL.Func(
         [],
         [NetworkEconomics],
@@ -445,6 +474,28 @@ export const init = ({ IDL }) => {
   const Proposal = IDL.Rec();
   const NeuronId = IDL.Record({ 'id' : IDL.Nat64 });
   const Followees = IDL.Record({ 'followees' : IDL.Vec(NeuronId) });
+  const AccountIdentifier = IDL.Record({ 'hash' : IDL.Vec(IDL.Nat8) });
+  const NodeProvider = IDL.Record({
+    'id' : IDL.Opt(IDL.Principal),
+    'reward_account' : IDL.Opt(AccountIdentifier),
+  });
+  const RewardToNeuron = IDL.Record({ 'dissolve_delay_seconds' : IDL.Nat64 });
+  const RewardToAccount = IDL.Record({
+    'to_account' : IDL.Opt(AccountIdentifier),
+  });
+  const RewardMode = IDL.Variant({
+    'RewardToNeuron' : RewardToNeuron,
+    'RewardToAccount' : RewardToAccount,
+  });
+  const RewardNodeProvider = IDL.Record({
+    'node_provider' : IDL.Opt(NodeProvider),
+    'reward_mode' : IDL.Opt(RewardMode),
+    'amount_e8s' : IDL.Nat64,
+  });
+  const MostRecentMonthlyNodeProviderRewards = IDL.Record({
+    'timestamp' : IDL.Nat64,
+    'rewards' : IDL.Vec(RewardNodeProvider),
+  });
   const GovernanceCachedMetrics = IDL.Record({
     'not_dissolving_neurons_e8s_buckets' : IDL.Vec(
       IDL.Tuple(IDL.Nat64, IDL.Float64)
@@ -471,11 +522,6 @@ export const init = ({ IDL }) => {
     'community_fund_total_staked_e8s' : IDL.Nat64,
     'timestamp_seconds' : IDL.Nat64,
   });
-  const AccountIdentifier = IDL.Record({ 'hash' : IDL.Vec(IDL.Nat8) });
-  const NodeProvider = IDL.Record({
-    'id' : IDL.Opt(IDL.Principal),
-    'reward_account' : IDL.Opt(AccountIdentifier),
-  });
   const NetworkEconomics = IDL.Record({
     'neuron_minimum_stake_e8s' : IDL.Nat64,
     'max_proposals_to_keep_per_topic' : IDL.Nat32,
@@ -557,6 +603,7 @@ export const init = ({ IDL }) => {
     'StartDissolving' : IDL.Record({}),
     'IncreaseDissolveDelay' : IncreaseDissolveDelay,
     'JoinCommunityFund' : IDL.Record({}),
+    'LeaveCommunityFund' : IDL.Record({}),
     'SetDissolveTimestamp' : SetDissolveTimestamp,
   });
   const Configure = IDL.Record({ 'operation' : IDL.Opt(Operation) });
@@ -604,18 +651,16 @@ export const init = ({ IDL }) => {
     'nns_function' : IDL.Int32,
     'payload' : IDL.Vec(IDL.Nat8),
   });
-  const RewardToNeuron = IDL.Record({ 'dissolve_delay_seconds' : IDL.Nat64 });
-  const RewardToAccount = IDL.Record({
-    'to_account' : IDL.Opt(AccountIdentifier),
+  const TimeWindow = IDL.Record({
+    'start_timestamp_seconds' : IDL.Nat64,
+    'end_timestamp_seconds' : IDL.Nat64,
   });
-  const RewardMode = IDL.Variant({
-    'RewardToNeuron' : RewardToNeuron,
-    'RewardToAccount' : RewardToAccount,
+  const SetOpenTimeWindowRequest = IDL.Record({
+    'open_time_window' : IDL.Opt(TimeWindow),
   });
-  const RewardNodeProvider = IDL.Record({
-    'node_provider' : IDL.Opt(NodeProvider),
-    'reward_mode' : IDL.Opt(RewardMode),
-    'amount_e8s' : IDL.Nat64,
+  const SetSnsTokenSwapOpenTimeWindow = IDL.Record({
+    'request' : IDL.Opt(SetOpenTimeWindowRequest),
+    'swap_canister_id' : IDL.Opt(IDL.Principal),
   });
   const SetDefaultFollowees = IDL.Record({
     'default_followees' : IDL.Vec(IDL.Tuple(IDL.Int32, Followees)),
@@ -638,6 +683,7 @@ export const init = ({ IDL }) => {
     'ManageNeuron' : ManageNeuron,
     'ExecuteNnsFunction' : ExecuteNnsFunction,
     'RewardNodeProvider' : RewardNodeProvider,
+    'SetSnsTokenSwapOpenTimeWindow' : SetSnsTokenSwapOpenTimeWindow,
     'SetDefaultFollowees' : SetDefaultFollowees,
     'RewardNodeProviders' : RewardNodeProviders,
     'ManageNetworkEconomics' : NetworkEconomics,
@@ -672,7 +718,7 @@ export const init = ({ IDL }) => {
     'executed_timestamp_seconds' : IDL.Nat64,
   });
   const Command_2 = IDL.Variant({
-    'Spawn' : Spawn,
+    'Spawn' : NeuronId,
     'Split' : Split,
     'Configure' : Configure,
     'Merge' : Merge,
@@ -711,19 +757,26 @@ export const init = ({ IDL }) => {
     'neuron_fees_e8s' : IDL.Nat64,
     'transfer' : IDL.Opt(NeuronStakeTransfer),
     'known_neuron_data' : IDL.Opt(KnownNeuronData),
+    'spawn_at_timestamp_seconds' : IDL.Opt(IDL.Nat64),
   });
   const Governance = IDL.Record({
     'default_followees' : IDL.Vec(IDL.Tuple(IDL.Int32, Followees)),
+    'most_recent_monthly_node_provider_rewards' : IDL.Opt(
+      MostRecentMonthlyNodeProviderRewards
+    ),
     'wait_for_quiet_threshold_seconds' : IDL.Nat64,
     'metrics' : IDL.Opt(GovernanceCachedMetrics),
+    'cached_daily_maturity_modulation' : IDL.Opt(IDL.Float64),
     'node_providers' : IDL.Vec(NodeProvider),
     'economics' : IDL.Opt(NetworkEconomics),
+    'spawning_neurons' : IDL.Opt(IDL.Bool),
     'latest_reward_event' : IDL.Opt(RewardEvent),
     'to_claim_transfers' : IDL.Vec(NeuronStakeTransfer),
     'short_voting_period_seconds' : IDL.Nat64,
     'proposals' : IDL.Vec(IDL.Tuple(IDL.Nat64, ProposalData)),
     'in_flight_commands' : IDL.Vec(IDL.Tuple(IDL.Nat64, NeuronInFlightCommand)),
     'neurons' : IDL.Vec(IDL.Tuple(IDL.Nat64, Neuron)),
+    'last_updated_maturity_modulation_cache' : IDL.Opt(IDL.Nat64),
     'genesis_timestamp_seconds' : IDL.Nat64,
   });
   return [Governance];

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

@@ -1,4 +1,4 @@
-/* Do not edit.  Compiled with ./scripts/compile-idl-js from candid/ledger.did */
+/* Do not edit.  Compiled with ./scripts/compile-idl-js from packages/nns/candid/ledger.did */
 export const idlFactory = ({ IDL }) => {
   const BlockIndex = IDL.Nat64;
   const GetBlocksArgs = IDL.Record({

package/dist/candid/{ledgerTypes.d.ts → ledger.d.ts}

@@ -1,9 +1,4 @@
-/* Do not edit.  Compiled with Canlist https://k7gat-daaaa-aaaae-qaahq-cai.ic0.app/ from candid/genesis_token.did */
-// Added manually the IDL part
-import type { IDL } from "@dfinity/candid";
 import type { Principal } from "@dfinity/principal";
-export const idlFactory: IDL.InterfaceFactory;
-
 export interface AccountBalanceArgs {
   account: AccountIdentifier;
 }

package/dist/candid/ledger.did

@@ -1,4 +1,4 @@
-// https://github.com/dfinity/ic/blob/331fc1ae92e23ef5d1c218595aea199a533cc689/rs/rosetta-api/ledger_canister/ledger.did
+// Generated from IC repo commit d1f1bbefafa90fd444a9088e377bf68c78ee0f3f 'rs/rosetta-api/ledger_canister/ledger.did' by import-candid
 // This is the official Ledger interface that is guaranteed to be backward compatible.
 
 // Amount of tokens, measured in 10^-8 of a token.
@@ -247,4 +247,4 @@ service : {
 
   // Returns the existing archive canisters information.
   archives : () -> (Archives) query;
-}
+}

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

@@ -1,5 +1,2 @@
 import type { IDL } from "@dfinity/candid";
-import { _SERVICE } from "./ledgerTypes";
 export const idlFactory: IDL.InterfaceFactory;
-
-export { _SERVICE as LedgerService };

package/dist/candid/ledger.idl.js

@@ -1,4 +1,4 @@
-/* Do not edit.  Compiled with ./scripts/compile-idl-js from candid/ledger.did */
+/* Do not edit.  Compiled with ./scripts/compile-idl-js from packages/nns/candid/ledger.did */
 export const idlFactory = ({ IDL }) => {
   const AccountIdentifier = IDL.Vec(IDL.Nat8);
   const AccountBalanceArgs = IDL.Record({ 'account' : AccountIdentifier });

package/dist/candid/sns_wasm.certified.idl.d.ts

@@ -0,0 +1,2 @@
+import type { IDL } from "@dfinity/candid";
+export const idlFactory: IDL.InterfaceFactory;

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

@@ -0,0 +1,117 @@
+/* Do not edit.  Compiled with ./scripts/compile-idl-js from packages/nns/candid/sns_wasm.did */
+export const idlFactory = ({ IDL }) => {
+  const SnsWasmCanisterInitPayload = IDL.Record({
+    'sns_subnet_ids' : IDL.Vec(IDL.Principal),
+  });
+  const SnsWasm = IDL.Record({
+    'wasm' : IDL.Vec(IDL.Nat8),
+    'canister_type' : IDL.Int32,
+  });
+  const AddWasmRequest = IDL.Record({
+    'hash' : IDL.Vec(IDL.Nat8),
+    'wasm' : IDL.Opt(SnsWasm),
+  });
+  const SnsWasmError = IDL.Record({ 'message' : IDL.Text });
+  const Result = IDL.Variant({
+    'Error' : SnsWasmError,
+    'Hash' : IDL.Vec(IDL.Nat8),
+  });
+  const AddWasmResponse = IDL.Record({ 'result' : IDL.Opt(Result) });
+  const TreasuryDistribution = IDL.Record({ 'total_e8s' : IDL.Nat64 });
+  const NeuronDistribution = IDL.Record({
+    'controller' : IDL.Opt(IDL.Principal),
+    'stake_e8s' : IDL.Nat64,
+  });
+  const DeveloperDistribution = IDL.Record({
+    'developer_neurons' : IDL.Vec(NeuronDistribution),
+  });
+  const AirdropDistribution = IDL.Record({
+    'airdrop_neurons' : IDL.Vec(NeuronDistribution),
+  });
+  const SwapDistribution = IDL.Record({
+    'total_e8s' : IDL.Nat64,
+    'initial_swap_amount_e8s' : IDL.Nat64,
+  });
+  const FractionalDeveloperVotingPower = IDL.Record({
+    'treasury_distribution' : IDL.Opt(TreasuryDistribution),
+    'developer_distribution' : IDL.Opt(DeveloperDistribution),
+    'airdrop_distribution' : IDL.Opt(AirdropDistribution),
+    'swap_distribution' : IDL.Opt(SwapDistribution),
+  });
+  const InitialTokenDistribution = IDL.Variant({
+    'FractionalDeveloperVotingPower' : FractionalDeveloperVotingPower,
+  });
+  const SnsInitPayload = IDL.Record({
+    'min_participant_icp_e8s' : IDL.Opt(IDL.Nat64),
+    'fallback_controller_principal_ids' : IDL.Vec(IDL.Text),
+    'token_symbol' : IDL.Opt(IDL.Text),
+    'max_icp_e8s' : IDL.Opt(IDL.Nat64),
+    'neuron_minimum_stake_e8s' : IDL.Opt(IDL.Nat64),
+    'min_participants' : IDL.Opt(IDL.Nat32),
+    'transaction_fee_e8s' : IDL.Opt(IDL.Nat64),
+    'initial_token_distribution' : IDL.Opt(InitialTokenDistribution),
+    'token_name' : IDL.Opt(IDL.Text),
+    'max_participant_icp_e8s' : IDL.Opt(IDL.Nat64),
+    'proposal_reject_cost_e8s' : IDL.Opt(IDL.Nat64),
+    'min_icp_e8s' : IDL.Opt(IDL.Nat64),
+  });
+  const DeployNewSnsRequest = IDL.Record({
+    'sns_init_payload' : IDL.Opt(SnsInitPayload),
+  });
+  const SnsCanisterIds = IDL.Record({
+    'root' : IDL.Opt(IDL.Principal),
+    'swap' : IDL.Opt(IDL.Principal),
+    'ledger' : IDL.Opt(IDL.Principal),
+    'governance' : IDL.Opt(IDL.Principal),
+  });
+  const DeployNewSnsResponse = IDL.Record({
+    'subnet_id' : IDL.Opt(IDL.Principal),
+    'error' : IDL.Opt(SnsWasmError),
+    'canisters' : IDL.Opt(SnsCanisterIds),
+  });
+  const SnsVersion = IDL.Record({
+    'root_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'swap_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'ledger_wasm_hash' : IDL.Vec(IDL.Nat8),
+    'governance_wasm_hash' : IDL.Vec(IDL.Nat8),
+  });
+  const GetNextSnsVersionRequest = IDL.Record({
+    'current_version' : IDL.Opt(SnsVersion),
+  });
+  const GetNextSnsVersionResponse = IDL.Record({
+    'next_version' : IDL.Opt(SnsVersion),
+  });
+  const GetWasmRequest = IDL.Record({ 'hash' : IDL.Vec(IDL.Nat8) });
+  const GetWasmResponse = IDL.Record({ 'wasm' : IDL.Opt(SnsWasm) });
+  const DeployedSns = IDL.Record({
+    'root_canister_id' : IDL.Opt(IDL.Principal),
+  });
+  const ListDeployedSnsesResponse = IDL.Record({
+    'instances' : IDL.Vec(DeployedSns),
+  });
+  return IDL.Service({
+    'add_wasm' : IDL.Func([AddWasmRequest], [AddWasmResponse], []),
+    'deploy_new_sns' : IDL.Func(
+        [DeployNewSnsRequest],
+        [DeployNewSnsResponse],
+        [],
+      ),
+    'get_next_sns_version' : IDL.Func(
+        [GetNextSnsVersionRequest],
+        [GetNextSnsVersionResponse],
+        [],
+      ),
+    'get_wasm' : IDL.Func([GetWasmRequest], [GetWasmResponse], []),
+    'list_deployed_snses' : IDL.Func(
+        [IDL.Record({})],
+        [ListDeployedSnsesResponse],
+        [],
+      ),
+  });
+};
+export const init = ({ IDL }) => {
+  const SnsWasmCanisterInitPayload = IDL.Record({
+    'sns_subnet_ids' : IDL.Vec(IDL.Principal),
+  });
+  return [SnsWasmCanisterInitPayload];
+};

package/dist/candid/sns_wasm.d.ts

@@ -0,0 +1,106 @@
+import type { Principal } from "@dfinity/principal";
+export interface AddWasmRequest {
+  hash: Array<number>;
+  wasm: [] | [SnsWasm];
+}
+export interface AddWasmResponse {
+  result: [] | [Result];
+}
+export interface AirdropDistribution {
+  airdrop_neurons: Array<NeuronDistribution>;
+}
+export interface DeployNewSnsRequest {
+  sns_init_payload: [] | [SnsInitPayload];
+}
+export interface DeployNewSnsResponse {
+  subnet_id: [] | [Principal];
+  error: [] | [SnsWasmError];
+  canisters: [] | [SnsCanisterIds];
+}
+export interface DeployedSns {
+  root_canister_id: [] | [Principal];
+}
+export interface DeveloperDistribution {
+  developer_neurons: Array<NeuronDistribution>;
+}
+export interface FractionalDeveloperVotingPower {
+  treasury_distribution: [] | [TreasuryDistribution];
+  developer_distribution: [] | [DeveloperDistribution];
+  airdrop_distribution: [] | [AirdropDistribution];
+  swap_distribution: [] | [SwapDistribution];
+}
+export interface GetNextSnsVersionRequest {
+  current_version: [] | [SnsVersion];
+}
+export interface GetNextSnsVersionResponse {
+  next_version: [] | [SnsVersion];
+}
+export interface GetWasmRequest {
+  hash: Array<number>;
+}
+export interface GetWasmResponse {
+  wasm: [] | [SnsWasm];
+}
+export type InitialTokenDistribution = {
+  FractionalDeveloperVotingPower: FractionalDeveloperVotingPower;
+};
+export interface ListDeployedSnsesResponse {
+  instances: Array<DeployedSns>;
+}
+export interface NeuronDistribution {
+  controller: [] | [Principal];
+  stake_e8s: bigint;
+}
+export type Result = { Error: SnsWasmError } | { Hash: Array<number> };
+export interface SnsCanisterIds {
+  root: [] | [Principal];
+  swap: [] | [Principal];
+  ledger: [] | [Principal];
+  governance: [] | [Principal];
+}
+export interface SnsInitPayload {
+  min_participant_icp_e8s: [] | [bigint];
+  fallback_controller_principal_ids: Array<string>;
+  token_symbol: [] | [string];
+  max_icp_e8s: [] | [bigint];
+  neuron_minimum_stake_e8s: [] | [bigint];
+  min_participants: [] | [number];
+  transaction_fee_e8s: [] | [bigint];
+  initial_token_distribution: [] | [InitialTokenDistribution];
+  token_name: [] | [string];
+  max_participant_icp_e8s: [] | [bigint];
+  proposal_reject_cost_e8s: [] | [bigint];
+  min_icp_e8s: [] | [bigint];
+}
+export interface SnsVersion {
+  root_wasm_hash: Array<number>;
+  swap_wasm_hash: Array<number>;
+  ledger_wasm_hash: Array<number>;
+  governance_wasm_hash: Array<number>;
+}
+export interface SnsWasm {
+  wasm: Array<number>;
+  canister_type: number;
+}
+export interface SnsWasmCanisterInitPayload {
+  sns_subnet_ids: Array<Principal>;
+}
+export interface SnsWasmError {
+  message: string;
+}
+export interface SwapDistribution {
+  total_e8s: bigint;
+  initial_swap_amount_e8s: bigint;
+}
+export interface TreasuryDistribution {
+  total_e8s: bigint;
+}
+export interface _SERVICE {
+  add_wasm: (arg_0: AddWasmRequest) => Promise<AddWasmResponse>;
+  deploy_new_sns: (arg_0: DeployNewSnsRequest) => Promise<DeployNewSnsResponse>;
+  get_next_sns_version: (
+    arg_0: GetNextSnsVersionRequest
+  ) => Promise<GetNextSnsVersionResponse>;
+  get_wasm: (arg_0: GetWasmRequest) => Promise<GetWasmResponse>;
+  list_deployed_snses: (arg_0: {}) => Promise<ListDeployedSnsesResponse>;
+}

package/dist/candid/sns_wasm.did

@@ -0,0 +1,76 @@
+// Generated from IC repo commit d1f1bbefafa90fd444a9088e377bf68c78ee0f3f 'rs/nns/sns-wasm/canister/sns-wasm.did' by import-candid
+type AddWasmRequest = record { hash : vec nat8; wasm : opt SnsWasm };
+type AddWasmResponse = record { result : opt Result };
+type AirdropDistribution = record { airdrop_neurons : vec NeuronDistribution };
+type DeployNewSnsRequest = record { sns_init_payload : opt SnsInitPayload };
+type DeployNewSnsResponse = record {
+  subnet_id : opt principal;
+  error : opt SnsWasmError;
+  canisters : opt SnsCanisterIds;
+};
+type DeployedSns = record { root_canister_id : opt principal };
+type DeveloperDistribution = record {
+  developer_neurons : vec NeuronDistribution;
+};
+type FractionalDeveloperVotingPower = record {
+  treasury_distribution : opt TreasuryDistribution;
+  developer_distribution : opt DeveloperDistribution;
+  airdrop_distribution : opt AirdropDistribution;
+  swap_distribution : opt SwapDistribution;
+};
+type GetNextSnsVersionRequest = record { current_version : opt SnsVersion };
+type GetNextSnsVersionResponse = record { next_version : opt SnsVersion };
+type GetWasmRequest = record { hash : vec nat8 };
+type GetWasmResponse = record { wasm : opt SnsWasm };
+type InitialTokenDistribution = variant {
+  FractionalDeveloperVotingPower : FractionalDeveloperVotingPower;
+};
+type ListDeployedSnsesResponse = record { instances : vec DeployedSns };
+type NeuronDistribution = record {
+  controller : opt principal;
+  stake_e8s : nat64;
+};
+type Result = variant { Error : SnsWasmError; Hash : vec nat8 };
+type SnsCanisterIds = record {
+  root : opt principal;
+  swap : opt principal;
+  ledger : opt principal;
+  governance : opt principal;
+};
+type SnsInitPayload = record {
+  min_participant_icp_e8s : opt nat64;
+  fallback_controller_principal_ids : vec text;
+  token_symbol : opt text;
+  max_icp_e8s : opt nat64;
+  neuron_minimum_stake_e8s : opt nat64;
+  min_participants : opt nat32;
+  transaction_fee_e8s : opt nat64;
+  initial_token_distribution : opt InitialTokenDistribution;
+  token_name : opt text;
+  max_participant_icp_e8s : opt nat64;
+  proposal_reject_cost_e8s : opt nat64;
+  min_icp_e8s : opt nat64;
+};
+type SnsVersion = record {
+  root_wasm_hash : vec nat8;
+  swap_wasm_hash : vec nat8;
+  ledger_wasm_hash : vec nat8;
+  governance_wasm_hash : vec nat8;
+};
+type SnsWasm = record { wasm : vec nat8; canister_type : int32 };
+type SnsWasmCanisterInitPayload = record { sns_subnet_ids : vec principal };
+type SnsWasmError = record { message : text };
+type SwapDistribution = record {
+  total_e8s : nat64;
+  initial_swap_amount_e8s : nat64;
+};
+type TreasuryDistribution = record { total_e8s : nat64 };
+service : (SnsWasmCanisterInitPayload) -> {
+  add_wasm : (AddWasmRequest) -> (AddWasmResponse);
+  deploy_new_sns : (DeployNewSnsRequest) -> (DeployNewSnsResponse);
+  get_next_sns_version : (GetNextSnsVersionRequest) -> (
+      GetNextSnsVersionResponse,
+    ) query;
+  get_wasm : (GetWasmRequest) -> (GetWasmResponse) query;
+  list_deployed_snses : (record {}) -> (ListDeployedSnsesResponse) query;
+}

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

@@ -0,0 +1,2 @@
+import type { IDL } from "@dfinity/candid";
+export const idlFactory: IDL.InterfaceFactory;