@_koii/task-node 1.12.37

package/README.md

@@ -0,0 +1,49 @@
+# K2-Node:
+****
+## TL;DR
+# How to to run a node:
+
+1. Clone the repo repo : https://gitlab.com/koii-network/task-node
+2. do `npm install`
+3. do `npm run build:watch`
+4. on another terminal do `npm start ` this will start a **K2** node with attention game running.
+****
+## Full Guide
+## How Attention game works
+
+The node collects PoRTs for a whole epoch and generates a distribution list and add its to the attention account of the node using a uploader contract which breaks the data into small chunks and then combines it into a big data chunk in the program. The node will also expose the port list on an endpoint 
+On the next Epoch the node will do voting by getting all the attention accounts and pings all the registered nodes and get all the posts the generates distribution list after verifying that teh list is correct or not.
+
+
+# How to run  
+## Deploy Uploader Program 
+First airdrop 1000 tokens to your default wallet.
+after that clone https://github.com/koii-network/k2-contracts this repo and deployed the uploader program by running `init.sh` file after installing dependencies using `npm install`. This will deploy the uploader program used by attention game.
+
+## Run Node:
+### Prerequisites: 
+1. You will need to create a task staking account in order to run tasks other than the attention contract.
+    1.1 You can create a staking wallet by using the staking cli `npm run stake`
+
+### Running a Node:
+To run a node run `npm run build:watch` and ona different terminal run `npm start` to start the node.
+
+### Working of stakes 
+
+The attention program needs 2 accounts one is the attentions staking account and data program account. Which executable makes from the mainAccount according to the stake amount set in the env variable (no preconfiguration needed)
+
+In-order to run tasks other than attention program, you need to make a staking account `npm run stake`, allocate some funds in that wallet and then the task you want to execute stake some tokens to that task id using the cli. After that you will be able to execute task and make rewards out of that.
+
+
+#### Note: Attention task is different than the other tasks
+****
+# Trouble Shooting:
+ ## Insufficient Balance:
+ You might get this error if you have restated the network and you are trying to run deploy uploader program or running attention game. In this cases try `solana airdrop <AMOUNT> <ADDRESS> `.
+
+ ## Program doesn't exists
+ You will get this error if you have restarted the network (Wiped out the data) and you are trying to run run attention game attention game, deleting `namespace/Attention22222222222222222222222222222222222/attentionAccountWallet.json` and `namespace/Attention22222222222222222222222222222222222/uploadAccountWallet.json` will fix the issue.
+
+
+
+****

package/dist/bincode_js.d.ts

