@keetanetwork/keetanet-client 0.10.2

package/lib/utils/helper.d.ts

@@ -0,0 +1,67 @@
+import type { JSONSerializable } from './conversion';
+export type DistributiveOmit<T, P extends PropertyKey> = T extends T ? Omit<T, P> : never;
+export declare function bufferToArrayBuffer(input: Buffer): ArrayBuffer;
+/**
+ * Check if a value is an integer or a bigint.
+ */
+export declare function isIntegerOrBigInt(value: unknown): boolean;
+/**
+ * Check if a value is a Buffer. This exists due to an inconsistency with the
+ * way `Buffer.isBuffer` is defined in `@types/node` and differs from similar
+ * functionality such as `Array.isArray`. This leads `Buffer.isBuffer` to
+ * result in an unbound method reference error despite being a static call.
+ * Eslint Rule: eslint@typescript-eslint/unbound-method
+ */
+export declare function isBuffer(value: unknown): value is Buffer;
+export declare function arrayRepeat<T>(value: T, length: number): T[];
+/**
+ * Waits a specific number of ticks and then resolves
+ */
+export declare function waitTicks(ticks: number): Promise<void>;
+/**
+ * Returns env variable, or default
+ * Throws if neither are defined
+ */
+export declare function env(name: string, defaultValue?: string): string;
+/**
+ * Generate a random string from length provided (default 32)
+ */
+export declare function randomString(requestedLength?: number): string;
+export declare function randomInt(min: number, max: number): number;
+export declare function asleep(time_ms: number): Promise<void>;
+export declare function promiseGenerator<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (error: any) => void;
+};
+export declare function internalLogger(nodeAlias: string | undefined, level: string, from: string, ...message: any[]): void;
+export declare function objectToBuffer(input: any): Buffer;
+export declare function debugPrintableObject(input: any): JSONSerializable;
+interface Constructor<T> {
+    new (...args: any[]): T;
+}
+interface IsInstance<T> {
+    check(obj: any, strict?: boolean): obj is T;
+}
+export declare function checkableGenerator<P extends Constructor<T>, T = InstanceType<P>>(parent: P, defaultStrict?: boolean): IsInstance<T>['check'];
+export type DeepMutable<T> = {
+    -readonly [P in keyof T]: DeepMutable<T[P]>;
+};
+interface WithIsInstance<Inst> extends Constructor<Inst> {
+    isInstance(arg: any): arg is Inst;
+}
+type EncodeFunc<Inst, Enc> = (a: Inst) => Enc;
+type DecodeFunc<Inst, Enc> = (a: Enc) => Inst;
+type CanBeArray<T> = T | T[];
+export interface InstanceSet<Instance, Encoded = string> extends Set<Encoded> {
+    add(data: CanBeArray<Instance | Encoded>): this;
+    delete(data: Instance | Encoded): boolean;
+    has(data: Instance | Encoded): boolean;
+    decodedArray: Instance[];
+    encodedArray: Encoded[];
+}
+export interface InstanceSetConstructor<Instance, Encoded> {
+    new (data?: (Instance | Encoded)[]): InstanceSet<Instance, Encoded>;
+}
+export declare function setGenerator<P extends WithIsInstance<Instance>, E extends EncodeFunc<Instance, Encoded>, D extends DecodeFunc<Instance, Encoded>, Instance = InstanceType<P>, Encoded = ReturnType<E>>(parent: P, rawEncode: E, rawDecode: D): InstanceSetConstructor<Instance, Encoded>;
+export {};

package/lib/utils/helper_testing.d.ts

