@dfinity/nns 0.1.8 → 0.2.2

package/dist/types/account_identifier.d.ts

@@ -0,0 +1,24 @@
+import { Principal } from "@dfinity/principal";
+import { AccountIdentifier as AccountIdentifierPb } from "../proto/ledger_pb";
+export declare class AccountIdentifier {
+    private readonly bytes;
+    private constructor();
+    static fromHex(hex: string): AccountIdentifier;
+    static fromPrincipal({ principal, subAccount, }: {
+        principal: Principal;
+        subAccount?: SubAccount;
+    }): AccountIdentifier;
+    /**
+     * @returns An AccountIdentifier protobuf object.
+     */
+    toProto(): AccountIdentifierPb;
+    toHex(): string;
+}
+export declare class SubAccount {
+    private readonly bytes;
+    private constructor();
+    static fromBytes(bytes: Uint8Array): SubAccount | Error;
+    static fromPrincipal(principal: Principal): SubAccount;
+    static ZERO: SubAccount;
+    toUint8Array(): Uint8Array;
+}

package/dist/types/canisters/governance/payloads.d.ts

@@ -0,0 +1,3 @@
+import { Option } from "../../types/option";
+export declare const getNnsFunctionName: (nnsFunction: number) => string;
+export declare const convertNnsFunctionPayload: (nnsFunction: number, payload: ArrayBuffer) => Option<Record<string, unknown>>;

package/dist/types/canisters/governance/request.converters.d.ts

@@ -0,0 +1,27 @@
+import { ListNeurons as RawListNeurons, ListProposalInfo, ManageNeuron as RawManageNeuron } from "../../../candid/governanceTypes.d";
+import { ClaimNeuronRequest, ClaimOrRefreshNeuronRequest, DisburseToNeuronRequest, ListProposalsRequest, MakeProposalRequest, ManageNeuron, SplitRequest } from "../../types/governance_converters";
+export declare class RequestConverters {
+    private readonly principal?;
+    constructor();
+    fromListNeurons: (neuronIds?: bigint[] | undefined) => RawListNeurons;
+    fromManageNeuron: (manageNeuron: ManageNeuron) => RawManageNeuron;
+    fromClaimNeuronRequest: (request: ClaimNeuronRequest) => [Array<number>, bigint, bigint];
+    fromListProposalsRequest: (request: ListProposalsRequest) => ListProposalInfo;
+    fromClaimOrRefreshNeuronRequest: (request: ClaimOrRefreshNeuronRequest) => RawManageNeuron;
+    fromSplitRequest: (request: SplitRequest) => RawManageNeuron;
+    fromDisburseToNeuronRequest: (request: DisburseToNeuronRequest) => RawManageNeuron;
+    fromMakeProposalRequest: (request: MakeProposalRequest) => RawManageNeuron;
+    private fromFollowees;
+    private fromNeuronId;
+    private fromNeuronIdOrSubaccount;
+    private fromProposalId;
+    private fromAction;
+    private fromCommand;
+    private fromOperation;
+    private fromChange;
+    private fromNodeProvider;
+    private fromAmount;
+    private fromAccountIdentifier;
+    private fromRewardMode;
+    private fromClaimOrRefreshBy;
+}

package/dist/types/canisters/governance/response.converters.d.ts

@@ -0,0 +1,35 @@
+import { Principal } from "@dfinity/principal";
+import { KnownNeuron as RawKnownNeuron, ListNeuronsResponse as RawListNeuronsResponse, ListProposalInfoResponse as RawListProposalInfoResponse, ManageNeuronResponse as RawManageNeuronResponse, ProposalInfo as RawProposalInfo } from "../../../candid/governanceTypes.d";
+import { NeuronId } from "../../types/common";
+import { DisburseToNeuronResponse, KnownNeuron, ListProposalsResponse, MakeProposalResponse, NeuronInfo, ProposalInfo } from "../../types/governance_converters";
+import { Option } from "../../types/option";
+export declare class ResponseConverters {
+    toProposalInfo: (proposalInfo: RawProposalInfo) => ProposalInfo;
+    toArrayOfNeuronInfo: (response: RawListNeuronsResponse, principal: Principal) => Array<NeuronInfo>;
+    private toNeuronInfo;
+    toListProposalsResponse: (response: RawListProposalInfoResponse) => ListProposalsResponse;
+    toKnownNeuron: (response: RawKnownNeuron) => KnownNeuron;
+    toSplitResponse: (response: RawManageNeuronResponse) => NeuronId;
+    toDisburseToNeuronResult: (response: RawManageNeuronResponse) => DisburseToNeuronResponse;
+    toClaimOrRefreshNeuronResponse: (response: RawManageNeuronResponse) => Option<NeuronId>;
+    toMakeProposalResponse: (response: RawManageNeuronResponse) => MakeProposalResponse;
+    private toNeuron;
+    private toBallotInfo;
+    private toDissolveState;
+    private toFollowees;
+    private toNeuronId;
+    private toNeuronIdOrSubaccount;
+    private toBallot;
+    private toProposal;
+    private toAction;
+    private toTally;
+    private toCommand;
+    private toOperation;
+    private toChange;
+    private toNodeProvider;
+    private toAmount;
+    private toAccountIdentifier;
+    private toRewardMode;
+    private toClaimOrRefreshBy;
+    private throwUnrecognisedTypeError;
+}

package/dist/types/constants/canister_ids.d.ts

@@ -0,0 +1,4 @@
+import { Principal } from "@dfinity/principal";
+export declare const GOVERNANCE_CANISTER_ID: Principal;
+export declare const MAINNET_GOVERNANCE_CANISTER_ID: Principal;
+export declare const MAINNET_LEDGER_CANISTER_ID: Principal;

