@dfinity/nns 0.1.6 → 0.2.0

package/dist/types/types/governance_converters.d.ts

@@ -0,0 +1,532 @@
+import { DerEncodedPublicKey } from "@dfinity/agent";
+import { Principal } from "@dfinity/principal";
+import { AccountIdentifier, CanisterIdString, E8s, NeuronId, PrincipalString } from "./common";
+import { Option } from "./option";
+export declare type Action = {
+    RegisterKnownNeuron: KnownNeuron;
+} | {
+    ExecuteNnsFunction: ExecuteNnsFunction;
+} | {
+    ManageNeuron: ManageNeuron;
+} | {
+    ApproveGenesisKyc: ApproveGenesisKyc;
+} | {
+    ManageNetworkEconomics: NetworkEconomics;
+} | {
+    RewardNodeProvider: RewardNodeProvider;
+} | {
+    RewardNodeProviders: RewardNodeProviders;
+} | {
+    AddOrRemoveNodeProvider: AddOrRemoveNodeProvider;
+} | {
+    SetDefaultFollowees: SetDefaultFollowees;
+} | {
+    Motion: Motion;
+};
+export interface AddHotKey {
+    newHotKey: Option<PrincipalString>;
+}
+export interface AddOrRemoveNodeProvider {
+    change: Option<Change>;
+}
+export interface ApproveGenesisKyc {
+    principals: Array<PrincipalString>;
+}
+export declare type AuthzChangeOp = {
+    Authorize: {
+        addSelf: boolean;
+    };
+} | {
+    Deauthorize: null;
+};
+export interface Ballot {
+    neuronId: bigint;
+    vote: Vote;
+    votingPower: bigint;
+}
+export interface BallotInfo {
+    vote: Vote;
+    proposalId: Option<ProposalId>;
+}
+export declare type By = {
+    NeuronIdOrSubaccount: Record<string, never>;
+} | {
+    MemoAndController: ClaimOrRefreshNeuronFromAccount;
+} | {
+    Memo: bigint;
+};
+export interface CanisterAuthzInfo {
+    methodsAuthz: Array<MethodAuthzInfo>;
+}
+export declare type Change = {
+    ToRemove: NodeProvider;
+} | {
+    ToAdd: NodeProvider;
+};
+export declare type ClaimOrRefresh = {
+    by: Option<By>;
+};
+export interface ClaimOrRefreshNeuronFromAccount {
+    controller: Option<Principal>;
+    memo: bigint;
+}
+export declare type ClaimOrRefreshNeuronRequest = {
+    neuronId: NeuronId;
+    by: Option<By>;
+};
+export declare type Command = {
+    Spawn: Spawn;
+} | {
+    Split: Split;
+} | {
+    Follow: Follow;
+} | {
+    ClaimOrRefresh: ClaimOrRefresh;
+} | {
+    Configure: Configure;
+} | {
+    RegisterVote: RegisterVote;
+} | {
+    Merge: Merge;
+} | {
+    DisburseToNeuron: DisburseToNeuron;
+} | {
+    MergeMaturity: MergeMaturity;
+} | {
+    MakeProposal: Proposal;
+} | {
+    Disburse: Disburse;
+};
+export interface Configure {
+    operation: Option<Operation>;
+}
+export interface Disburse {
+    toAccountId: Option<AccountIdentifier>;
+    amount: Option<E8s>;
+}
+export interface DisburseResponse {
+    transferBlockHeight: bigint;
+}
+export interface DisburseToNeuron {
+    dissolveDelaySeconds: bigint;
+    kycVerified: boolean;
+    amount: E8s;
+    newController: Option<PrincipalString>;
+    nonce: bigint;
+}
+export declare type DissolveState = {
+    DissolveDelaySeconds: bigint;
+} | {
+    WhenDissolvedTimestampSeconds: bigint;
+};
+export interface ExecuteNnsFunction {
+    nnsFunctionId: number;
+    nnsFunctionName: Option<string>;
+    payload: Option<Record<string, unknown>>;
+    payloadBytes: ArrayBuffer;
+}
+export interface Follow {
+    topic: Topic;
+    followees: Array<NeuronId>;
+}
+export interface Followees {
+    topic: Topic;
+    followees: Array<NeuronId>;
+}
+export interface GovernanceError {
+    errorMessage: string;
+    errorType: number;
+}
+export interface IncreaseDissolveDelay {
+    additionalDissolveDelaySeconds: number;
+}
+export interface KnownNeuron {
+    id: NeuronId;
+    name: string;
+    description: Option<string>;
+}
+export interface SetDissolveTimestamp {
+    dissolveTimestampSeconds: bigint;
+}
+export interface ListProposalsRequest {
+    limit: number;
+    beforeProposal: Option<ProposalId>;
+    includeRewardStatus: Array<ProposalRewardStatus>;
+    excludeTopic: Array<Topic>;
+    includeStatus: Array<ProposalStatus>;
+}
+export interface ListProposalsResponse {
+    proposals: Array<ProposalInfo>;
+}
+export interface MakeProposalResponse {
+    proposalId: ProposalId;
+}
+export interface ManageNeuron {
+    id: Option<NeuronId>;
+    command: Option<Command>;
+    neuronIdOrSubaccount: Option<NeuronIdOrSubaccount>;
+}
+export interface Merge {
+    sourceNeuronId: Option<NeuronId>;
+}
+export interface MergeMaturity {
+    percentageToMerge: number;
+}
+export interface MergeMaturityRequest {
+    neuronId: NeuronId;
+    percentageToMerge: number;
+}
+export interface MergeMaturityResponse {
+    mergedMaturityE8s: bigint;
+    newStakeE8s: bigint;
+}
+export interface MethodAuthzChange {
+    principal: Option<PrincipalString>;
+    methodName: string;
+    canister: CanisterIdString;
+    operation: AuthzChangeOp;
+}
+export interface MethodAuthzInfo {
+    methodName: string;
+    principalIds: Array<ArrayBuffer>;
+}
+export interface Motion {
+    motionText: string;
+}
+export interface NetworkEconomics {
+    neuronMinimumStake: E8s;
+    maxProposalsToKeepPerTopic: number;
+    neuronManagementFeePerProposal: E8s;
+    rejectCost: E8s;
+    transactionFee: E8s;
+    neuronSpawnDissolveDelaySeconds: bigint;
+    minimumIcpXdrRate: bigint;
+    maximumNodeProviderRewards: bigint;
+}
+export interface Neuron {
+    id: Option<NeuronId>;
+    isCurrentUserController: Option<boolean>;
+    controller: Option<PrincipalString>;
+    recentBallots: Array<BallotInfo>;
+    kycVerified: boolean;
+    notForProfit: boolean;
+    cachedNeuronStake: E8s;
+    createdTimestampSeconds: bigint;
+    maturityE8sEquivalent: bigint;
+    agingSinceTimestampSeconds: bigint;
+    neuronFees: E8s;
+    hotKeys: Array<PrincipalString>;
+    accountIdentifier: AccountIdentifier;
+    joinedCommunityFundTimestampSeconds: Option<bigint>;
+    dissolveState: Option<DissolveState>;
+    followees: Array<Followees>;
+}
+export declare type NeuronIdOrSubaccount = {
+    Subaccount: Array<number>;
+} | {
+    NeuronId: NeuronId;
+};
+export declare enum NeuronState {
+    UNSPECIFIED = 0,
+    LOCKED = 1,
+    DISSOLVING = 2,
+    DISSOLVED = 3
+}
+export interface NeuronInfo {
+    neuronId: NeuronId;
+    dissolveDelaySeconds: bigint;
+    recentBallots: Array<BallotInfo>;
+    createdTimestampSeconds: bigint;
+    state: NeuronState;
+    joinedCommunityFundTimestampSeconds: Option<bigint>;
+    retrievedAtTimestampSeconds: bigint;
+    votingPower: bigint;
+    ageSeconds: bigint;
+    fullNeuron: Option<Neuron>;
+}
+export interface NeuronInfoForHw {
+    id: string;
+    amount: string;
+    hotKeys: Array<PrincipalString>;
+}
+export interface NodeProvider {
+    id: Option<PrincipalString>;
+    rewardAccount: Option<AccountIdentifier>;
+}
+export declare type Operation = {
+    RemoveHotKey: RemoveHotKey;
+} | {
+    AddHotKey: AddHotKey;
+} | {
+    StopDissolving: Record<string, never>;
+} | {
+    StartDissolving: Record<string, never>;
+} | {
+    IncreaseDissolveDelay: IncreaseDissolveDelay;
+} | {
+    JoinCommunityFund: Record<string, never>;
+} | {
+    SetDissolveTimestamp: SetDissolveTimestamp;
+};
+export interface Proposal {
+    title: Option<string>;
+    url: string;
+    action: Option<Action>;
+    summary: string;
+}
+export declare type ProposalId = bigint;
+export interface ProposalInfo {
+    id: Option<ProposalId>;
+    ballots: Array<Ballot>;
+    rejectCost: E8s;
+    proposalTimestampSeconds: bigint;
+    rewardEventRound: bigint;
+    failedTimestampSeconds: bigint;
+    decidedTimestampSeconds: bigint;
+    latestTally: Option<Tally>;
+    proposal: Option<Proposal>;
+    proposer: Option<NeuronId>;
+    executedTimestampSeconds: bigint;
+    topic: Topic;
+    status: ProposalStatus;
+    rewardStatus: ProposalRewardStatus;
+}
+export declare enum ProposalRewardStatus {
+    PROPOSAL_REWARD_STATUS_UNKNOWN = 0,
+    PROPOSAL_REWARD_STATUS_ACCEPT_VOTES = 1,
+    PROPOSAL_REWARD_STATUS_READY_TO_SETTLE = 2,
+    PROPOSAL_REWARD_STATUS_SETTLED = 3,
+    PROPOSAL_REWARD_STATUS_INELIGIBLE = 4
+}
+export declare enum ProposalStatus {
+    PROPOSAL_STATUS_UNKNOWN = 0,
+    PROPOSAL_STATUS_OPEN = 1,
+    PROPOSAL_STATUS_REJECTED = 2,
+    PROPOSAL_STATUS_ACCEPTED = 3,
+    PROPOSAL_STATUS_EXECUTED = 4,
+    PROPOSAL_STATUS_FAILED = 5
+}
+export declare enum Vote {
+    UNSPECIFIED = 0,
+    YES = 1,
+    NO = 2
+}
+export interface RegisterVote {
+    vote: Vote;
+    proposal: Option<ProposalId>;
+}
+export interface RemoveHotKey {
+    hotKeyToRemove: Option<PrincipalString>;
+}
+export declare type RewardMode = {
+    RewardToNeuron: RewardToNeuron;
+} | {
+    RewardToAccount: RewardToAccount;
+};
+export declare type RewardNodeProviders = {
+    rewards: Array<RewardNodeProvider>;
+};
+export interface RewardToAccount {
+    toAccount: Option<AccountIdentifier>;
+}
+export interface RewardToNeuron {
+    dissolveDelaySeconds: bigint;
+}
+export declare type ClaimNeuronRequest = {
+    publicKey: DerEncodedPublicKey;
+    nonce: bigint;
+    dissolveDelayInSecs: bigint;
+};
+export declare type ClaimNeuronResponse = {
+    Ok: null;
+} | {
+    Err: GovernanceError;
+};
+export declare type GetFullNeuronResponse = {
+    Ok: Neuron;
+} | {
+    Err: GovernanceError;
+};
+export declare type GetNeuronInfoResponse = {
+    Ok: NeuronInfo;
+} | {
+    Err: GovernanceError;
+};
+export interface RewardNodeProvider {
+    nodeProvider: Option<NodeProvider>;
+    rewardMode: Option<RewardMode>;
+    amountE8s: bigint;
+}
+export interface SetDefaultFollowees {
+    defaultFollowees: Array<Followees>;
+}
+export interface Spawn {
+    newController: Option<PrincipalString>;
+}
+export interface SpawnResponse {
+    createdNeuronId: NeuronId;
+}
+export interface Split {
+    amount: E8s;
+}
+export interface Tally {
+    no: bigint;
+    yes: bigint;
+    total: bigint;
+    timestampSeconds: bigint;
+}
+export declare enum Topic {
+    Unspecified = 0,
+    ManageNeuron = 1,
+    ExchangeRate = 2,
+    NetworkEconomics = 3,
+    Governance = 4,
+    NodeAdmin = 5,
+    ParticipantManagement = 6,
+    SubnetManagement = 7,
+    NetworkCanisterManagement = 8,
+    Kyc = 9,
+    NodeProviderRewards = 10
+}
+export interface AddHotKeyRequest {
+    neuronId: NeuronId;
+    principal: PrincipalString;
+}
+export interface RemoveHotKeyRequest {
+    neuronId: NeuronId;
+    principal: PrincipalString;
+}
+export interface StartDissolvingRequest {
+    neuronId: NeuronId;
+}
+export interface StopDissolvingRequest {
+    neuronId: NeuronId;
+}
+export interface IncreaseDissolveDelayRequest {
+    neuronId: NeuronId;
+    additionalDissolveDelaySeconds: number;
+}
+export interface FollowRequest {
+    neuronId: NeuronId;
+    topic: Topic;
+    followees: Array<NeuronId>;
+}
+export interface RegisterVoteRequest {
+    neuronId: NeuronId;
+    vote: Vote;
+    proposal: ProposalId;
+}
+export interface SpawnRequest {
+    neuronId: NeuronId;
+    newController: Option<PrincipalString>;
+}
+export interface SplitRequest {
+    neuronId: NeuronId;
+    amount: E8s;
+}
+export interface DisburseRequest {
+    neuronId: NeuronId;
+    toAccountId?: AccountIdentifier;
+    amount?: E8s;
+}
+export interface DisburseToNeuronRequest {
+    neuronId: NeuronId;
+    dissolveDelaySeconds: bigint;
+    kycVerified: boolean;
+    amount: E8s;
+    newController: Option<PrincipalString>;
+    nonce: bigint;
+}
+export interface JoinCommunityFundRequest {
+    neuronId: NeuronId;
+}
+export interface MakeProposalRequest {
+    neuronId: NeuronId;
+    title: Option<string>;
+    url: string;
+    summary: string;
+    action: Action;
+}
+export interface MakeMotionProposalRequest {
+    neuronId: NeuronId;
+    title: Option<string>;
+    url: string;
+    text: string;
+    summary: string;
+}
+export interface MakeNetworkEconomicsProposalRequest {
+    neuronId: NeuronId;
+    title: Option<string>;
+    summary: string;
+    url: string;
+    networkEconomics: NetworkEconomics;
+}
+export interface MakeRewardNodeProviderProposalRequest {
+    neuronId: NeuronId;
+    title: Option<string>;
+    summary: string;
+    url: string;
+    nodeProvider: PrincipalString;
+    amount: E8s;
+    rewardMode: Option<RewardMode>;
+}
+export interface MakeSetDefaultFolloweesProposalRequest {
+    neuronId: NeuronId;
+    title: Option<string>;
+    summary: string;
+    url: string;
+    followees: Array<Followees>;
+}
+export interface MakeExecuteNnsFunctionProposalRequest {
+    neuronId: NeuronId;
+    title: Option<string>;
+    summary: string;
+    url: string;
+    nnsFunction: number;
+    payload: ArrayBuffer;
+}
+export interface DisburseToNeuronResponse {
+    createdNeuronId: NeuronId;
+}
+export interface SpawnResponse {
+    createdNeuronId: NeuronId;
+}
+export declare type EmptyResponse = {
+    Ok: null;
+} | {
+    Err: GovernanceError;
+};
+export default interface ServiceInterface {
+    getNeurons: (certified: boolean, neuronIds?: NeuronId[]) => Promise<Array<NeuronInfo>>;
+    getNeuronsForHW: () => Promise<Array<NeuronInfoForHw>>;
+    getPendingProposals: () => Promise<Array<ProposalInfo>>;
+    getProposalInfo: (proposalId: bigint) => Promise<Option<ProposalInfo>>;
+    listKnownNeurons: (certified: boolean) => Promise<Array<KnownNeuron>>;
+    listProposals: (request: ListProposalsRequest) => Promise<ListProposalsResponse>;
+    addHotKey: (request: AddHotKeyRequest) => Promise<EmptyResponse>;
+    removeHotKey: (request: RemoveHotKeyRequest) => Promise<EmptyResponse>;
+    startDissolving: (request: StartDissolvingRequest) => Promise<EmptyResponse>;
+    stopDissolving: (request: StopDissolvingRequest) => Promise<EmptyResponse>;
+    increaseDissolveDelay: (request: IncreaseDissolveDelayRequest) => Promise<EmptyResponse>;
+    joinCommunityFund: (request: JoinCommunityFundRequest) => Promise<EmptyResponse>;
+    follow: (request: FollowRequest) => Promise<EmptyResponse>;
+    mergeMaturity: (request: MergeMaturityRequest) => Promise<MergeMaturityResponse>;
+    registerVote: (request: RegisterVoteRequest) => Promise<EmptyResponse>;
+    spawn: (request: SpawnRequest) => Promise<SpawnResponse>;
+    split: (request: SplitRequest) => Promise<NeuronId>;
+    disburse: (request: DisburseRequest) => Promise<DisburseResponse>;
+    disburseToNeuron: (request: DisburseToNeuronRequest) => Promise<DisburseToNeuronResponse>;
+    makeMotionProposal: (request: MakeMotionProposalRequest) => Promise<MakeProposalResponse>;
+    makeNetworkEconomicsProposal: (request: MakeNetworkEconomicsProposalRequest) => Promise<MakeProposalResponse>;
+    makeRewardNodeProviderProposal: (request: MakeRewardNodeProviderProposalRequest) => Promise<MakeProposalResponse>;
+    makeSetDefaultFolloweesProposal: (request: MakeSetDefaultFolloweesProposalRequest) => Promise<MakeProposalResponse>;
+    makeExecuteNnsFunctionProposal: (request: MakeExecuteNnsFunctionProposalRequest) => Promise<MakeProposalResponse>;
+    claimOrRefreshNeuron: (request: ClaimOrRefreshNeuronRequest) => Promise<Option<NeuronId>>;
+    claimOrRefreshNeuronFromAccount: (request: ClaimOrRefreshNeuronFromAccount) => Promise<NeuronId>;
+}
+/**
+ * An error used to ensure at compile-time that it's never reached.
+ */
+export declare class UnsupportedValueError extends Error {
+    constructor(value: never);
+}