@@ -0,0 +1,37 @@
+import Account from '../account';
+import LocalNode from '../node/local';
+import { VoteStaple } from '../vote';
+import type { Block } from '../block';
+export declare const testingNetworkId: bigint;
+type NodeConfig = ConstructorParameters<typeof LocalNode>[0];
+export declare function canListenOn(ip: string): Promise<boolean>;
+export declare function findListenableIP(checkIPs: string[]): Promise<string | null>;
+export declare function findListenableBindingForTest(options?: Pick<CreateTestNodeOptions, 'simulatedPhysicalNetwork'>): Promise<{
+    ip: string;
+    port: number;
+}>;
+export type CreateTestNodeOptions = {
+    name?: string;
+    peerNodes?: LocalNode[];
+    enableP2P?: boolean;
+    p2p?: Partial<NodeConfig['p2p']>;
+    ledger?: Partial<NodeConfig['ledger']>;
+    initialTrustedAccount?: Account;
+    createInitialVoteStaple?: boolean;
+    nodeConfig?: Partial<Omit<NodeConfig, 'p2p' | 'ledger' | 'initialTrustedAccount'>>;
+    simulatedPhysicalNetwork?: boolean;
+};
+export interface LocalNodeWithPrivateKey extends LocalNode {
+    config: NodeConfig & Required<Pick<NodeConfig, 'ledgerPrivateKey'>>;
+}
+export declare function createTestNode(account: Account, options?: CreateTestNodeOptions): Promise<LocalNodeWithPrivateKey>;
+export declare function getVotesFromSingleNode(node: LocalNode, fromAccount: Account, toAccount: Account, headBlock: Block | null): Promise<VoteStaple>;
+/**
+ * Run a command and get its output
+ */
+export declare function run(command: string, stdin: Buffer): {
+    output?: string;
+    ok: boolean;
+};
+declare let testMethod: (..._ignore_args: any[]) => any;
+export { testMethod };

package/lib/utils/initial.d.ts

@@ -0,0 +1,32 @@
+import Account from '../account';
+import Block from '../block';
+import type { VoteStaple } from '../vote';
+interface BaseGenerationConfig {
+    network: bigint;
+    initialTrustedAccount: Account;
+    voteSerial?: bigint;
+}
+interface InitialConfigSupply extends BaseGenerationConfig {
+    addSupply: {
+        recipient: Account;
+        amount: bigint;
+        delegate: boolean;
+        delegateTo?: Account;
+    };
+}
+type BlocksAlwaysReturn = {
+    networkAddress: Block;
+    baseToken: Block;
+    initialTrustedAccount: Block;
+};
+type BlocksWithAddSupply = BlocksAlwaysReturn & {
+    recipient: Block;
+    recipientSupply?: Block;
+};
+type InitialGenResponse<B extends BlocksAlwaysReturn> = {
+    voteStaple: VoteStaple;
+    blocks: B;
+};
+export declare function generateInitialVoteStaple(options: InitialConfigSupply): Promise<InitialGenResponse<BlocksWithAddSupply>>;
+export declare function generateInitialVoteStaple(options: BaseGenerationConfig): Promise<InitialGenResponse<BlocksAlwaysReturn>>;
+export {};

package/lib/utils/never.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Asserts that the provided value is never.
+ *
+ * This is useful for static type checking to ensure that all possible values
+ * are handled.
+ */
+export declare function assertNever(value: never): never;

package/lib/utils/redis.d.ts

@@ -0,0 +1,11 @@
+import { RedisClientType } from 'redis';
+export { RedisClientType };
+/**
+ * Single Redis Pool Client/Connection
+ */
+export declare class RedisClient {
+    #private;
+    constructor(host: string, password: string, port?: number);
+    destroy(): Promise<void>;
+    run<T>(code: (conn: RedisClientType) => Promise<T>): Promise<T>;
+}

package/lib/vote.d.ts