@@ -0,0 +1,225 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+* @param {any} val
+* @returns {any}
+*/
+export function bincode_js_deserialize(val: any): any;
+/**
+* @param {any} val
+* @returns {any}
+*/
+export function borsh_bpf_js_deserialize(val: any): any;
+/**
+* Initialize Javascript logging and panic handler
+*/
+export function solana_program_init(): void;
+/**
+* A hash; the 32-byte output of a hashing algorithm.
+*
+* This struct is used most often in `solana-sdk` and related crates to contain
+* a [SHA-256] hash, but may instead contain a [blake3] hash, as created by the
+* [`blake3`] module (and used in [`Message::hash`]).
+*
+* [SHA-256]: https://en.wikipedia.org/wiki/SHA-2
+* [blake3]: https://github.com/BLAKE3-team/BLAKE3
+* [`blake3`]: crate::blake3
+* [`Message::hash`]: crate::message::Message::hash
+*/
+export class Hash {
+  free(): void;
+/**
+* Create a new Hash object
+*
+* * `value` - optional hash as a base58 encoded string, `Uint8Array`, `[number]`
+* @param {any} value
+*/
+  constructor(value: any);
+/**
+* Return the base58 string representation of the hash
+* @returns {string}
+*/
+  toString(): string;
+/**
+* Checks if two `Hash`s are equal
+* @param {Hash} other
+* @returns {boolean}
+*/
+  equals(other: Hash): boolean;
+/**
+* Return the `Uint8Array` representation of the hash
+* @returns {Uint8Array}
+*/
+  toBytes(): Uint8Array;
+}
+/**
+* A directive for a single invocation of a Solana program.
+*
+* An instruction specifies which program it is calling, which accounts it may
+* read or modify, and additional data that serves as input to the program. One
+* or more instructions are included in transactions submitted by Solana
+* clients. Instructions are also used to describe [cross-program
+* invocations][cpi].
+*
+* [cpi]: https://docs.solana.com/developing/programming-model/calling-between-programs
+*
+* During execution, a program will receive a list of account data as one of
+* its arguments, in the same order as specified during `Instruction`
+* construction.
+*
+* While Solana is agnostic to the format of the instruction data, it has
+* built-in support for serialization via [`borsh`] and [`bincode`].
+*
+* [`borsh`]: https://docs.rs/borsh/latest/borsh/
+* [`bincode`]: https://docs.rs/bincode/latest/bincode/
+*
+* # Specifying account metadata
+*
+* When constructing an [`Instruction`], a list of all accounts that may be
+* read or written during the execution of that instruction must be supplied as
+* [`AccountMeta`] values.
+*
+* Any account whose data may be mutated by the program during execution must
+* be specified as writable. During execution, writing to an account that was
+* not specified as writable will cause the transaction to fail. Writing to an
+* account that is not owned by the program will cause the transaction to fail.
+*
+* Any account whose lamport balance may be mutated by the program during
+* execution must be specified as writable. During execution, mutating the
+* lamports of an account that was not specified as writable will cause the
+* transaction to fail. While _subtracting_ lamports from an account not owned
+* by the program will cause the transaction to fail, _adding_ lamports to any
+* account is allowed, as long is it is mutable.
+*
+* Accounts that are not read or written by the program may still be specified
+* in an `Instruction`'s account list. These will affect scheduling of program
+* execution by the runtime, but will otherwise be ignored.
+*
+* When building a transaction, the Solana runtime coalesces all accounts used
+* by all instructions in that transaction, along with accounts and permissions
+* required by the runtime, into a single account list. Some accounts and
+* account permissions required by the runtime to process a transaction are
+* _not_ required to be included in an `Instruction`s account list. These
+* include:
+*
+* - The program ID — it is a separate field of `Instruction`
+* - The transaction's fee-paying account — it is added during [`Message`]
+*   construction. A program may still require the fee payer as part of the
+*   account list if it directly references it.
+*
+* [`Message`]: crate::message::Message
+*
+* Programs may require signatures from some accounts, in which case they
+* should be specified as signers during `Instruction` construction. The
+* program must still validate during execution that the account is a signer.
+*/
+export class Instruction {
+  free(): void;
+}
+/**
+*/
+export class Instructions {
+  free(): void;
+/**
+*/
+  constructor();
+/**
+* @param {Instruction} instruction
+*/
+  push(instruction: Instruction): void;
+}
+/**
+* A Solana transaction message (legacy).
+*
+* See the [`message`] module documentation for further description.
+*
+* [`message`]: crate::message
+*
+* Some constructors accept an optional `payer`, the account responsible for
+* paying the cost of executing a transaction. In most cases, callers should
+* specify the payer explicitly in these constructors. In some cases though,
+* the caller is not _required_ to specify the payer, but is still allowed to:
+* in the `Message` structure, the first account is always the fee-payer, so if
+* the caller has knowledge that the first account of the constructed
+* transaction's `Message` is both a signer and the expected fee-payer, then
+* redundantly specifying the fee-payer is not strictly required.
+*/
+export class Message {
+  free(): void;
+/**
+* The id of a recent ledger entry.
+*/
+  recent_blockhash: Hash;
+}
+/**
+* The address of a [Solana account][acc].
+*
+* Some account addresses are [ed25519] public keys, with corresponding secret
+* keys that are managed off-chain. Often, though, account addresses do not
+* have corresponding secret keys — as with [_program derived
+* addresses_][pdas] — or the secret key is not relevant to the operation
+* of a program, and may have even been disposed of. As running Solana programs
+* can not safely create or manage secret keys, the full [`Keypair`] is not
+* defined in `solana-program` but in `solana-sdk`.
+*
+* [acc]: https://docs.solana.com/developing/programming-model/accounts
+* [ed25519]: https://ed25519.cr.yp.to/
+* [pdas]: https://docs.solana.com/developing/programming-model/calling-between-programs#program-derived-addresses
+* [`Keypair`]: https://docs.rs/solana-sdk/latest/solana_sdk/signer/keypair/struct.Keypair.html
+*/
+export class Pubkey {
+  free(): void;
+/**
+* Create a new Pubkey object
+*
+* * `value` - optional public key as a base58 encoded string, `Uint8Array`, `[number]`
+* @param {any} value
+*/
+  constructor(value: any);
+/**
+* Return the base58 string representation of the public key
+* @returns {string}
+*/
+  toString(): string;
+/**
+* Check if a `Pubkey` is on the ed25519 curve.
+* @returns {boolean}
+*/
+  isOnCurve(): boolean;
+/**
+* Checks if two `Pubkey`s are equal
+* @param {Pubkey} other
+* @returns {boolean}
+*/
+  equals(other: Pubkey): boolean;
+/**
+* Return the `Uint8Array` representation of the public key
+* @returns {Uint8Array}
+*/
+  toBytes(): Uint8Array;
+/**
+* Derive a Pubkey from another Pubkey, string seed, and a program id
+* @param {Pubkey} base
+* @param {string} seed
+* @param {Pubkey} owner
+* @returns {Pubkey}
+*/
+  static createWithSeed(base: Pubkey, seed: string, owner: Pubkey): Pubkey;
+/**
+* Derive a program address from seeds and a program id
+* @param {any[]} seeds
+* @param {Pubkey} program_id
+* @returns {Pubkey}
+*/
+  static createProgramAddress(seeds: any[], program_id: Pubkey): Pubkey;
+/**
+* Find a valid program address
+*
+* Returns:
+* * `[PubKey, number]` - the program address and bump seed
+* @param {any[]} seeds
+* @param {Pubkey} program_id
+* @returns {any}
+*/
+  static findProgramAddress(seeds: any[], program_id: Pubkey): any;
+}