@dfinity/nns 0.2.1 → 0.2.2

package/dist/candid/nns_dapp.did

@@ -0,0 +1,240 @@
+// Generated from nns-dapp repo commit a4f91518433f99b0c127fe037376d06190d6e79e by nns-dapp.update.sh
+type AccountIdentifier = text;
+type BlockHeight = nat64;
+type CanisterId = principal;
+type ICPTs = record { e8s: nat64; };
+type Memo = nat64;
+type NeuronId = nat64;
+type SubAccount = vec nat8;
+
+type AccountDetails =
+    record {
+        "principal": principal;
+        account_identifier: AccountIdentifier;
+        sub_accounts: vec SubAccountDetails;
+        hardware_wallet_accounts: vec HardwareWalletAccountDetails;
+    };
+
+type SubAccountDetails =
+    record {
+        name: text;
+        sub_account: SubAccount;
+        account_identifier: AccountIdentifier;
+    };
+
+type HardwareWalletAccountDetails =
+    record {
+        name: text;
+        "principal": principal;
+        account_identifier: AccountIdentifier;
+    };
+
+type GetAccountResponse =
+    variant {
+        Ok: AccountDetails;
+        AccountNotFound;
+    };
+
+type Timestamp =
+    record {
+        timestamp_nanos: nat64;
+    };
+
+type GetTransactionsRequest =
+    record {
+        account_identifier: AccountIdentifier;
+        offset: nat32;
+        page_size: nat8;
+    };
+
+type GetTransactionsResponse =
+    record {
+        transactions: vec Transaction;
+        total: nat32;
+    };
+
+type Send =
+    record {
+        to: AccountIdentifier;
+        amount: ICPTs;
+        fee: ICPTs;
+    };
+
+type Receive =
+    record {
+        from: AccountIdentifier;
+        amount: ICPTs;
+        fee: ICPTs;
+    };
+
+type Transfer =
+    variant {
+        Burn: record { amount: ICPTs; };
+        Mint: record { amount: ICPTs; };
+        Send: Send;
+        Receive: Receive;
+    };
+
+type Transaction =
+    record {
+        block_height: BlockHeight;
+        timestamp: Timestamp;
+        memo: nat64;
+        transfer: Transfer;
+        transaction_type: opt TransactionType;
+    };
+
+type TransactionType =
+    variant {
+        Burn;
+        Mint;
+        Send;
+        StakeNeuron;
+        StakeNeuronNotification;
+        TopUpNeuron;
+        CreateCanister;
+        TopUpCanister: CanisterId;
+    };
+
+type CreateSubAccountResponse =
+    variant {
+        Ok: SubAccountDetails;
+        AccountNotFound;
+        SubAccountLimitExceeded;
+        NameTooLong;
+    };
+
+type RenameSubAccountRequest =
+    record {
+        account_identifier: AccountIdentifier;
+        new_name: text;
+    };
+
+type RenameSubAccountResponse =
+    variant {
+        Ok;
+        AccountNotFound;
+        SubAccountNotFound;
+        NameTooLong;
+    };
+
+type RegisterHardwareWalletRequest =
+    record {
+        name: text;
+        "principal": principal;
+    };
+
+type RegisterHardwareWalletResponse =
+    variant {
+        Ok;
+        AccountNotFound;
+        HardwareWalletAlreadyRegistered;
+        HardwareWalletLimitExceeded;
+        NameTooLong;
+    };
+
+type CanisterDetails =
+    record {
+        name: text;
+        canister_id: principal;
+    };
+
+type AttachCanisterRequest =
+    record {
+        name: text;
+        canister_id: principal;
+    };
+
+type AttachCanisterResponse =
+    variant {
+        Ok;
+        CanisterLimitExceeded;
+        CanisterAlreadyAttached;
+        NameAlreadyTaken;
+        NameTooLong;
+    };
+
+type DetachCanisterRequest =
+    record {
+        canister_id: principal;
+    };
+
+type DetachCanisterResponse =
+    variant {
+        Ok;
+        CanisterNotFound;
+    };
+
+type MultiPartTransactionStatus =
+    variant {
+        NeuronCreated: NeuronId;
+        CanisterCreated: CanisterId;
+        Complete;
+        Refunded: record { BlockHeight; text; };
+        Error: text;
+        ErrorWithRefundPending: text;
+        NotFound;
+        PendingSync;
+        Queued;
+    };
+
+type MultiPartTransactionError =
+    record {
+        block_height: BlockHeight;
+        error_message: text;
+    };
+
+type Stats =
+    record {
+        accounts_count: nat64;
+        sub_accounts_count: nat64;
+        hardware_wallet_accounts_count: nat64;
+        transactions_count: nat64;
+        block_height_synced_up_to: opt nat64;
+        earliest_transaction_timestamp_nanos: nat64;
+        earliest_transaction_block_height: BlockHeight;
+        latest_transaction_timestamp_nanos: nat64;
+        latest_transaction_block_height: BlockHeight;
+        seconds_since_last_ledger_sync: nat64;
+        neurons_created_count: nat64;
+        neurons_topped_up_count: nat64;
+        transactions_to_process_queue_length: nat32;
+    };
+
+type HeaderField =
+    record {
+        text; text;
+    };
+
+type HttpRequest =
+    record {
+        method: text;
+        url: text;
+        headers: vec HeaderField;
+        body: blob;
+    };
+
+type HttpResponse =
+    record {
+        status_code: nat16;
+        headers: vec HeaderField;
+        body: blob;
+    };
+
+service : {
+    get_account: () -> (GetAccountResponse) query;
+    add_account: () -> (AccountIdentifier);
+    get_transactions: (GetTransactionsRequest) -> (GetTransactionsResponse) query;
+    create_sub_account: (text) -> (CreateSubAccountResponse);
+    rename_sub_account: (RenameSubAccountRequest) -> (RenameSubAccountResponse);
+    register_hardware_wallet: (RegisterHardwareWalletRequest) -> (RegisterHardwareWalletResponse);
+    get_canisters: () -> (vec CanisterDetails) query;
+    attach_canister: (AttachCanisterRequest) -> (AttachCanisterResponse);
+    detach_canister: (DetachCanisterRequest) -> (DetachCanisterResponse);
+    get_multi_part_transaction_status: (principal, BlockHeight) -> (MultiPartTransactionStatus) query;
+    get_multi_part_transaction_errors: () -> (vec MultiPartTransactionError) query;
+    get_stats: () -> (Stats) query;
+
+    http_request: (request: HttpRequest) -> (HttpResponse) query;
+    add_stable_asset: (asset: blob) -> ();
+}

