@keetanetwork/keetanet-client 0.10.2

package/LICENSE

@@ -0,0 +1,35 @@
+Keeta Token Network Community License (v1.0)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
+
+
+
+
+
+
+
+
+
+
+
+
+

package/api/index.d.ts

@@ -0,0 +1,181 @@
+import type Node from '../lib/node';
+import type { JSONSerializable } from '../lib/utils/conversion';
+declare const rootTree: {
+    vote: {
+        _root: {
+            POST: (request: APIRequest, payload: {
+                blocks: string[];
+                votes?: string[];
+            }) => Promise<{
+                vote: import("../lib/vote").VoteJSONOutput & {
+                    $binary: string;
+                };
+            }>;
+        };
+        ':blockhash': {
+            GET: (request: APIRequest, blockhash: string) => Promise<{
+                blockhash: string;
+                votes: (import("../lib/vote").VoteJSONOutput & {
+                    $binary: string;
+                })[] | null;
+            }>;
+        };
+    };
+    node: {
+        peers: {
+            GET: (request: APIRequest) => Promise<{
+                peers: import("./node").NodeAPIGetPeersResponse[];
+            }>;
+        };
+        publish: {
+            POST: (request: APIRequest, payload: {
+                votesAndBlocks: string;
+            }) => Promise<{
+                publish: boolean;
+            }>;
+        };
+        stats: {
+            GET: (request: APIRequest) => Promise<{
+                ledger: import("../lib/ledger/types").LedgerStatistics;
+                switch: import("../lib/p2p").P2PSwitchStatistics;
+            }>;
+        };
+        ledger: {
+            clearstats: {
+                GET: (_ignored_request: APIRequest) => Promise<{
+                    clearStats: boolean;
+                }>;
+            };
+            block: {
+                ':blockhash': {
+                    GET: (request: APIRequest, blockhash: string) => Promise<{
+                        blockhash: string;
+                        block: null | import("../lib/block").Block;
+                    }>;
+                    successor: {
+                        GET: (request: APIRequest, blockhash: string) => Promise<{
+                            blockhash: string;
+                            successorBlock: null | import("../lib/block").Block;
+                        }>;
+                    };
+                };
+            };
+            representative: {
+                GET: (request: APIRequest, providedRep?: string) => Promise<import("./node").NodeAPIGetRepresentativeResponse>;
+                ':rep': {
+                    GET: (request: APIRequest, providedRep?: string) => Promise<import("./node").NodeAPIGetRepresentativeResponse>;
+                };
+            };
+            representatives: {
+                GET: (request: APIRequest) => Promise<{
+                    representatives: import("./node").NodeAPIGetAllRepresentativesResponse[];
+                }>;
+            };
+            account: {
+                ':account': {
+                    GET: (request: APIRequest, pubKey: string) => Promise<import("./node").NodeAPIAccountState | import("./node").NodeAPIAccountStateError>;
+                    head: {
+                        GET: (request: APIRequest, account: string | import("../lib/account").GenericAccount) => Promise<{
+                            account: import("../lib/account").GenericAccount;
+                            block: null | import("../lib/block").Block;
+                        }>;
+                    };
+                    chain: {
+                        GET: (request: APIRequest, account: string) => Promise<import("./node").NodeAPIGetAccountChainResponse>;
+                    };
+                    history: {
+                        GET: (request: APIRequest, account: string, start?: unknown) => Promise<import("./node").NodeAPIGetAccountHistoryResponse>;
+                        start: {
+                            ':block': {
+                                GET: (request: APIRequest, account: string, start?: unknown) => Promise<import("./node").NodeAPIGetAccountHistoryResponse>;
+                            };
+                        };
+                    };
+                    balance: {
+                        GET: (request: APIRequest, account: string | import("../lib/account").GenericAccount) => Promise<{
+                            account: import("../lib/account").GenericAccount;
+                            balances: import("../lib/ledger/types").GetAllBalancesResponse;
+                        }>;
+                        ':token': {
+                            GET: (request: APIRequest, account: string | import("../lib/account").GenericAccount, token: string | import("../lib/account").TokenAddress) => Promise<{
+                                account: import("../lib/account").GenericAccount;
+                                token: import("../lib/account").TokenAddress;
+                                balance: bigint;
+                            }>;
+                        };
+                    };
+                    acl: {
+                        granted: {
+                            GET: (request: APIRequest, entity: string | import("../lib/account").GenericAccount) => Promise<{
+                                permissions: import("../lib/ledger/types").ACLRow[];
+                            }>;
+                        };
+                        additional: {
+                            GET: (request: APIRequest, principalPubKey: string, entityList?: string) => Promise<import("./node").NodeAPIPrincipalACLWithInfoResponse>;
+                            ':entityList': {
+                                GET: (request: APIRequest, principalPubKey: string, entityList?: string) => Promise<import("./node").NodeAPIPrincipalACLWithInfoResponse>;
+                            };
+                        };
+                        GET: (request: APIRequest, principal: string | import("../lib/account").GenericAccount, entityPubKeys: string) => Promise<{
+                            permissions: import("../lib/ledger/types").ACLRow[];
+                        }>;
+                        ':entityList': {
+                            GET: (request: APIRequest, principal: string | import("../lib/account").GenericAccount, entityPubKeys: string) => Promise<{
+                                permissions: import("../lib/ledger/types").ACLRow[];
+                            }>;
+                        };
+                    };
+                    pending: {
+                        GET: (request: APIRequest, account: string) => Promise<{
+                            account: string;
+                            block: null | import("../lib/block").Block;
+                        }>;
+                    };
+                };
+            };
+            accounts: {
+                ':accounts': {
+                    GET: (request: APIRequest, accounts: string) => Promise<(import("./node").NodeAPIAccountState | import("./node").NodeAPIAccountStateError)[]>;
+                };
+            };
+            checksum: {
+                GET: (request: APIRequest) => Promise<import("./node").NodeAPIGetLedgerChecksumResponse>;
+            };
+        };
+        bootstrap: {
+            votes: {
+                GET: (request: APIRequest) => Promise<{
+                    voteStaples: import("../lib/vote").VoteStaple[];
+                }>;
+            };
+        };
+        version: {
+            GET: () => Promise<{
+                node: string;
+            }>;
+        };
+    };
+};
+export interface APIRequest {
+    node: Node;
+    params: {
+        [name: string]: string;
+    };
+    query: {
+        [name: string]: string;
+    };
+    payload: any;
+    header: {
+        get: (name: string) => string | undefined;
+    };
+}
+interface HandlerMapping {
+    method: 'GET' | 'PUT' | 'POST' | 'DELETE';
+    path: string;
+    timeout?: boolean;
+    handler: (request: APIRequest, ...args: any[]) => Promise<JSONSerializable>;
+}
+type HandlerMappings = HandlerMapping[];
+declare const to_export: HandlerMappings;
+export default to_export;
+export type APITree = typeof rootTree;