package/dist/types/constants/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const SUB_ACCOUNT_BYTE_LENGTH = 32;
+export declare const CREATE_CANISTER_MEMO: bigint;
+export declare const TOP_UP_CANISTER_MEMO: bigint;
+export declare const TRANSACTION_FEE: bigint;
+export declare const E8S_PER_ICP: bigint;

package/dist/types/governance.d.ts

@@ -0,0 +1,49 @@
+import { NeuronId } from "./types/common";
+import { GovernanceCanisterOptions } from "./types/governance";
+import { ClaimOrRefreshNeuronFromAccount, KnownNeuron, ListProposalsRequest, ListProposalsResponse, NeuronInfo } from "./types/governance_converters";
+export declare class GovernanceCanister {
+    private readonly service;
+    private readonly certifiedService;
+    private readonly requestConverters;
+    private readonly responseConverters;
+    private readonly myPrincipal?;
+    private constructor();
+    static create(options?: GovernanceCanisterOptions): GovernanceCanister;
+    /**
+     * Returns the list of neurons controlled by the caller.
+     *
+     * If an array of neuron IDs is provided, precisely those neurons will be fetched.
+     *
+     * If `certified` is true, the request is fetched as an update call, otherwise
+     * it is fetched using a query call.
+     *
+     * TODO: Decide: The library method is getNeurons but the raw method is list_neurons.  Do we want this inconsistency?
+     */
+    getNeurons: ({ certified, neuronIds, }: {
+        certified: boolean;
+        neuronIds?: bigint[] | undefined;
+    }) => Promise<NeuronInfo[]>;
+    /**
+     * Returns the list of neurons who have been approved by the community to
+     * appear as the default followee options.
+     *
+     * If `certified` is true, the request is fetched as an update call, otherwise
+     * it is fetched using a query call.
+     */
+    listKnownNeurons: (certified?: boolean) => Promise<KnownNeuron[]>;
+    /**
+     * Returns the list of proposals made for the community to vote on,
+     * paginated and filtered by the request.
+     *
+     * If `certified` is true (default), the request is fetched as an update call, otherwise
+     * it is fetched using a query call.
+     */
+    listProposals: ({ request, certified, }: {
+        request: ListProposalsRequest;
+        certified?: boolean | undefined;
+    }) => Promise<ListProposalsResponse>;
+    /**
+     * Gets the NeuronID of a newly created neuron.
+     */
+    claimOrRefreshNeuronFromAccount: (request: ClaimOrRefreshNeuronFromAccount) => Promise<NeuronId>;
+}

package/dist/types/icp.d.ts

@@ -0,0 +1,17 @@
+import { ICPTs } from "../proto/ledger_pb";
+import { FromICPStringError } from "./types/icp";
+export declare class ICP {
+    private e8s;
+    private constructor();
+    static fromE8s(amount: bigint): ICP;
+    /**
+     * Initialize from a string. Accepted formats:
+     *
+     * 1234567.8901
+     * 1'234'567.8901
+     * 1,234,567.8901
+     */
+    static fromString(amount: string): ICP | FromICPStringError;
+    toE8s(): bigint;
+    toProto(): ICPTs;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export { AccountIdentifier, SubAccount } from "./account_identifier";
+export { GovernanceCanister } from "./governance";
+export { ICP } from "./icp";
+export { LedgerCanister } from "./ledger";
+export * from "./types/governance";
+export * from "./types/governance_converters";
+export * from "./types/icp";
+export * from "./types/ledger";

package/dist/types/ledger.d.ts

@@ -0,0 +1,33 @@
+import { AccountIdentifier } from "./account_identifier";
+import { ICP } from "./icp";
+import { BlockHeight } from "./types/common";
+import { LedgerCanisterOptions, TransferError } from "./types/ledger";
+export declare class LedgerCanister {
+    private readonly agent;
+    private readonly canisterId;
+    private readonly updateFetcher;
+    private readonly queryFetcher;
+    private constructor();
+    static create(options?: LedgerCanisterOptions): LedgerCanister;
+    /**
+     * Returns the balance of the specified account identifier.
+     *
+     * If `certified` is true, the request is fetched as an update call, otherwise
+     * it is fetched using a query call.
+     */
+    accountBalance: ({ accountIdentifier, certified, }: {
+        accountIdentifier: AccountIdentifier;
+        certified?: boolean | undefined;
+    }) => Promise<ICP>;
+    /**
+     * Transfer ICP from the caller to the destination `accountIdentifier`.
+     * Returns the index of the block containing the tx if it was successful.
+     *
+     * TODO: support remaining options (subaccounts, memos, etc.)
+     */
+    transfer: ({ to, amount, memo, }: {
+        to: AccountIdentifier;
+        amount: ICP;
+        memo?: bigint | undefined;
+    }) => Promise<BlockHeight | TransferError>;
+}

package/dist/types/types/common.d.ts

@@ -0,0 +1,8 @@
+export declare type CanisterIdString = string;
+export declare type NeuronId = bigint;
+export declare type AccountIdentifier = string;
+export declare type BlockHeight = bigint;
+export declare type E8s = bigint;
+export declare type Memo = bigint;
+export declare type PrincipalString = string;
+export declare type SubAccount = Uint8Array;

package/dist/types/types/governance.d.ts

@@ -0,0 +1,9 @@
+import { Agent } from "@dfinity/agent";
+import { Principal } from "@dfinity/principal";
+import { GovernanceService } from "../../candid/governance.idl";
+export interface GovernanceCanisterOptions {
+    agent?: Agent;
+    canisterId?: Principal;
+    serviceOverride?: GovernanceService;
+    certifiedServiceOverride?: GovernanceService;
+}