package/dist/candid/nns_dapp.idl.js

@@ -0,0 +1,206 @@
+/* Do not edit.  Compiled with ./scripts/compile-idl-js from candid/nns_dapp.did */
+export const idlFactory = ({ IDL }) => {
+  const AccountIdentifier = IDL.Text;
+  const AttachCanisterRequest = IDL.Record({
+    'name' : IDL.Text,
+    'canister_id' : IDL.Principal,
+  });
+  const AttachCanisterResponse = IDL.Variant({
+    'Ok' : IDL.Null,
+    'CanisterAlreadyAttached' : IDL.Null,
+    'NameAlreadyTaken' : IDL.Null,
+    'NameTooLong' : IDL.Null,
+    'CanisterLimitExceeded' : IDL.Null,
+  });
+  const SubAccount = IDL.Vec(IDL.Nat8);
+  const SubAccountDetails = IDL.Record({
+    'name' : IDL.Text,
+    'sub_account' : SubAccount,
+    'account_identifier' : AccountIdentifier,
+  });
+  const CreateSubAccountResponse = IDL.Variant({
+    'Ok' : SubAccountDetails,
+    'AccountNotFound' : IDL.Null,
+    'NameTooLong' : IDL.Null,
+    'SubAccountLimitExceeded' : IDL.Null,
+  });
+  const DetachCanisterRequest = IDL.Record({ 'canister_id' : IDL.Principal });
+  const DetachCanisterResponse = IDL.Variant({
+    'Ok' : IDL.Null,
+    'CanisterNotFound' : IDL.Null,
+  });
+  const HardwareWalletAccountDetails = IDL.Record({
+    'principal' : IDL.Principal,
+    'name' : IDL.Text,
+    'account_identifier' : AccountIdentifier,
+  });
+  const AccountDetails = IDL.Record({
+    'principal' : IDL.Principal,
+    'account_identifier' : AccountIdentifier,
+    'hardware_wallet_accounts' : IDL.Vec(HardwareWalletAccountDetails),
+    'sub_accounts' : IDL.Vec(SubAccountDetails),
+  });
+  const GetAccountResponse = IDL.Variant({
+    'Ok' : AccountDetails,
+    'AccountNotFound' : IDL.Null,
+  });
+  const CanisterDetails = IDL.Record({
+    'name' : IDL.Text,
+    'canister_id' : IDL.Principal,
+  });
+  const BlockHeight = IDL.Nat64;
+  const MultiPartTransactionError = IDL.Record({
+    'error_message' : IDL.Text,
+    'block_height' : BlockHeight,
+  });
+  const CanisterId = IDL.Principal;
+  const NeuronId = IDL.Nat64;
+  const MultiPartTransactionStatus = IDL.Variant({
+    'Queued' : IDL.Null,
+    'Error' : IDL.Text,
+    'Refunded' : IDL.Tuple(BlockHeight, IDL.Text),
+    'CanisterCreated' : CanisterId,
+    'Complete' : IDL.Null,
+    'NotFound' : IDL.Null,
+    'NeuronCreated' : NeuronId,
+    'PendingSync' : IDL.Null,
+    'ErrorWithRefundPending' : IDL.Text,
+  });
+  const Stats = IDL.Record({
+    'latest_transaction_block_height' : BlockHeight,
+    'seconds_since_last_ledger_sync' : IDL.Nat64,
+    'sub_accounts_count' : IDL.Nat64,
+    'neurons_topped_up_count' : IDL.Nat64,
+    'transactions_to_process_queue_length' : IDL.Nat32,
+    'neurons_created_count' : IDL.Nat64,
+    'hardware_wallet_accounts_count' : IDL.Nat64,
+    'accounts_count' : IDL.Nat64,
+    'earliest_transaction_block_height' : BlockHeight,
+    'transactions_count' : IDL.Nat64,
+    'block_height_synced_up_to' : IDL.Opt(IDL.Nat64),
+    'latest_transaction_timestamp_nanos' : IDL.Nat64,
+    'earliest_transaction_timestamp_nanos' : IDL.Nat64,
+  });
+  const GetTransactionsRequest = IDL.Record({
+    'page_size' : IDL.Nat8,
+    'offset' : IDL.Nat32,
+    'account_identifier' : AccountIdentifier,
+  });
+  const TransactionType = IDL.Variant({
+    'Burn' : IDL.Null,
+    'Mint' : IDL.Null,
+    'Send' : IDL.Null,
+    'StakeNeuronNotification' : IDL.Null,
+    'TopUpCanister' : CanisterId,
+    'CreateCanister' : IDL.Null,
+    'TopUpNeuron' : IDL.Null,
+    'StakeNeuron' : IDL.Null,
+  });
+  const Timestamp = IDL.Record({ 'timestamp_nanos' : IDL.Nat64 });
+  const ICPTs = IDL.Record({ 'e8s' : IDL.Nat64 });
+  const Send = IDL.Record({
+    'to' : AccountIdentifier,
+    'fee' : ICPTs,
+    'amount' : ICPTs,
+  });
+  const Receive = IDL.Record({
+    'fee' : ICPTs,
+    'from' : AccountIdentifier,
+    'amount' : ICPTs,
+  });
+  const Transfer = IDL.Variant({
+    'Burn' : IDL.Record({ 'amount' : ICPTs }),
+    'Mint' : IDL.Record({ 'amount' : ICPTs }),
+    'Send' : Send,
+    'Receive' : Receive,
+  });
+  const Transaction = IDL.Record({
+    'transaction_type' : IDL.Opt(TransactionType),
+    'memo' : IDL.Nat64,
+    'timestamp' : Timestamp,
+    'block_height' : BlockHeight,
+    'transfer' : Transfer,
+  });
+  const GetTransactionsResponse = IDL.Record({
+    'total' : IDL.Nat32,
+    'transactions' : IDL.Vec(Transaction),
+  });
+  const HeaderField = IDL.Tuple(IDL.Text, IDL.Text);
+  const HttpRequest = IDL.Record({
+    'url' : IDL.Text,
+    'method' : IDL.Text,
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(HeaderField),
+  });
+  const HttpResponse = IDL.Record({
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(HeaderField),
+    'status_code' : IDL.Nat16,
+  });
+  const RegisterHardwareWalletRequest = IDL.Record({
+    'principal' : IDL.Principal,
+    'name' : IDL.Text,
+  });
+  const RegisterHardwareWalletResponse = IDL.Variant({
+    'Ok' : IDL.Null,
+    'AccountNotFound' : IDL.Null,
+    'HardwareWalletAlreadyRegistered' : IDL.Null,
+    'HardwareWalletLimitExceeded' : IDL.Null,
+    'NameTooLong' : IDL.Null,
+  });
+  const RenameSubAccountRequest = IDL.Record({
+    'new_name' : IDL.Text,
+    'account_identifier' : AccountIdentifier,
+  });
+  const RenameSubAccountResponse = IDL.Variant({
+    'Ok' : IDL.Null,
+    'AccountNotFound' : IDL.Null,
+    'SubAccountNotFound' : IDL.Null,
+    'NameTooLong' : IDL.Null,
+  });
+  return IDL.Service({
+    'add_account' : IDL.Func([], [AccountIdentifier], []),
+    'add_stable_asset' : IDL.Func([IDL.Vec(IDL.Nat8)], [], []),
+    'attach_canister' : IDL.Func(
+        [AttachCanisterRequest],
+        [AttachCanisterResponse],
+        [],
+      ),
+    'create_sub_account' : IDL.Func([IDL.Text], [CreateSubAccountResponse], []),
+    'detach_canister' : IDL.Func(
+        [DetachCanisterRequest],
+        [DetachCanisterResponse],
+        [],
+      ),
+    'get_account' : IDL.Func([], [GetAccountResponse], ['query']),
+    'get_canisters' : IDL.Func([], [IDL.Vec(CanisterDetails)], ['query']),
+    'get_multi_part_transaction_errors' : IDL.Func(
+        [],
+        [IDL.Vec(MultiPartTransactionError)],
+        ['query'],
+      ),
+    'get_multi_part_transaction_status' : IDL.Func(
+        [IDL.Principal, BlockHeight],
+        [MultiPartTransactionStatus],
+        ['query'],
+      ),
+    'get_stats' : IDL.Func([], [Stats], ['query']),
+    'get_transactions' : IDL.Func(
+        [GetTransactionsRequest],
+        [GetTransactionsResponse],
+        ['query'],
+      ),
+    'http_request' : IDL.Func([HttpRequest], [HttpResponse], ['query']),
+    'register_hardware_wallet' : IDL.Func(
+        [RegisterHardwareWalletRequest],
+        [RegisterHardwareWalletResponse],
+        [],
+      ),
+    'rename_sub_account' : IDL.Func(
+        [RenameSubAccountRequest],
+        [RenameSubAccountResponse],
+        [],
+      ),
+  });
+};
+export const init = ({ IDL }) => { return []; };