package/api/node.d.ts

@@ -0,0 +1,216 @@
+import type { AccountInfo, GetAllBalancesResponse, LedgerStatistics, ACLRow } from '../lib/ledger/types';
+import type { P2PSwitchStatistics } from '../lib/p2p';
+import { NodeKind } from '../lib/node';
+import Block, { BlockHash } from '../lib/block';
+import type { APIRequest } from '.';
+import type { Endpoints } from '../config';
+import type { GenericAccount, TokenAddress } from '../lib/account';
+import Account from '../lib/account';
+import type { VoteStaple } from '../lib/vote';
+interface GetPeersAPIResponse {
+    kind: NodeKind;
+    key?: string;
+    endpoint?: string;
+}
+interface GetAccountChainAPIResponse {
+    account: string;
+    blocks: {
+        block: Block;
+    }[];
+    nextKey: BlockHash | null;
+}
+interface AccountState {
+    account: GenericAccount;
+    currentHeadBlock: BlockHash | null;
+    representative: Account | null;
+    balances: GetAllBalancesResponse;
+    info: AccountInfo;
+}
+interface AccountStateError {
+    account: string;
+    error: string;
+}
+interface GetAllRepresentativesAPIResponse {
+    representative: string;
+    endpoints: Endpoints;
+}
+interface GetRepresentativeAPIResponse {
+    representative: string;
+    weight: bigint;
+}
+interface GetLedgerChecksumAPIResponse {
+    moment: Date;
+    momentRange: number;
+    checksum: bigint;
+}
+interface PrincipalACLWithInfoResponse {
+    account: GenericAccount;
+    access: {
+        entity: GenericAccount;
+        info: AccountInfo;
+        balances: GetAllBalancesResponse;
+        principals: ACLRow[];
+    }[];
+}
+interface GetAccountHistoryResponse {
+    history: {
+        voteStaple: ReturnType<typeof VoteStaple['toJSONSerializable']>;
+        '$id': string;
+        '$timestamp': string;
+    }[];
+}
+declare function getPeers(request: APIRequest): Promise<{
+    peers: GetPeersAPIResponse[];
+}>;
+declare function publishVoteStaple(request: APIRequest, payload: {
+    votesAndBlocks: string;
+}): Promise<{
+    publish: boolean;
+}>;
+declare function getNodeStats(request: APIRequest): Promise<{
+    ledger: LedgerStatistics;
+    switch: P2PSwitchStatistics;
+}>;
+declare function debugClearStats(_ignored_request: APIRequest): Promise<{
+    clearStats: boolean;
+}>;
+declare function getBlockSuccessor(request: APIRequest, blockhash: string): Promise<{
+    blockhash: string;
+    successorBlock: null | Block;
+}>;
+declare function getAccountPendingBlock(request: APIRequest, account: string): Promise<{
+    account: string;
+    block: null | Block;
+}>;
+declare function getAccountsHead(request: APIRequest, account: string | GenericAccount): Promise<{
+    account: GenericAccount;
+    block: null | Block;
+}>;
+declare function getAccountBalance(request: APIRequest, account: string | GenericAccount, token: string | TokenAddress): Promise<{
+    account: GenericAccount;
+    token: TokenAddress;
+    balance: bigint;
+}>;
+declare function getAllBalances(request: APIRequest, account: string | GenericAccount): Promise<{
+    account: GenericAccount;
+    balances: GetAllBalancesResponse;
+}>;
+declare function getAccountState(request: APIRequest, pubKey: string): Promise<AccountState | AccountStateError>;
+declare function getBlockByHash(request: APIRequest, blockhash: string): Promise<{
+    blockhash: string;
+    block: null | Block;
+}>;
+declare function getAccountStates(request: APIRequest, accounts: string): Promise<(AccountState | AccountStateError)[]>;
+declare function listACLsByEntity(request: APIRequest, entity: string | GenericAccount): Promise<{
+    permissions: ACLRow[];
+}>;
+declare function listACLsByPrincipal(request: APIRequest, principal: string | GenericAccount, entityPubKeys: string): Promise<{
+    permissions: ACLRow[];
+}>;
+declare function listACLsByPrincipalWithInfo(request: APIRequest, principalPubKey: string, entityList?: string): Promise<PrincipalACLWithInfoResponse>;
+declare function getAccountChain(request: APIRequest, account: string): Promise<GetAccountChainAPIResponse>;
+declare function getAccountHistory(request: APIRequest, account: string, start?: unknown): Promise<GetAccountHistoryResponse>;
+declare function getAllRepresentatives(request: APIRequest): Promise<{
+    representatives: GetAllRepresentativesAPIResponse[];
+}>;
+declare function getRepresentative(request: APIRequest, providedRep?: string): Promise<GetRepresentativeAPIResponse>;
+declare function getLedgerChecksum(request: APIRequest): Promise<GetLedgerChecksumAPIResponse>;
+declare function getVoteStaplesAfter(request: APIRequest): Promise<{
+    voteStaples: VoteStaple[];
+}>;
+declare function getVersion(): Promise<{
+    node: string;
+}>;
+declare const _default: {
+    peers: {
+        GET: typeof getPeers;
+    };
+    publish: {
+        POST: typeof publishVoteStaple;
+    };
+    stats: {
+        GET: typeof getNodeStats;
+    };
+    ledger: {
+        clearstats: {
+            GET: typeof debugClearStats;
+        };
+        block: {
+            ':blockhash': {
+                GET: typeof getBlockByHash;
+                successor: {
+                    GET: typeof getBlockSuccessor;
+                };
+            };
+        };
+        representative: {
+            GET: typeof getRepresentative;
+            ':rep': {
+                GET: typeof getRepresentative;
+            };
+        };
+        representatives: {
+            GET: typeof getAllRepresentatives;
+        };
+        account: {
+            ':account': {
+                GET: typeof getAccountState;
+                head: {
+                    GET: typeof getAccountsHead;
+                };
+                chain: {
+                    GET: typeof getAccountChain;
+                };
+                history: {
+                    GET: typeof getAccountHistory;
+                    start: {
+                        ':block': {
+                            GET: typeof getAccountHistory;
+                        };
+                    };
+                };
+                balance: {
+                    GET: typeof getAllBalances;
+                    ':token': {
+                        GET: typeof getAccountBalance;
+                    };
+                };
+                acl: {
+                    granted: {
+                        GET: typeof listACLsByEntity;
+                    };
+                    additional: {
+                        GET: typeof listACLsByPrincipalWithInfo;
+                        ':entityList': {
+                            GET: typeof listACLsByPrincipalWithInfo;
+                        };
+                    };
+                    GET: typeof listACLsByPrincipal;
+                    ':entityList': {
+                        GET: typeof listACLsByPrincipal;
+                    };
+                };
+                pending: {
+                    GET: typeof getAccountPendingBlock;
+                };
+            };
+        };
+        accounts: {
+            ':accounts': {
+                GET: typeof getAccountStates;
+            };
+        };
+        checksum: {
+            GET: typeof getLedgerChecksum;
+        };
+    };
+    bootstrap: {
+        votes: {
+            GET: typeof getVoteStaplesAfter;
+        };
+    };
+    version: {
+        GET: typeof getVersion;
+    };
+};
+export default _default;

