@_koii/task-node 1.12.37

package/dist/taskNodeLib.d.ts

@@ -0,0 +1,712 @@
+import { PublicKey, Keypair, AccountInfo, Connection } from '@_koii/web3.js';
+import { Application, RequestHandler } from 'express';
+import { ChildProcess } from 'child_process';
+import { WriteStream } from 'fs';
+import * as BufferLayout from '@solana/buffer-layout';
+import * as jsonwebtoken from 'jsonwebtoken';
+import * as fsPromises from 'fs/promises';
+
+interface IDatabase {
+    get(key: string, callback?: () => void): Promise<any>;
+    put(key: string, value: string, callback?: () => void): Promise<void>;
+}
+
+interface TaskData {
+    task_id?: string;
+    task_name?: string;
+    task_manager?: PublicKey;
+    task_audit_program?: string;
+    stake_pot_account?: PublicKey;
+    bounty_amount_per_round?: number;
+}
+declare enum LogLevel {
+    Log = "log",
+    Warn = "warn",
+    Error = "error"
+}
+interface INode {
+    data: {
+        url: string | undefined;
+        timestamp: number;
+    };
+    signature: string;
+    owner: string;
+    submitterPubkey: string;
+}
+/**
+ * @dev We need this additional interface because the constructor only sits on the
+ * static side of the class, not on the instance side.
+ */
+interface IRunningTasks<T extends ITaskNodeBase> {
+    [key: string]: {
+        namespace: T;
+        child: ChildProcess;
+        expressAppPort: number;
+        secret: string;
+    };
+}
+interface ISelectedTasks {
+    task_name: string;
+    task_id: string;
+    task_audit_program: string;
+    task_manager?: PublicKey;
+    stake_pot_account?: PublicKey;
+    bounty_amount_per_round?: number;
+    round_time: number;
+    starting_slot: number;
+    audit_window: number;
+    submission_window: number;
+    task_executable_network: string;
+    task_metadata: string;
+    task_type: string;
+}
+declare type ExpressMethodType = 'get' | 'post' | 'put' | 'delete';
+interface TaskNodeConfig {
+    taskTxId: string;
+    mainSystemAccount: Keypair | null | undefined;
+    taskData: TaskData;
+    serverApp: Application | null;
+    db: IDatabase;
+    rpcUrl: string;
+    taskType: string;
+}
+interface ITaskNodeBaseWithConstructor extends ITaskNodeBase {
+    new (config: TaskNodeConfig): ITaskNodeBase;
+}
+interface ITaskNodeBase {
+    /**
+     * @param {string} taskTxId - Tasks transaction ID to be used as the namespace name
+     */
+    taskTxId: string;
+    /**
+     * @param {Application} app - Express app instance
+     */
+    serverApp: Application | null;
+    /**
+     * @param {IDatabase} db - Database adapter
+     */
+    db: IDatabase;
+    rpcUrl: string;
+    taskType: string;
+    mainSystemAccount: Keypair | null | undefined;
+    mainSystemAccountPubKey: PublicKey;
+    taskAccountInfo: AccountInfo<Buffer> | null;
+    taskData: TaskData;
+    appDataPath: string;
+    submitterAccountKeyPair: Keypair;
+    distributionAccountKeyPair: Keypair;
+    submitterPubkey: string;
+    distributionPubKey: string;
+    connection: Connection;
+    taskStateInfoPublicKey: PublicKey;
+    stakePotAccount: PublicKey;
+    getMainSystemAccountPubKey(): Promise<Keypair>;
+    storeGet(key: string): Promise<any>;
+    storeGetRaw(key: string): Promise<string | null>;
+    storeSet(key: string, value: string): Promise<void>;
+    jwtSign(accessToken: string, secret: string): Promise<string>;
+    jwtVerify(accessToken: string, secret: string): Promise<any>;
+    fs(method: any, path: any, ...args: any): Promise<any>;
+    fsStaking(method: any, path: any, ...args: any[]): Promise<any>;
+    fsWriteStream(imagepath: string): Promise<WriteStream>;
+    fsReadStream(imagepath: string): Promise<Buffer>;
+    express(method: ExpressMethodType, path: string, callback: () => void): Application;
+    submissionOnChain(submitterKeypair: Keypair, submission: string, round: number): Promise<string>;
+    stakeOnChain(taskStateInfoPublicKey: PublicKey, stakingAccKeypair: Keypair, stakePotAccount: PublicKey, stakeAmount: number): Promise<string>;
+    claimReward(stakePotAccount: PublicKey, beneficiaryAccount: PublicKey, claimerKeypair: Keypair): Promise<string>;
+    sendTransaction(serviceNodeAccount: PublicKey, beneficiaryAccount: PublicKey, amount: number): Promise<string>;
+    bs58Encode(data: Uint8Array): Promise<string>;
+    bs58Decode(data: any): Promise<Uint8Array>;
+    signData(data: any): Promise<string>;
+    verifySignedData(signedData: any, publicKey: string): Promise<{
+        error: string;
+        data?: undefined;
+    } | {
+        data: string;
+        error?: undefined;
+    }>;
+    sendAndConfirmTransactionWrapper(transaction: any, signers: any[]): Promise<string>;
+    establishConnection(): Promise<void>;
+    getTaskState(options: TaskStateOptions): Promise<any>;
+    getSubmitterAccount(): Promise<Keypair | null>;
+    checkSubmissionAndUpdateRound(submissionValue: string, round: number): Promise<void>;
+    getProgramAccounts(): Promise<{
+        pubkey: PublicKey;
+        account: AccountInfo<Buffer>;
+    }[]>;
+    defaultTaskSetup(): Promise<void>;
+    getRpcUrl(): string;
+    getNodes(url: string): Promise<Array<INode>>;
+    payloadTrigger(round: number): Promise<string>;
+    payloadTriggerOnBehalf(round: any, distribution_account_key: any): Promise<string>;
+}
+interface AuditTriggerState {
+    trigger_by: PublicKey;
+    slot: number;
+    votes: Array<{
+        is_valid: boolean;
+        voter: PublicKey;
+        slot: number;
+    }>;
+}
+declare type SubmissionsPerRound = Record<Round, Record<PublicKeyString, Submission>>;
+declare type Round = string;
+declare type PublicKeyString = string;
+declare type Submission = {
+    submission_value: string;
+    slot: number;
+};
+declare type ROE = number;
+interface TaskState {
+    task_id: string;
+    task_name: string;
+    task_manager: PublicKey;
+    is_allowlisted: boolean;
+    is_active: boolean;
+    task_audit_program: string;
+    stake_pot_account: PublicKey;
+    total_bounty_amount: number;
+    bounty_amount_per_round: number;
+    current_round: number;
+    available_balances: Record<string, ROE>;
+    stake_list: Record<string, ROE>;
+    task_metadata: string;
+    task_description: string;
+    submissions: SubmissionsPerRound;
+    submissions_audit_trigger: Record<string, Record<string, AuditTriggerState>>;
+    total_stake_amount: number;
+    minimum_stake_amount: number;
+    ip_address_list: Record<string, string>;
+    round_time: number;
+    starting_slot: number;
+    audit_window: number;
+    submission_window: number;
+    task_executable_network: 'IPFS' | 'ARWEAVE';
+    distribution_rewards_submission: SubmissionsPerRound;
+    distributions_audit_trigger: Record<string, Record<string, AuditTriggerState>>;
+    distributions_audit_record: Record<string, 'Uninitialized' | 'PayoutSuccessful' | 'PayoutFailed'>;
+    task_vars: string;
+    koii_vars: string;
+    is_migrated: boolean;
+    migrated_to: string;
+    allowed_failed_distributions: number;
+}
+interface TaskStateKPL {
+    task_id: string;
+    task_name: string;
+    task_manager: PublicKey;
+    is_allowlisted: boolean;
+    is_active: boolean;
+    task_audit_program: string;
+    stake_pot_account: PublicKey;
+    stake_pot_seed: PublicKey;
+    stake_pot_bump: number;
+    total_bounty_amount: number;
+    bounty_amount_per_round: number;
+    token_type: PublicKey;
+    current_round: number;
+    available_balances: Record<string, ROE>;
+    stake_list: Record<string, ROE>;
+    task_metadata: string;
+    task_description: string;
+    submissions: SubmissionsPerRound;
+    submissions_audit_trigger: Record<string, Record<string, AuditTriggerState>>;
+    total_stake_amount: number;
+    minimum_stake_amount: number;
+    ip_address_list: Record<string, string>;
+    round_time: number;
+    starting_slot: number;
+    audit_window: number;
+    submission_window: number;
+    task_executable_network: 'IPFS' | 'ARWEAVE';
+    distribution_rewards_submission: SubmissionsPerRound;
+    distributions_audit_trigger: Record<string, Record<string, AuditTriggerState>>;
+    distributions_audit_record: Record<string, 'Uninitialized' | 'PayoutSuccessful' | 'PayoutFailed'>;
+    task_vars: string;
+    koii_vars: string;
+    is_migrated: boolean;
+    migrated_to: string;
+    allowed_failed_distributions: number;
+}
+interface TaskStateOptions {
+    is_submission_required?: boolean;
+    is_distribution_required?: boolean;
+    is_available_balances_required?: boolean;
+    is_stake_list_required?: boolean;
+}
+
+declare class DbAdapter implements IDatabase {
+    private static instance;
+    private db;
+    constructor(databasePath: string);
+    static getInstance(databasePath: string): DbAdapter;
+    compactDatafile(): void;
+    get(key: string): Promise<unknown>;
+    put(key: string, value: string): Promise<void>;
+}
+
+interface ExecuteTasksPayload {
+    selectedTasks: ISelectedTasks[];
+    expressApp: Application;
+    operationMode: string;
+    Namespace: ITaskNodeBaseWithConstructor;
+    mainSystemAccount: Keypair;
+    secrets: Record<string, string>;
+    attentionStake: unknown;
+    taskStakes?: string;
+    k2NodeUrl?: string;
+    serviceUrl?: string;
+    db: IDatabase;
+}
+declare function executeTasks({ selectedTasks, expressApp, operationMode, Namespace, mainSystemAccount, secrets, attentionStake, taskStakes, k2NodeUrl, serviceUrl, db, }: ExecuteTasksPayload): Promise<void>;
+
+declare enum FilesystemNetwork {
+    ARWEAVE = "ARWEAVE",
+    IPFS = "IPFS"
+}
+/**
+ * Load tasks and generate task executables
+ * @param {any[]} selectedTasks Array of selected tasks
+ * @param {any} expressApp
+ * @returns {any[]} Array of executable tasks
+ */
+declare function loadTasks(selectedTasks: ISelectedTasks[], environment: string): Promise<void>;
+
+declare function encodeData(type: any, fields: any): Buffer;
+
+declare function getAlloc(type: any, fields: any): number;
+
+/**
+ * @description Get URL from K2_NODE_URL environment variable
+ * @todo: probably should not be exported to the package
+ */
+declare function getRpcUrlWrapper(): string;
+
+declare function padStringWithSpaces(input: string, length: number): string;
+
+declare function makeChunks(data: Buffer, size: number): any[];
+
+declare function sleep(ms: any): Promise<unknown>;
+
+/** CORE TIMER LOGIC - BEGIN */
+
+interface IGlobalTimersConfig {
+    KPL_tasks: string[];
+    selectedTasks: ISelectedTasks[];
+    runningTasks: IRunningTasks<ITaskNodeBase>;
+    setTimerForRewards?: (value: number) => void;
+    networkURL?: string;
+}
+declare function runTimers({ KPL_tasks, selectedTasks, runningTasks, setTimerForRewards, networkURL, }: IGlobalTimersConfig): Promise<NodeJS.Timer | undefined>;
+declare function updateRewardsQueue(KPL_tasks: string[], setTimerForRewards: any, connection: Connection): Promise<void>;
+
+declare function getAverageSlotTime(connection: Connection, prevAvgSlotTime?: number, samplesNumber?: number): Promise<number>;
+
+declare function getCurrentSlot(connection: Connection): Promise<number>;
+
+declare function getTaskState(connection: Connection, taskId: string, options: TaskStateOptions, context?: string): Promise<TaskState>;
+declare function getTaskStateKPL(connection: {
+    getAccountInfo: (arg0: PublicKey) => any;
+}, taskId: string, options: TaskStateOptions, context?: string): Promise<TaskStateKPL>;
+
+interface TaskSubmissionState {
+    submissions: SubmissionsPerRound;
+    submissions_audit_trigger: Record<string, Record<string, AuditTriggerState>>;
+}
+declare function getTaskSubmissionInfo(connection: Connection, taskId: string, round?: number, task_type?: string, forceRefetch?: boolean): Promise<TaskSubmissionState>;
+
+interface TaskDistributionInfo {
+    distribution_rewards_submission: SubmissionsPerRound;
+    distributions_audit_trigger: Record<string, Record<string, AuditTriggerState>>;
+    distributions_audit_record: Record<string, 'Uninitialized' | 'PayoutSuccessful' | 'PayoutFailed'>;
+}
+declare function getTaskDistributionInfo(connection: Connection, taskId: string, round?: number, task_type?: string): Promise<TaskDistributionInfo>;
+
+interface MyTaskSubmission {
+    submission_value: string;
+    slot: number;
+}
+declare function getMyTaskSubmissionRoundInfo(connection: Connection, taskId: string, staking_wallet_address: string, round: number): Promise<MyTaskSubmission>;
+
+declare function getMyTaskStakeInfo(connection: Connection, taskId: string, staking_wallet_address: string): Promise<number>;
+
+declare function decodeZstd(base64ZstdData: string): Promise<Buffer>;
+
+declare const TASK_INSTRUCTION_LAYOUTS: Readonly<{
+    CreateTask: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            task_name: Uint8Array;
+            task_description: Uint8Array;
+            task_audit_program: Buffer;
+            task_executable_network: Buffer;
+            total_bounty_amount: bigint;
+            bounty_amount_per_round: bigint;
+            round_time: bigint;
+            audit_window: bigint;
+            submission_window: bigint;
+            minimum_stake_amount: bigint;
+            task_metadata: Buffer;
+            local_vars: Buffer;
+        }>;
+    };
+    SubmitTask: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            submission: Uint8Array;
+            round: bigint;
+        }>;
+    };
+    AuditSubmissions: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            is_valid: bigint;
+            round: bigint;
+        }>;
+    };
+    AuditDistribution: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            is_valid: bigint;
+            round: bigint;
+        }>;
+    };
+    Payout: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            round: number;
+        }>;
+    };
+    Whitelist: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            isWhitelisted: bigint;
+        }>;
+    };
+    SetActive: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            isActive: bigint;
+        }>;
+    };
+    ClaimReward: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+        }>;
+    };
+    FundTask: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            amount: bigint;
+        }>;
+    };
+    Stake: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            stakeAmount: bigint;
+            ipAddress: Uint8Array;
+        }>;
+    };
+    Withdraw: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+        }>;
+    };
+    UploadDistributionList: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            instruction_data: ArrayBuffer;
+        }>;
+    };
+    SubmitDistributionList: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            round: bigint;
+        }>;
+    };
+}>;
+declare type TaskInstructionLayouts = typeof TASK_INSTRUCTION_LAYOUTS;
+
+declare const TASK_INSTRUCTION_LAYOUTS_KPL: Readonly<{
+    CreateTask: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            task_name: Uint8Array;
+            task_description: Uint8Array;
+            task_audit_program: Buffer;
+            task_executable_network: Buffer;
+            total_bounty_amount: bigint;
+            bounty_amount_per_round: bigint;
+            round_time: bigint;
+            audit_window: bigint;
+            submission_window: bigint;
+            minimum_stake_amount: bigint;
+            task_metadata: Buffer;
+            local_vars: Buffer;
+        }>;
+    };
+    SubmitTask: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            submission: Uint8Array;
+            round: bigint;
+        }>;
+    };
+    AuditSubmissions: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            is_valid: bigint;
+            round: bigint;
+        }>;
+    };
+    AuditDistribution: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            is_valid: bigint;
+            round: bigint;
+        }>;
+    };
+    Payout: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            round: number;
+        }>;
+    };
+    Whitelist: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            isWhitelisted: bigint;
+        }>;
+    };
+    SetActive: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            isActive: bigint;
+        }>;
+    };
+    ClaimReward: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+        }>;
+    };
+    FundTask: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            amount: bigint;
+        }>;
+    };
+    Stake: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            stakeAmount: bigint;
+            ipAddress: Uint8Array;
+        }>;
+    };
+    Withdraw: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+        }>;
+    };
+    UploadDistributionList: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            instruction_data: ArrayBuffer;
+        }>;
+    };
+    SubmitDistributionList: {
+        index: number;
+        layout: BufferLayout.Structure<{
+            instruction: number;
+            round: bigint;
+        }>;
+    };
+}>;
+declare type KPLTaskInstructionLayouts = typeof TASK_INSTRUCTION_LAYOUTS_KPL;
+
+declare const DEFAULT_PROGRAM_ID = "Koiitask22222222222222222222222222222222222";
+declare const TASK_CONTRACT_ID: PublicKey;
+declare const CLOCK_PUBLIC_KEY: PublicKey;
+declare const BUNDLER_NODES = "/nodes";
+declare const ARWEAVE_GATEWAY_URL = "https://arweave.net/";
+declare const IPFS_GATEWAY_URL = "https://ipfs.io/ipfs/";
+declare const KPL_PROGRAM_ID = "KPLTRVs6jA7QTthuJH2cEmyCEskFbSV2xpZw46cganN";
+declare const KPL_CONTRACT_ID: PublicKey;
+
+declare abstract class TaskNodeBase implements ITaskNodeBase {
+    abstract getSubmitterAccount(): Promise<Keypair | null>;
+    abstract getMainSystemAccountPubKey(db?: IDatabase): Promise<Keypair>;
+    abstract getDistributionAccount(): Promise<Keypair | null>;
+    db: IDatabase;
+    mainSystemAccount: Keypair | null | undefined;
+    taskData: TaskData;
+    mainSystemAccountPubKey: PublicKey;
+    taskAccountInfo: AccountInfo<Buffer> | null;
+    submitterAccountKeyPair: Keypair;
+    distributionAccountKeyPair: Keypair;
+    submitterPubkey: string;
+    distributionPubKey: string;
+    connection: Connection;
+    taskStateInfoPublicKey: PublicKey;
+    stakePotAccount: PublicKey;
+    taskTxId: string;
+    serverApp: Application | null;
+    rpcUrl: string;
+    taskType: string;
+    loggerCallback: null | ((level: LogLevel, message: string, action: string) => void);
+    constructor({ mainSystemAccount, taskTxId, taskData, serverApp, db, rpcUrl, taskType, }: TaskNodeConfig);
+    appDataPath: string;
+    storeGet(key: string): Promise<any>;
+    /**
+     * Namespace wrapper over storeSetAsync
+     * @param {string} key Path to set
+     * @param {*} value Data to set
+     * @returns {Promise<void>}
+     */
+    storeSet(key: string, value: string): Promise<void>;
+    jwtSign(accessToken: string, secret: string): Promise<string>;
+    jwtVerify(accessToken: string, secret: string): Promise<string | jsonwebtoken.JwtPayload>;
+    /**
+     * Namespace wrapper over fsPromises methods
+     * @param {*} method The fsPromise method to call
+     * @param {*} path Path for the express call
+     * @param  {...any} args Remaining parameters for the FS call
+     * @returns {Promise<any>}
+     */
+    fs(method: keyof typeof fsPromises, path: string, ...args: unknown[]): Promise<unknown>;
+    fsStaking(method: keyof typeof fsPromises, path: any, ...args: any[]): Promise<unknown>;
+    fsWriteStream(imagepath: string): Promise<WriteStream>;
+    fsReadStream(imagepath: string): Promise<Buffer>;
+    /**
+     * Namespace wrapper over express app methods
+     * @param {string} method // Receive method ["get", "post", "put", "delete"]
+     * @param {string} path // Endpoint path appended to namespace
+     * @param {Function} callback // Callback function on traffic receive
+     */
+    express(method: ExpressMethodType, path: string, callback: RequestHandler): Application;
+    /**
+     * Wrapper function for the OnChain submission for Task contract
+     * @param {Connection} connection // The k2 connection object
+     * @param {PublicKey} taskStateInfoKeypairPubKey // Task Id
+     * @param {Keypair} submitterPubkey //The keypair of the submitter node
+     * @param {string} submission // The actual submission to onchain (cannot pe greater than 512 bytes)
+     */
+    submissionOnChain(submitterKeypair: Keypair, submission: string, round: number): Promise<string>;
+    distributionListSubmissionOnChain(round: number): Promise<string>;
+    stakeOnChain(taskStateInfoPublicKey: PublicKey, stakingAccKeypair: Keypair, stakePotAccount: PublicKey, stakeAmount: number): Promise<string>;
+    claimReward(stakePotAccount: PublicKey, beneficiaryAccount: PublicKey, claimerKeypair: Keypair, taskStateInfoPublicKey?: PublicKey): Promise<string>;
+    sendTransaction(serviceNodeAccount: PublicKey, beneficiaryAccount: PublicKey, amount: number): Promise<string>;
+    bs58Encode(data: Uint8Array): Promise<string>;
+    bs58Decode(data: any): Promise<Uint8Array>;
+    signData(data: any): Promise<string>;
+    verifySignedData(signedData: any, publicKey: string): Promise<{
+        error: string;
+        data?: undefined;
+    } | {
+        data: string;
+        error?: undefined;
+    }>;
+    decodePayload(payload: Uint8Array): string;
+    setLoggerCallback(callback: (level: LogLevel, message: string, action: string) => void): void;
+    logger(level: LogLevel, message: string, action: string): Promise<boolean>;
+    /**
+     * @consider to remove it from here and add it just to the Task Node, it is not used in the Desktop Node
+     */
+    sendAndConfirmTransactionWrapper(transaction: any, signers: any[]): Promise<string>;
+    /**
+     * @todo: fix types
+     */
+    mapSignersToKeypairs(signers: any[]): Keypair[];
+    establishConnection(): Promise<void>;
+    /**
+     * @description Get the latest Task State
+     * @returns task data in JSON format
+     */
+    getTaskState(options: TaskStateOptions, context?: string): Promise<TaskState>;
+    /**
+     * @description Refers the value of round to know if submission is allowed or not
+     */
+    checkSubmissionAndUpdateRound(submissionValue: string, round: number): Promise<void>;
+    /**
+     * @description Get the latest Task State
+     * @returns task data in JSON format
+     */
+    getProgramAccounts(): Promise<{
+        pubkey: PublicKey;
+        account: AccountInfo<Buffer>;
+    }[]>;
+    getRpcUrl(): string;
+    storeGetRaw(key: string): Promise<string | null>;
+    defaultTaskSetup(): Promise<void>;
+    /**
+     * Gets an array of service nodes
+     * @param url URL of the service node to retrieve the array from a known service node
+     * @returns Array of service nodes
+     */
+    getNodes(url: string): Promise<Array<INode>>;
+    getTaskStateById(taskId: string, options: TaskStateOptions, task_type: string, context?: string): Promise<TaskState>;
+    getCurrentSlot(): Promise<number>;
+    payloadTriggerOnBehalf(round: any, distribution_account_key: any): Promise<string>;
+    getCacheNodes(taskId: string): Promise<INode[]>;
+    /**
+     * @todo: ask Syed if we can get taskId from the class
+     */
+    registerNodes(newNodes: any, taskId: string): Promise<boolean>;
+    payloadTrigger(round: any): Promise<string>;
+    getRound(): Promise<number>;
+    uploadDistributionList(distributionListDataBlob: object, round: number): Promise<boolean | null>;
+    distributionListAuditSubmission(candidatePubkey: PublicKey, isValid: boolean, round: number): Promise<string>;
+    /**
+     * Wrapper function for the OnChain Voting for Task contract
+     * @param {Connection} connection // The k2 connection object
+     * @param {PublicKey} candidatePubkey // Candidate public key who submitted the task and you are approving whose task is correct
+     * @param {Keypair} voterKeypair // Voter keypair optional, by default will use the your task account keypair
+     * @param {boolean} isValid // Boolean indicating submission is valid or Invalid
+  
+     */
+    auditSubmission(candidatePubkey: PublicKey, isValid: boolean, round: number): Promise<string>;
+    getDistributionList(publicKey: string, round: string, taskId?: string): Promise<string | null>;
+    getTaskSubmissionInfo(round: number): Promise<TaskSubmissionState | null>;
+    getTaskDistributionInfo(round: number): Promise<TaskDistributionInfo | null>;
+    getAverageSlotTime(): Promise<number>;
+    validateUploadedDistributionList(publicKey: PublicKey, round: string, originalDistributionList: object): Promise<boolean>;
+    shallowEqual(parsed: any, generateDistributionList: any): Promise<boolean>;
+    getBincodeDeserializedDistributionList(raw_data: any, round: string, taskId: string): string | null;
+    retryFailedTransactions(dataByteCount: number, chunks: Array<Uint8Array>, ourAccount: Keypair, uploadAccount: Keypair, round: string, orginalDistributionList: any, totalChunks: number): Promise<boolean>;
+    private insertStringAt;
+    getTaskLevelDBPath(): Promise<string>;
+    getBasePath(): Promise<string>;
+    getTaskNodeVersion(): Promise<string>;
+}
+
+/**
+ * Run loop that executes every 5 minutes
+ */
+declare function runPeriodic(selectedTasks: any, namespace: any, mainSystemWalletAccount: Keypair, serviceUrl: string, haveStaticIP: boolean): Promise<void>;
+declare function initialPropagation(selectedTasks: any, attentionTaskId: string, namespace: any, mainSystemWalletAccount: Keypair, serviceUrl: string, haveStaticIP: boolean): Promise<any>;
+
+export { ARWEAVE_GATEWAY_URL, AuditTriggerState, BUNDLER_NODES, CLOCK_PUBLIC_KEY, DEFAULT_PROGRAM_ID, DbAdapter, ExpressMethodType, FilesystemNetwork, IDatabase, IGlobalTimersConfig, INode, IPFS_GATEWAY_URL, IRunningTasks, ISelectedTasks, ITaskNodeBase, ITaskNodeBaseWithConstructor, KPLTaskInstructionLayouts, KPL_CONTRACT_ID, KPL_PROGRAM_ID, LogLevel, PublicKeyString, Round, Submission, SubmissionsPerRound, TASK_CONTRACT_ID, TASK_INSTRUCTION_LAYOUTS, TASK_INSTRUCTION_LAYOUTS_KPL, TaskData, TaskDistributionInfo, TaskInstructionLayouts, TaskNodeBase, TaskNodeConfig, TaskState, TaskStateKPL, TaskStateOptions, TaskSubmissionState, decodeZstd, encodeData, executeTasks, getAlloc, getAverageSlotTime, getCurrentSlot, getMyTaskStakeInfo, getMyTaskSubmissionRoundInfo, getRpcUrlWrapper, getTaskDistributionInfo, getTaskState, getTaskStateKPL, getTaskSubmissionInfo, initialPropagation, loadTasks, makeChunks, padStringWithSpaces, runPeriodic, runTimers, sleep, updateRewardsQueue };