package/dist/candid/payloads.did

@@ -0,0 +1,168 @@
+// Generated by running `cargo run --bin nns_functions_candid_gen`
+
+type AddNodeOperatorPayload = record {
+  node_operator_principal_id : opt principal;
+  node_allowance : nat64;
+  node_provider_principal_id : opt principal;
+};
+type AddNodesToSubnetPayload = record {
+  subnet_id : principal;
+  node_ids : vec principal;
+};
+type AddOrRemoveDataCentersProposalPayload = record {
+  data_centers_to_add : vec DataCenterRecord;
+  data_centers_to_remove : vec text;
+};
+type BlessReplicaVersionPayload = record {
+  node_manager_sha256_hex : text;
+  release_package_url : text;
+  sha256_hex : text;
+  replica_version_id : text;
+  release_package_sha256_hex : text;
+  node_manager_binary_url : text;
+  binary_url : text;
+};
+type CanisterAction = variant { Start; Stop };
+type CreateSubnetPayload = record {
+  unit_delay_millis : nat64;
+  max_instructions_per_round : nat64;
+  features : SubnetFeatures;
+  max_instructions_per_message : nat64;
+  gossip_registry_poll_period_ms : nat32;
+  max_ingress_bytes_per_message : nat64;
+  dkg_dealings_per_block : nat64;
+  max_block_payload_size : nat64;
+  max_instructions_per_install_code : nat64;
+  start_as_nns : bool;
+  is_halted : bool;
+  gossip_pfn_evaluation_period_ms : nat32;
+  max_ingress_messages_per_block : nat64;
+  gossip_max_artifact_streams_per_peer : nat32;
+  replica_version_id : text;
+  gossip_max_duplicity : nat32;
+  gossip_max_chunk_wait_ms : nat32;
+  dkg_interval_length : nat64;
+  subnet_id_override : opt principal;
+  ingress_bytes_per_block_soft_cap : nat64;
+  initial_notary_delay_millis : nat64;
+  gossip_max_chunk_size : nat32;
+  subnet_type : SubnetType;
+  gossip_retransmission_request_ms : nat32;
+  gossip_receive_check_cache_size : nat32;
+  node_ids : vec principal;
+};
+type DataCenterRecord = record {
+  id : text;
+  gps : opt Gps;
+  region : text;
+  owner : text;
+};
+type Gps = record { latitude : float32; longitude : float32 };
+type NodeRewardRate = record { xdr_permyriad_per_node_per_month : nat64 };
+type NodeRewardRates = record { rates : vec record { text; NodeRewardRate } };
+type RecoverSubnetPayload = record {
+  height : nat64;
+  replacement_nodes : opt vec principal;
+  subnet_id : principal;
+  registry_store_uri : opt record { text; text; nat64 };
+  state_hash : vec nat8;
+  time_ns : nat64;
+};
+type RemoveNodeOperatorsPayload = record {
+  node_operators_to_remove : vec vec nat8;
+};
+type RemoveNodesFromSubnetPayload = record { node_ids : vec principal };
+type RerouteCanisterRangePayload = record {
+  range_end_inclusive : principal;
+  range_start_inclusive : principal;
+  destination_subnet : principal;
+};
+type SetAuthorizedSubnetworkListArgs = record {
+  who : opt principal;
+  subnets : vec principal;
+};
+type SetFirewallConfigPayload = record {
+  ipv4_prefixes : vec text;
+  firewall_config : text;
+  ipv6_prefixes : vec text;
+};
+type StopOrStartNnsCanisterProposalPayload = record {
+  action : CanisterAction;
+  canister_id : principal;
+};
+type SubnetFeatures = record { ecdsa_signatures : bool };
+type SubnetType = variant { application; verified_application; system };
+type UpdateIcpXdrConversionRatePayload = record {
+  data_source : text;
+  xdr_permyriad_per_icp : nat64;
+  timestamp_seconds : nat64;
+};
+type UpdateNodeOperatorConfigPayload = record {
+  node_operator_id : opt principal;
+  node_allowance : opt nat64;
+  rewardable_nodes : vec record { text; nat32 };
+  dc_id : opt text;
+};
+type UpdateNodeRewardsTableProposalPayload = record {
+  new_entries : vec record { text; NodeRewardRates };
+};
+type UpdateSubnetPayload = record {
+  unit_delay_millis : opt nat64;
+  max_duplicity : opt nat32;
+  max_instructions_per_round : opt nat64;
+  features : opt SubnetFeatures;
+  set_gossip_config_to_default : bool;
+  max_instructions_per_message : opt nat64;
+  pfn_evaluation_period_ms : opt nat32;
+  subnet_id : principal;
+  max_ingress_bytes_per_message : opt nat64;
+  dkg_dealings_per_block : opt nat64;
+  max_block_payload_size : opt nat64;
+  max_instructions_per_install_code : opt nat64;
+  start_as_nns : opt bool;
+  is_halted : opt bool;
+  max_number_of_canisters : opt nat64;
+  advert_best_effort_percentage : opt nat32;
+  retransmission_request_ms : opt nat32;
+  dkg_interval_length : opt nat64;
+  registry_poll_period_ms : opt nat32;
+  max_chunk_wait_ms : opt nat32;
+  receive_check_cache_size : opt nat32;
+  ssh_backup_access : opt vec text;
+  ingress_bytes_per_block_soft_cap : opt nat64;
+  max_chunk_size : opt nat32;
+  initial_notary_delay_millis : opt nat64;
+  max_artifact_streams_per_peer : opt nat32;
+  subnet_type : opt SubnetType;
+  ssh_readonly_access : opt vec text;
+};
+type UpdateSubnetReplicaVersionPayload = record {
+  subnet_id : principal;
+  replica_version_id : text;
+};
+type UpdateUnassignedNodesConfigPayload = record {
+  replica_version : opt text;
+  ssh_readonly_access : opt vec text;
+};
+service : {
+  add_node_operator : (AddNodeOperatorPayload) -> ();
+  add_nodes_to_subnet : (AddNodesToSubnetPayload) -> ();
+  add_or_remove_data_centers : (AddOrRemoveDataCentersProposalPayload) -> ();
+  bless_replica_version : (BlessReplicaVersionPayload) -> ();
+  clear_provisional_whitelist : () -> ();
+  create_subnet : (CreateSubnetPayload) -> ();
+  recover_subnet : (RecoverSubnetPayload) -> ();
+  remove_node_operators : (RemoveNodeOperatorsPayload) -> ();
+  remove_nodes : (RemoveNodesFromSubnetPayload) -> ();
+  remove_nodes_from_subnet : (RemoveNodesFromSubnetPayload) -> ();
+  reroute_canister_range : (RerouteCanisterRangePayload) -> ();
+  set_authorized_subnetwork_list : (SetAuthorizedSubnetworkListArgs) -> ();
+  set_firewall_config : (SetFirewallConfigPayload) -> ();
+  stop_or_start_nns_canister : (StopOrStartNnsCanisterProposalPayload) -> ();
+  update_icp_xdr_conversion_rate : (UpdateIcpXdrConversionRatePayload) -> ();
+  update_node_operator_config : (UpdateNodeOperatorConfigPayload) -> ();
+  update_node_rewards_table : (UpdateNodeRewardsTableProposalPayload) -> ();
+  update_subnet : (UpdateSubnetPayload) -> ();
+  update_subnet_replica_version : (UpdateSubnetReplicaVersionPayload) -> ();
+  update_unassigned_nodes_config : (UpdateUnassignedNodesConfigPayload) -> ();
+}

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