package/api/vote.d.ts

@@ -0,0 +1,25 @@
+import type { APIRequest } from '.';
+import KeetaNet from '../lib';
+type Vote = InstanceType<typeof KeetaNet['Vote']>;
+type VoteJSONOutput = ReturnType<Vote['toJSON']> & {
+    '$binary': string;
+};
+declare function createNewVote(request: APIRequest, payload: {
+    blocks: string[];
+    votes?: string[];
+}): Promise<{
+    vote: VoteJSONOutput;
+}>;
+declare function getVotes(request: APIRequest, blockhash: string): Promise<{
+    blockhash: string;
+    votes: VoteJSONOutput[] | null;
+}>;
+declare const _default: {
+    _root: {
+        POST: typeof createNewVote;
+    };
+    ':blockhash': {
+        GET: typeof getVotes;
+    };
+};
+export default _default;

package/client/builder.d.ts

@@ -0,0 +1,129 @@
+import type { GenericAccount, IdentifierKeyAlgorithm } from '../lib/account';
+import { Account, AccountKeyAlgorithm } from '../lib/account';
+import type { AdjustMethod, BlockHash } from '../lib/block';
+import { Block } from '../lib/block';
+import type { AccountInfo } from '../lib/ledger/types';
+import type { AcceptedPermissionTypes } from '../lib/permissions';
+import Permissions from '../lib/permissions';
+type GetPrevFunction = (acct: GenericAccount | string) => Promise<BlockHash | string | null | undefined>;
+interface AccountSignerOptions {
+    account: GenericAccount;
+    signer: Account;
+}
+interface RenderOptions {
+    network: bigint;
+    getPrevious: GetPrevFunction;
+}
+type BuilderBlockOptions = Partial<AccountSignerOptions>;
+export type BuilderOptions = Partial<AccountSignerOptions> & Pick<AccountSignerOptions, 'signer'>;
+type PerAccount<T> = {
+    [accountPubKey: string]: T;
+};
+interface IdentifierCreateRequest {
+    type: IdentifierKeyAlgorithm;
+    toResolve?: PendingAccount;
+}
+type AccountOrPending<Type extends AccountKeyAlgorithm = AccountKeyAlgorithm> = Account<Type> | PendingAccount<Type>;
+type TokenOrPending = AccountOrPending<AccountKeyAlgorithm.TOKEN>;
+export interface PendingOperations {
+    receive?: {
+        otherParty: AccountOrPending;
+        token: TokenOrPending;
+        amount: bigint;
+        exactReceive: boolean;
+        forward?: AccountOrPending;
+    }[];
+    send?: {
+        otherParty: AccountOrPending;
+        token: TokenOrPending;
+        amount: bigint;
+        external?: string;
+    }[];
+    createIdentifiers?: IdentifierCreateRequest[];
+    tokenSupply?: bigint;
+    adminModifyBalance?: {
+        isSet: boolean;
+        amount: bigint;
+        token: TokenOrPending;
+    }[];
+    permissionsChanges?: PerAccount<PerAccount<{
+        method: AdjustMethod;
+        permissions: Permissions;
+    }[]>>;
+    info?: AccountInfo;
+    setRep?: Account;
+}
+export interface PendingOperationsJSON {
+    receive?: {
+        otherParty: string;
+        token: string;
+        amount: string;
+        exactReceive: boolean;
+        forward?: string;
+    }[];
+    send?: {
+        otherParty: string;
+        token: string;
+        amount: string;
+        external?: string;
+    }[];
+    createIdentifiers?: {
+        type: IdentifierKeyAlgorithm;
+    }[];
+    tokenSupply?: string;
+    adminModifyBalance?: {
+        isSet: boolean;
+        amount: string;
+        token: string;
+    }[];
+    permissionsChanges?: PerAccount<PerAccount<{
+        method: AdjustMethod;
+        permissions: [string, string];
+    }[]>>;
+    info?: Pick<AccountInfo, 'name' | 'description' | 'metadata'> & {
+        defaultPermission?: [string, string];
+    };
+    setRep?: string;
+}
+export interface AccountSignerOptionsJSON {
+    account: string;
+    signer: string;
+}
+export interface AllPendingJSON {
+    renderedBlocks: string[];
+    nonRendered: [AccountSignerOptionsJSON, PendingOperationsJSON][];
+}
+export interface ComputeBlocksResponse {
+    blocks: Block[];
+}
+export declare class PendingAccount<AccountType extends AccountKeyAlgorithm = AccountKeyAlgorithm> {
+    #private;
+    static IsInstance: (obj: any, strict?: boolean) => obj is PendingAccount<AccountKeyAlgorithm>;
+    static GetValue<T extends AccountKeyAlgorithm>(data: AccountOrPending<T>): Account<T>;
+    set account(account: Account<AccountType>);
+    get account(): Account<AccountType>;
+}
+type AllPending = [AccountSignerOptions, PendingOperations][];
+export declare class UserClientBuilder {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is UserClientBuilder;
+    static PendingAccount: typeof PendingAccount;
+    static FromPendingJSON(options: BuilderOptions, getPrivateKey: (acct: Account) => Promise<Account>, multiAllPending: AllPendingJSON[]): Promise<UserClientBuilder>;
+    pendingToJSON(): AllPendingJSON;
+    constructor(options: BuilderOptions, previousRender?: ComputeBlocksResponse, previousPending?: AllPending);
+    get defaultOptions(): BuilderOptions;
+    updateAccounts(accountOptions: Partial<AccountSignerOptions>): void;
+    clone(): Promise<UserClientBuilder>;
+    computeBlocks(renderOptions: RenderOptions): Promise<ComputeBlocksResponse>;
+    send(recipient: AccountOrPending, amount: bigint, token: TokenOrPending, external?: string, options?: BuilderBlockOptions): void;
+    receive(from: AccountOrPending, amount: bigint, token: TokenOrPending, exact?: boolean, forward?: GenericAccount, options?: BuilderBlockOptions): void;
+    updatePermissions(principal: GenericAccount, permissions: AcceptedPermissionTypes, target?: GenericAccount, method?: AdjustMethod, options?: BuilderBlockOptions): void;
+    modifyTokenSupply(amount: bigint, options?: BuilderBlockOptions): void;
+    modifyTokenBalance(token: TokenOrPending, amount: bigint, isSet?: boolean, options?: BuilderBlockOptions): void;
+    setInfo(info: AccountInfo, options?: BuilderBlockOptions): void;
+    setRep(to: Account, options?: BuilderBlockOptions): void;
+    generateIdentifier<Algo extends IdentifierKeyAlgorithm>(type: Algo, options?: BuilderBlockOptions): PendingAccount<Algo>;
+    get blocks(): Block[];
+    get rendered(): boolean;
+}
+export {};