@@ -0,0 +1,273 @@
+import { Block, BlockHash } from './block';
+import type { BlockJSON, BlockJSONOutput } from './block';
+import Account from './account';
+import type { ASN1Date } from './utils/asn1';
+import type { JSONSupported, ToJSONSerializableOptions } from './utils/conversion';
+import BufferStorage from './utils/buffer';
+/**
+ * Representation of the vote
+ */
+export interface VoteJSON {
+    issuer: string | Account;
+    serial: string | bigint;
+    blocks: string[] | BlockHash[];
+    validityFrom: string | Date;
+    validityTo: string | Date;
+    signature: string | ArrayBuffer;
+}
+export interface VoteJSONOutput extends JSONSupported<VoteJSON> {
+    $permanent: boolean;
+    $trusted: boolean;
+    $uid: string;
+}
+export interface VoteStapleJSON {
+    blocks: BlockJSON[] | BlockJSONOutput[];
+    votes: VoteJSON[] | VoteJSONOutput[];
+}
+declare class VoteHash extends BufferStorage {
+    static isInstance: (obj: any, strict?: boolean) => obj is VoteHash;
+    readonly storageKind = "VoteHash";
+    constructor(blockhash: ConstructorParameters<typeof BufferStorage>[0]);
+}
+type CertificateOID = {
+    type: 'oid';
+    oid: string;
+};
+type CertificateVersionInfo = {
+    type: 'context';
+    value: number;
+    kind: 'explicit';
+    contains: bigint;
+};
+type CertificateIssuerOrSubject = {
+    type: 'set';
+    name: CertificateOID;
+    value: {
+        type: 'string';
+        kind: 'utf8';
+        value: string;
+    };
+};
+type CertificateValidity = (ASN1Date | Date);
+type CertificatePublicKeyInfo = [CertificateOID[], {
+    type: 'bitstring';
+    value: Buffer;
+}];
+type CertificateExtensions = {
+    type: 'context';
+    value: number;
+    kind: 'explicit';
+    contains: [
+        [
+            CertificateOID,
+            boolean,
+            Buffer
+        ]
+    ];
+};
+type CertificateSchema = [
+    version: CertificateVersionInfo,
+    serial: bigint,
+    signatureAlgo: CertificateOID[],
+    issuer: CertificateIssuerOrSubject[],
+    validity: [CertificateValidity, CertificateValidity],
+    subject: CertificateIssuerOrSubject[],
+    publicKey: CertificatePublicKeyInfo,
+    extensions: CertificateExtensions
+];
+/**
+ * Parse a set of distinguished names
+ */
+declare function findRDN(input: any[], findOID: string): any;
+declare function blockHashesFromVote(input: Buffer): BlockHash[];
+/**
+ * A map for VoteBlockHashes
+ */
+export declare class VoteBlockHashMap<ValueType = unknown> implements Map<VoteBlockHash, ValueType> {
+    #private;
+    constructor();
+    [Symbol.iterator](): IterableIterator<[VoteBlockHash, ValueType]>;
+    [Symbol.toStringTag]: string;
+    add(key: VoteBlockHash, value: ValueType): this;
+    delete(key: VoteBlockHash): boolean;
+    get(key: VoteBlockHash): ValueType | undefined;
+    forEach(callbackfn: (value: ValueType, key: VoteBlockHash, map: Map<VoteBlockHash, ValueType>) => void, thisArg?: any): void;
+    has(key: VoteBlockHash): boolean;
+    set(key: VoteBlockHash, value: ValueType): this;
+    get size(): number;
+    entries(): IterableIterator<[VoteBlockHash, ValueType]>;
+    keys(): IterableIterator<VoteBlockHash>;
+    values(): IterableIterator<ValueType>;
+    clear(): void;
+}
+/**
+ * A VoteBlockHash is a hash of the blocks in a vote staple or vote staple
+ * it is a unique ID for the vote or vote staples contents regardless of which
+ * votes are included in the staple -- every vote in a vote staple has the same
+ * VoteBlockHash.
+ */
+export declare class VoteBlockHash extends BufferStorage {
+    static isInstance: (obj: any, strict?: boolean) => obj is VoteBlockHash;
+    static readonly Map: typeof VoteBlockHashMap;
+    readonly storageKind = "VoteBlockHash";
+    get hashFunctionName(): string;
+    static fromBlockHashes(blockHashes: BlockHash[]): VoteBlockHash;
+    static fromVote(vote: PossiblyExpiredVote | Vote): VoteBlockHash;
+    static fromVoteStaple(voteStaple: VoteStaple): VoteBlockHash;
+    constructor(stapleHash: ConstructorParameters<typeof BufferStorage>[0]);
+}
+/**
+ * Options for Votes
+ */
+type VoteOptions = {
+    /**
+     * The instant at which a vote's expiration is validated against (default is moment of instantiation)
+     */
+    now?: Date;
+};
+export declare class PossiblyExpiredVote {
+    #private;
+    readonly issuer: Account;
+    readonly serial: bigint;
+    readonly blocks: BlockHash[];
+    readonly validityFrom: Date;
+    readonly validityTo: Date;
+    readonly signature: ArrayBuffer;
+    readonly $trusted: boolean;
+    readonly $permanent: boolean;
+    readonly $uid: string;
+    protected static allowedSlop: number;
+    protected static permanentVoteThreshold: number;
+    static Staple: typeof VoteStaple;
+    static Builder: typeof VoteBuilder;
+    static readonly VoteBlocksHash: typeof VoteBlockHash;
+    static isInstance: (obj: any, strict?: boolean) => obj is PossiblyExpiredVote;
+    static isValidJSON(voteJSON: VoteJSON | VoteJSONOutput): voteJSON is VoteJSON | VoteJSONOutput;
+    static fromJSON(voteJSON: VoteJSON | VoteJSONOutput, options?: VoteOptions): PossiblyExpiredVote | Vote;
+    constructor(vote: Buffer | ArrayBuffer | PossiblyExpiredVote | Uint8Array | string | VoteJSON | VoteJSONOutput, options?: VoteOptions);
+    toBytes(): ArrayBuffer;
+    get hash(): VoteHash;
+    get blocksHash(): VoteBlockHash;
+    toString(): string;
+    toJSON(): VoteJSONOutput;
+    protected expirationCheckMoment(): number;
+    get expired(): boolean;
+}
+/**
+ * A vote is a certificate issued indicating that the issuer "vouches" for the
+ * blocks specified will fit into the ledger of the operator/issuer.
+ */
+export declare class Vote extends PossiblyExpiredVote {
+    readonly possiblyExpired = false;
+    static isInstance: (obj: any, strict?: boolean) => obj is Vote;
+    constructor(vote: Buffer | ArrayBuffer | Vote | PossiblyExpiredVote | string | VoteJSON | VoteJSONOutput, options?: VoteOptions);
+    static toJSONSerializablePrefix: string;
+    static toJSONSerializable(value: Vote, opts: ToJSONSerializableOptions): {
+        [x: string]: any;
+        $permanent: boolean;
+        $trusted: boolean;
+        $uid: string;
+    };
+}
+/**
+ * A vote staple is a distributable block consisting of one or more blocks
+ * and one or more votes.
+ */
+declare class VoteStapleHash extends BufferStorage {
+    static isInstance: (obj: any, strict?: boolean) => obj is VoteStapleHash;
+    readonly storageKind = "VoteStapleHash";
+    get hashFunctionName(): string;
+    constructor(stapleHash: ConstructorParameters<typeof BufferStorage>[0]);
+}
+export declare class VoteStaple {
+    #private;
+    static readonly VoteBlockHash: typeof VoteBlockHash;
+    /**
+     * Construct a new staple from votes and blocks
+     */
+    static fromVotesAndBlocks(votes: Vote[], blocks: Block[], voteOptions?: VoteOptions): VoteStaple;
+    /**
+     * Convert a list of Votes and Blocks into a VoteStaple
+     * This is slightly different from VoteStaple.fromVotesAndBlocks in
+     * that it will filter the supplied votes to only include those that
+     * are permanent if any permanent votes are present, otherwise only
+     * temporary votes will be included
+     *
+     * Additionally, it will filter out any votes that are expired
+     */
+    static fromVotesAndBlocksWithFiltering(votes: PossiblyExpiredVote[], blocks: Block[], opts: Parameters<typeof VoteStaple['fromVotesAndBlocks']>[2]): VoteStaple | null;
+    static fromVotesAndBlocksToHashMap(votes: PossiblyExpiredVote[], blocks: Block[], opts: Parameters<typeof VoteStaple['fromVotesAndBlocks']>[2] & {
+        voteBlockHashes?: VoteBlockHash[];
+    }): VoteBlockHashMap<VoteStaple | null>;
+    static isValidJSON(staple: VoteStapleJSON): boolean;
+    static fromJSON(staple: VoteStapleJSON, voteOptions?: VoteOptions): VoteStaple;
+    static isInstance: (obj: any, strict?: boolean) => obj is VoteStaple;
+    /**
+     * Construct a new staple from a message buffer
+     */
+    constructor(votesStapled: ArrayBuffer | Buffer | VoteStapleJSON | string, voteOptions?: VoteOptions);
+    /**
+     * Get the serialized version
+     */
+    toBytes(uncompressed?: boolean): ArrayBuffer;
+    toString(): string;
+    /**
+     * Get the serialized version as JSON
+     */
+    toJSON(): {
+        votes: VoteJSONOutput[];
+        blocks: BlockJSONOutput[];
+    };
+    /**
+     * Hash of the Vote Staple -- this is the hash of the data in the
+     * canonical form of the staple, which may be different from
+     * the hash of the data passed into the this object.
+     */
+    get hash(): VoteStapleHash;
+    /**
+     * Get the hash of the blockhashes in the staple -- this is a stable ID
+     * for the staple regardless of which votes are included in the staple.
+     */
+    get blocksHash(): VoteBlockHash;
+    /**
+     * Get the votes for this staple
+     */
+    get votes(): Vote[];
+    /**
+     * Get the blocks for this staple
+     */
+    get blocks(): Block[];
+    /**
+     * Get the timestamp of the staple
+     *
+     * This is the average of the timestamps of the votes, unless a
+     * particular account is specified then that timestamp is used
+     * if it issued a vote in the staple.
+     */
+    timestamp(preferRep?: Account): Date;
+    static toJSONSerializablePrefix: string;
+    static toJSONSerializable(value: VoteStaple, opts: ToJSONSerializableOptions): {
+        votes: VoteJSONOutput[];
+        blocks: BlockJSONOutput[];
+        $binary?: string;
+    };
+}
+export declare class VoteBuilder {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is VoteBuilder;
+    constructor(account: Account, blocks?: (Block | BlockHash)[]);
+    addBlocks(blocks: (Block | BlockHash | string)[]): void;
+    addBlock(block: Block | BlockHash | string): void;
+    generateVoteData(serial: bigint, validTo: Date, validFrom: Date): {
+        voteData: ArrayBuffer;
+        tbsCertificate: CertificateSchema;
+        signatureInfo: CertificateOID[];
+    };
+    createVote(voteData: ArrayBuffer, tbsCertificate: CertificateSchema, signatureInfo: CertificateOID[], signature: BufferStorage, voteOptions?: VoteOptions): Vote;
+    seal(serial: bigint, validTo: Date | null, validFrom?: Date, voteOptions?: VoteOptions): Promise<Vote>;
+}
+export default Vote;
+export declare const Testing: {
+    findRDN: typeof findRDN;
+    blockHashesFromVote: typeof blockHashesFromVote;
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+	"name": "@keetanetwork/keetanet-client",
+	"repository": "https://github.com/keetanetwork/node.git",
+	"version": "0.10.2",
+	"description": "KeetaNet Client TypeScript Reference Implementation",
+	"files": [
+		"**/*.js",
+		"**/*.d.ts"
+	],
+	"types": "./client/index.d.ts",
+	"author": "Keeta Token Genesis LLC",
+	"license": "see LICENSE",
+	"devDependencies": {
+		"@noble/curves": "1.6.0",
+		"@safeheron/crypto-ecies": "1.0.0",
+		"asn1js": "2.4.0",
+		"ecies-25519": "1.3.1",
+		"ecies-geth": "1.7.3",
+		"elliptic": "6.6.0",
+		"futoin-hkdf": "1.5.3",
+		"isomorphic-ws": "5.0.0",
+		"node-fetch": "2.7.0",
+		"rfc4648": "1.5.4",
+		"uuid": "11.0.3",
+		"ws": "8.18.0"
+	},
+	"dependencies": {
+		"secp256k1": "5.0.1"
+	},
+	"optionalDependencies": {
+		"@keetanetwork/asn1-napi-rs": "1.1.9"
+	},
+	"browser": "./client/index-browser.js",
+	"main": "./client/index.js"
+}

package/version.d.ts

@@ -0,0 +1,2 @@
+export declare const version = "0.10.2";
+export default version;