package/dist/types/types/icp.d.ts

@@ -0,0 +1,4 @@
+export declare enum FromICPStringError {
+    FRACTIONAL_MORE_THAN_8_DECIMALS = 0,
+    INVALID_FORMAT = 1
+}

package/dist/types/types/ledger.d.ts

@@ -0,0 +1,30 @@
+import { Agent } from "@dfinity/agent";
+import { Principal } from "@dfinity/principal";
+import { ICP } from "../icp";
+export declare type BlockHeight = bigint;
+export declare type TransferError = InvalidSender | InsufficientFunds | TxTooOld | TxCreatedInFuture | TxDuplicate | BadFee;
+export declare class InvalidSender {
+}
+export declare class BadFee {
+}
+export declare class InsufficientFunds {
+    readonly balance: ICP;
+    constructor(balance: ICP);
+}
+export declare class TxTooOld {
+    readonly allowed_window_secs: number;
+    constructor(allowed_window_secs: number);
+}
+export declare class TxCreatedInFuture {
+}
+export declare class TxDuplicate {
+    readonly duplicateOf: BlockHeight;
+    constructor(duplicateOf: BlockHeight);
+}
+export declare type Fetcher = (agent: Agent, canisterId: Principal, methodName: string, arg: ArrayBuffer) => Promise<Uint8Array | Error>;
+export interface LedgerCanisterOptions {
+    agent?: Agent;
+    canisterId?: Principal;
+    updateCallOverride?: Fetcher;
+    queryCallOverride?: Fetcher;
+}