package/client/client_common_tests.d.ts

@@ -0,0 +1,72 @@
+import * as KeetaNet from '.';
+import type LocalNode from '../lib/node/local';
+import type { Networks } from '../config';
+import type Account from '../lib/account';
+import type { UserClient } from '.';
+import { toJSONSerializable } from '../lib/utils/conversion';
+import KeetaError from '../lib/error';
+export type ClientParams = {
+    ip?: string;
+    port?: number;
+    networkID: number;
+    networkAlias: Networks;
+    testPrivateAccount: {
+        seed: string;
+    };
+    repKeys: string[];
+    accountIndexes: number[];
+    trustedKeyIndex: number;
+};
+export type NodeCreationOptions = {
+    p2pTested?: boolean;
+    count?: number;
+};
+export declare function setup(options?: NodeCreationOptions): Promise<{
+    trustedKey: Account<import("../lib/account").AccountKeyAlgorithm.ECDSA_SECP256K1>;
+    repKeys: Account<import("../lib/account").AccountKeyAlgorithm.ECDSA_SECP256K1 | import("../lib/account").AccountKeyAlgorithm.ED25519 | import("../lib/account").AccountKeyAlgorithm.ECDSA_SECP256R1>[];
+    accounts: Account<import("../lib/account").AccountKeyAlgorithm.ECDSA_SECP256K1>[];
+    nodes: LocalNode[];
+    trustedClients: KeetaNet.UserClient[];
+    userClients: KeetaNet.UserClient[];
+    networkAddress: import("../lib/account").NetworkAddress;
+    baseToken: import("../lib/account").TokenAddress;
+    params: ClientParams;
+    cleanupFunctions: (() => Promise<void>)[];
+}>;
+declare function runBasicTests(nodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, _ignoreExpectErrorCode: any): Promise<void>;
+declare function runBuilderStorageTests(_ignoreNodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
+declare function runRecoverAccountTest(nodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
+declare function runNonNodeTests(_ignore_nodes: LocalNode[], _ignore_userClient: UserClient, _ignore_trustedClient: UserClient, _ignore_params: ClientParams, expect: any, _ignore_ExpectErrorCode: any): Promise<void>;
+export declare const clientTests: {
+    'Basic Client Tests': {
+        test: typeof runBasicTests;
+        options: {
+            p2pTested: boolean;
+            count: number;
+        };
+    };
+    'Basic Client Tests (No Node)': {
+        test: typeof runNonNodeTests;
+        options: {
+            p2pTested: boolean;
+            count: number;
+            timeout: number;
+        };
+    };
+    'Builder/Storage Test': {
+        test: typeof runBuilderStorageTests;
+        options: {
+            p2pTested: boolean;
+            count: number;
+        };
+    };
+    'Recover Account Test': {
+        test: typeof runRecoverAccountTest;
+        options: {
+            p2pTested: boolean;
+            count: number;
+        };
+    };
+};
+export declare const KeetaNetError: typeof KeetaError;
+export { toJSONSerializable };