@@ -0,0 +1,20 @@
+import type { IDL } from "@dfinity/candid";
+
+export const AddNodeOperatorPayload: IDL.RecordClass;
+export const AddNodesToSubnetPayload: IDL.RecordClass;
+export const AddOrRemoveDataCentersProposalPayload: IDL.RecordClass;
+export const BlessReplicaVersionPayload: IDL.RecordClass;
+export const CreateSubnetPayload: IDL.RecordClass;
+export const RecoverSubnetPayload: IDL.RecordClass;
+export const RemoveNodeOperatorsPayload: IDL.RecordClass;
+export const RemoveNodesFromSubnetPayload: IDL.RecordClass;
+export const RerouteCanisterRangePayload: IDL.RecordClass;
+export const SetAuthorizedSubnetworkListArgs: IDL.RecordClass;
+export const SetFirewallConfigPayload: IDL.RecordClass;
+export const StopOrStartNnsCanisterProposalPayload: IDL.RecordClass;
+export const UpdateIcpXdrConversionRatePayload: IDL.RecordClass;
+export const UpdateNodeOperatorConfigPayload: IDL.RecordClass;
+export const UpdateNodeRewardsTableProposalPayload: IDL.RecordClass;
+export const UpdateSubnetPayload: IDL.RecordClass;
+export const UpdateSubnetReplicaVersionPayload: IDL.RecordClass;
+export const UpdateUnassignedNodesConfigPayload: IDL.RecordClass;