package/dist/types/types/option.d.ts

@@ -0,0 +1 @@
+export declare type Option<T> = T | undefined;

package/dist/types/utils/agent.utils.d.ts

@@ -0,0 +1,5 @@
+import { Agent } from "@dfinity/agent";
+/**
+ * @returns The default agent to use. An agent that connects to mainnet with the anonymous identity.
+ */
+export declare const defaultAgent: () => Agent;

package/dist/types/utils/converter.utils.d.ts

@@ -0,0 +1,18 @@
+import { Principal } from "@dfinity/principal";
+import { AccountIdentifier, SubAccount } from "../types/common";
+export declare const uint8ArrayToBigInt: (array: Uint8Array) => bigint;
+export declare const bigIntToUint8Array: (value: bigint) => Uint8Array;
+export declare const arrayBufferToArrayOfNumber: (buffer: ArrayBuffer) => Array<number>;
+export declare const arrayOfNumberToUint8Array: (numbers: Array<number>) => Uint8Array;
+export declare const arrayOfNumberToArrayBuffer: (numbers: Array<number>) => ArrayBuffer;
+export declare const arrayBufferToNumber: (buffer: ArrayBuffer) => number;
+export declare const numberToArrayBuffer: (value: number, byteLength: number) => ArrayBuffer;
+export declare const asciiStringToByteArray: (text: string) => Array<number>;
+export declare const toSubAccountId: (subAccount: Array<number>) => number;
+export declare const fromSubAccountId: (subAccountId: number) => Array<number>;
+export declare const accountIdentifierToBytes: (accountIdentifier: AccountIdentifier) => Uint8Array;
+export declare const accountIdentifierFromBytes: (accountIdentifier: Uint8Array) => AccountIdentifier;
+export declare const principalToAccountIdentifier: (principal: Principal, subAccount?: Uint8Array | undefined) => string;
+export declare const principalToSubAccount: (principal: Principal) => SubAccount;
+export declare const toHexString: (bytes: Uint8Array) => string;
+export declare const calculateCrc32: (bytes: Uint8Array) => Uint8Array;