@nosana/kit 0.1.6 → 1.0.2

package/README.md

@@ -1,16 +1,6 @@
 # Nosana Kit
 
-A TypeScript SDK for interacting with the Nosana Network on Solana. This kit provides a comprehensive set of tools for managing jobs, markets, runs, and other Nosana protocol operations.
-
-## Features
-
-- 🚀 **Full TypeScript Support** - Complete type safety and IntelliSense
-- 🔗 **Solana Integration** - Built on top of the new Solana Kit client
-- 📦 **Jobs Management** - Create, manage, and monitor nosana jobs
-- 🌐 **IPFS** - Seamless IPFS hash handling and conversions, uploading and retrieving
-- ⚙️ **Configurable Networks** - Support for mainnet and devnet
-- 🧪 **Comprehensive Testing** - Well-tested with high coverage
-- 📝 **Rich Logging** - Built-in logging with configurable levels
+TypeScript SDK for interacting with the Nosana Network on Solana. Provides comprehensive tools for managing jobs, markets, runs, and protocol operations on the Nosana decentralized compute network.
 
 ## Installation
 
@@ -18,15 +8,20 @@ A TypeScript SDK for interacting with the Nosana Network on Solana. This kit pro
 npm install @nosana/kit
 ```
 
+### Requirements
+
+- Node.js >= 20.18.0
+- TypeScript >= 5.3.0 (for development)
+
 ## Quick Start
 
 ```typescript
 import { NosanaClient, NosanaNetwork } from '@nosana/kit';
 
-// Initialize client with default mainnet configuration
+// Initialize with mainnet defaults
 const client = new NosanaClient();
 
-// Or specify network and custom configuration
+// Or specify network and configuration
 const client = new NosanaClient(NosanaNetwork.DEVNET, {
   solana: {
     rpcEndpoint: 'https://your-custom-rpc.com',
@@ -34,27 +29,41 @@ const client = new NosanaClient(NosanaNetwork.DEVNET, {
   }
 });
 
-// Fetch a job
-const job = await client.jobs.get('your-job-address');
+// Fetch a job by address
+const job = await client.jobs.get('job-address');
 console.log('Job state:', job.state);
 
-// Get all completed jobs for a market
-const jobs = await client.jobs.all({ 
+// Query jobs with filters
+const completedJobs = await client.jobs.all({ 
   market: 'market-address',
-  state: 2 // completed jobs
+  state: 2  // JobState.COMPLETED
 });
 ```
 
+## Architecture
+
+The SDK is organized into clear, purpose-driven modules:
+
+- **`services/`** - Utility services (SolanaService for RPC/transactions, NosService for NOS token operations)
+- **`programs/`** - On-chain program interfaces (JobsProgram, StakeProgram)
+- **`ipfs/`** - IPFS integration
+- **`config/`** - Network configurations
+- **`utils/`** - Helper utilities
+
+This structure makes it clear that:
+- **Services** = Helper services and utilities for common operations
+- **Programs** = Interfaces to on-chain Solana programs
+
 ## Configuration
 
-### Network Configuration
+### Networks
 
 The SDK supports two networks:
 
-- `NosanaNetwork.MAINNET` - Production network
-- `NosanaNetwork.DEVNET` - Development network
+- **`NosanaNetwork.MAINNET`** - Production network (mainnet-beta)
+- **`NosanaNetwork.DEVNET`** - Development network (devnet)
 
-### Custom Configuration
+### Configuration Options
 
 ```typescript
 import { NosanaClient, NosanaNetwork, NosanaLogLevel } from '@nosana/kit';
@@ -62,80 +71,634 @@ import { NosanaClient, NosanaNetwork, NosanaLogLevel } from '@nosana/kit';
 const client = new NosanaClient(NosanaNetwork.MAINNET, {
   solana: {
     cluster: 'mainnet-beta',
-    rpcEndpoint: 'https://your-rpc-endpoint.com',
+    rpcEndpoint: 'https://api.mainnet-beta.solana.com',
     commitment: 'confirmed'
   },
   ipfs: {
-    api: 'https://your-ipfs-api.com',
-    jwt: 'your-jwt-token',
-    gateway: 'https://your-ipfs-gateway.com'
+    api: 'https://api.pinata.cloud',
+    jwt: 'your-pinata-jwt-token',
+    gateway: 'https://gateway.pinata.cloud/ipfs/'
   },
-  logLevel: NosanaLogLevel.DEBUG
+  logLevel: NosanaLogLevel.DEBUG,
+  wallet: keypairArray  // Optional: Set wallet during initialization
 });
 ```
 
-## API Reference
+## Core Components
 
 ### NosanaClient
 
-The main client class that provides access to all Nosana protocol features.
+Main entry point for SDK interactions.
+
+**Properties:**
+- `config: ClientConfig` - Active configuration
+- `jobs: JobsProgram` - Jobs program interface
+- `stake: StakeProgram` - Staking program interface
+- `solana: SolanaService` - General Solana utilities (RPC, transactions, PDAs)
+- `nos: NosService` - NOS token operations service
+- `ipfs: IPFS` - IPFS operations and utilities
+- `logger: Logger` - Logging instance
+- `wallet?: KeyPairSigner` - Active wallet (if set)
+
+**Methods:**
+- `setWallet(wallet: WalletConfig): Promise<KeyPairSigner>` - Set the signing wallet
+
+### Wallet Configuration
+
+The SDK supports multiple wallet input formats:
 
 ```typescript
-class NosanaClient {
-  constructor(network?: NosanaNetwork, customConfig?: PartialClientConfig)
-  
-  readonly config: ClientConfig
-  readonly jobs: JobsProgram
-  readonly solana: SolanaUtils
-  readonly logger: Logger
-}
+// Number array (raw keypair)
+await client.setWallet([1, 2, 3, ..., 64]);
+
+// JSON string
+await client.setWallet(JSON.stringify(keypairArray));
+
+// Base58 string
+await client.setWallet('base58EncodedPrivateKey');
+
+// File path
+await client.setWallet('/path/to/keypair.json');
+
+// Environment variable (JSON array or base58)
+process.env.SOLANA_PRIVATE_KEY = JSON.stringify(keypairArray);
+await client.setWallet('env:SOLANA_PRIVATE_KEY');
+
+// Browser wallet adapter
+await client.setWallet(browserWalletAdapter);
+
+// Existing KeyPairSigner (passthrough)
+await client.setWallet(existingKeypairSigner);
 ```
 
-### JobsProgram
+## Jobs Program API
 
-Manages job-related operations on the Nosana network.
+### Fetching Accounts
 
-#### Methods
+#### Get Single Job
 
 ```typescript
-// Fetch a single job
 async get(address: Address, checkRun?: boolean): Promise<Job>
+```
 
-// Fetch a run
+Fetch a job account. If `checkRun` is true (default), automatically checks for associated run accounts to determine if a queued job is actually running.
+
+```typescript
+const job = await client.jobs.get('job-address');
+console.log(job.state);      // JobState enum
+console.log(job.price);      // Job price in smallest unit
+console.log(job.ipfsJob);    // IPFS CID of job definition
+console.log(job.timeStart);  // Start timestamp (if running)
+```
+
+#### Get Single Run
+
+```typescript
 async run(address: Address): Promise<Run>
+```
+
+Fetch a run account by address.
+
+```typescript
+const run = await client.jobs.run('run-address');
+console.log(run.job);   // Associated job address
+console.log(run.node);  // Node executing the run
+console.log(run.time);  // Run start time
+```
+
+#### Get Single Market
 
-// Fetch a market
+```typescript
 async market(address: Address): Promise<Market>
+```
 
-// Fetch multiple jobs
+Fetch a market account by address.
+
+```typescript
+const market = await client.jobs.market('market-address');
+console.log(market.queueType);  // MarketQueueType enum
+console.log(market.jobPrice);   // Market job price
+```
+
+#### Get Multiple Jobs
+
+```typescript
 async multiple(addresses: Address[], checkRuns?: boolean): Promise<Job[]>
+```
+
+Batch fetch multiple jobs by addresses.
+
+```typescript
+const jobs = await client.jobs.multiple([
+  'job-address-1',
+  'job-address-2',
+  'job-address-3'
+], true);
+```
+
+### Querying with Filters
 
-// Fetch all jobs with optional filters
+#### Query All Jobs
+
+```typescript
 async all(filters?: {
-  state?: number,
+  state?: JobState,
   market?: Address,
   node?: Address,
-  project?: Address,
+  project?: Address
 }, checkRuns?: boolean): Promise<Job[]>
+```
+
+Fetch all jobs matching filter criteria using getProgramAccounts.
+
+```typescript
+import { JobState } from '@nosana/kit';
 
-// Get runs with optional filters
+// Get all running jobs in a market
+const runningJobs = await client.jobs.all({
+  state: JobState.RUNNING,
+  market: 'market-address'
+});
+
+// Get all jobs for a project
+const projectJobs = await client.jobs.all({
+  project: 'project-address'
+});
+```
+
+#### Query All Runs
+
+```typescript
 async runs(filters?: {
   job?: Address,
-  node?: Address,
+  node?: Address
 }): Promise<Run[]>
+```
 
-// Get markets with optional filters
+Fetch runs with optional filtering.
+
+```typescript
+// Get all runs for a specific job
+const jobRuns = await client.jobs.runs({ job: 'job-address' });
+
+// Get all runs on a specific node
+const nodeRuns = await client.jobs.runs({ node: 'node-address' });
+```
+
+#### Query All Markets
+
+```typescript
 async markets(filters?: {
-  project?: Address,
+  project?: Address
 }): Promise<Market[]>
 ```
 
-#### Account Types
-...
+Fetch markets with optional project filtering.
+
+```typescript
+const projectMarkets = await client.jobs.markets({ 
+  project: 'project-address' 
+});
+```
+
+### Creating Jobs
+
+#### Post a Job
+
+```typescript
+async post(params: {
+  market: Address,
+  timeout: number | bigint,
+  ipfsHash: string,
+  node?: Address
+}): Promise<Instruction>
+```
+
+Create a list instruction for posting a job to a market. Returns an instruction that must be submitted to the network.
+
+```typescript
+// Set wallet first
+await client.setWallet(yourKeypair);
+
+// Create job instruction
+const instruction = await client.jobs.post({
+  market: 'market-address',
+  timeout: 3600,           // Timeout in seconds
+  ipfsHash: 'QmXxx...',    // IPFS CID of job definition
+  node: 'node-address'     // Optional: target specific node
+});
+
+// Submit the instruction
+await client.solana.send(instruction);
+```
+
+### Real-time Monitoring
+
+#### Monitor Account Updates
+
+```typescript
+async monitor(options?: {
+  onJobAccount?: (job: Job) => void | Promise<void>,
+  onMarketAccount?: (market: Market) => void | Promise<void>,
+  onRunAccount?: (run: Run) => void | Promise<void>,
+  onError?: (error: Error, accountType?: string) => void | Promise<void>
+}): Promise<() => void>
+```
+
+Subscribe to real-time account updates via WebSocket. Includes automatic reconnection on failure.
+
+```typescript
+// Start monitoring
+const stopMonitoring = await client.jobs.monitor({
+  onJobAccount: async (job) => {
+    console.log('Job update:', job.address, job.state);
+    
+    // Process updates - save to database, trigger workflows, etc.
+    if (job.state === JobState.COMPLETED) {
+      await processCompletedJob(job);
+    }
+  },
+  onRunAccount: async (run) => {
+    console.log('Run started:', run.job, 'on node', run.node);
+  },
+  onError: (error) => {
+    console.error('Monitor error:', error);
+  }
+});
+
+// Stop monitoring when done
+stopMonitoring();
+```
+
+The monitor handles WebSocket reconnection automatically and continues processing updates until explicitly stopped.
+
+## Account Types
+
+### Job
+
+```typescript
+type Job = {
+  address: Address;
+  state: JobState;           // QUEUED | RUNNING | COMPLETED | STOPPED
+  ipfsJob: string | null;    // IPFS CID of job definition
+  ipfsResult: string | null; // IPFS CID of job result
+  market: Address;
+  node: Address;
+  payer: Address;
+  project: Address;
+  price: number;
+  timeStart: number;         // Unix timestamp
+  timeEnd: number;           // Unix timestamp
+  timeout: number;           // Seconds
+};
+
+enum JobState {
+  QUEUED = 0,
+  RUNNING = 1,
+  COMPLETED = 2,
+  STOPPED = 3
+}
+```
+
+### Run
+
+```typescript
+type Run = {
+  address: Address;
+  job: Address;      // Associated job
+  node: Address;     // Node executing the job
+  time: number;      // Unix timestamp
+};
+```
+
+### Market
+
+```typescript
+type Market = {
+  address: Address;
+  queueType: MarketQueueType;  // JOB_QUEUE | NODE_QUEUE
+  jobPrice: number;
+  nodeStakeMinimum: number;
+  jobTimeout: number;
+  jobType: number;
+  project: Address;
+  // ... additional fields
+};
+
+enum MarketQueueType {
+  JOB_QUEUE = 0,
+  NODE_QUEUE = 1
+}
+```
+
+## Solana Service
+
+General Solana utility service for low-level RPC operations, transactions, and PDA derivations.
+
+### Methods
+
+```typescript
+// Send transaction (instruction, array, or transaction object)
+send(tx: IInstruction | IInstruction[] | Transaction): Promise<Signature>
+
+// Get account balance
+getBalance(address: Address | string): Promise<bigint>
+
+// Get latest blockhash
+getLatestBlockhash(): Promise<{ blockhash: string, lastValidBlockHeight: number }>
+
+// Derive program derived address
+pda(seeds: Array<Address | string>, programId: Address): Promise<Address>
+```
+
+### Examples
+
+```typescript
+// Send a single instruction
+const signature = await client.solana.send(instruction);
+
+// Send multiple instructions atomically
+const signature = await client.solana.send([ix1, ix2, ix3]);
+
+// Check account balance
+const balance = await client.solana.getBalance('address');
+console.log(`Balance: ${balance} lamports`);
+
+// Derive PDA
+const pda = await client.solana.pda(
+  ['seed1', 'seed2'],
+  programAddress
+);
+```
+
+## IPFS Utilities
+
+### Static Methods
+
+```typescript
+// Convert Solana hash to IPFS CID
+IPFS.solHashToIpfsHash(hash: Uint8Array | number[]): string | null
+
+// Convert IPFS hash to byte array
+IPFS.IpfsHashToByteArray(ipfsHash: string): Uint8Array
+```
+
+### Instance Methods
+
+```typescript
+// Pin JSON data to Pinata
+pin(data: object, name?: string): Promise<string>
+
+// Pin file to Pinata
+pinFile(filePath: string, name?: string): Promise<string>
+
+// Pin buffer/stream to Pinata
+pinFileFromBuffer(source: Buffer | Readable, filename: string): Promise<string>
+
+// Retrieve data from IPFS
+retrieve(hash: string | Uint8Array, options?: AxiosRequestConfig): Promise<any>
+```
+
+### Examples
+
+```typescript
+// Convert between Solana and IPFS hash formats
+const ipfsCid = IPFS.solHashToIpfsHash(solanaHashBytes);
+const solanaHash = IPFS.IpfsHashToByteArray(ipfsCid);
+
+// Pin job definition
+const cid = await client.ipfs.pin({
+  version: 1,
+  type: 'docker',
+  image: 'ubuntu:latest',
+  command: ['echo', 'hello']
+}, 'job-definition');
+
+// Retrieve job results
+const results = await client.ipfs.retrieve(job.ipfsResult);
+```
+
+## Staking Program
+
+The StakeProgram provides methods to interact with Nosana staking accounts on-chain.
+
+### Get a Single Stake Account
+
+Fetch a stake account by its address:
+
+```typescript
+const stake = await client.stake.get('stake-account-address');
+
+console.log('Stake Account:', stake.address);
+console.log('Authority:', stake.authority);
+console.log('Staked Amount:', stake.amount);
+console.log('xNOS Tokens:', stake.xnos);
+console.log('Duration:', stake.duration);
+console.log('Time to Unstake:', stake.timeUnstake);
+console.log('Vault:', stake.vault);
+```
+
+### Get Multiple Stake Accounts
+
+Fetch multiple stake accounts by their addresses:
+
+```typescript
+const addresses = ['address1', 'address2', 'address3'];
+const stakes = await client.stake.multiple(addresses);
+
+stakes.forEach(stake => {
+  console.log(`${stake.address}: ${stake.amount} staked`);
+});
+```
+
+### Get All Stake Accounts
+
+Fetch all stake accounts in the program:
+
+```typescript
+// Get all stakes
+const allStakes = await client.stake.all();
+console.log(`Found ${allStakes.length} stake accounts`);
+```
+
+### Type Definitions
+
+```typescript
+interface Stake {
+  address: Address;
+  amount: number;
+  authority: Address;
+  duration: number;
+  timeUnstake: number;
+  vault: Address;
+  vaultBump: number;
+  xnos: number;
+}
+```
+
+### Use Cases
+
+- **Portfolio Tracking**: Monitor your staked NOS tokens
+- **Analytics**: Analyze staking patterns and distributions
+- **Governance**: Check voting power based on staked amounts
+- **Rewards Calculation**: Calculate rewards based on stake duration and amount
+
+### Example: Analyze Staking Distribution
+
+```typescript
+const allStakes = await client.stake.all();
+
+// Calculate total staked
+const totalStaked = allStakes.reduce((sum, stake) => sum + stake.amount, 0);
+
+// Find average stake
+const averageStake = totalStaked / allStakes.length;
+
+// Find largest stake
+const largestStake = allStakes.reduce((max, stake) => 
+  Math.max(max, stake.amount), 0
+);
+
+console.log('Staking Statistics:');
+console.log(`Total Staked: ${totalStaked.toLocaleString()} NOS`);
+console.log(`Average Stake: ${averageStake.toLocaleString()} NOS`);
+console.log(`Largest Stake: ${largestStake.toLocaleString()} NOS`);
+console.log(`Number of Stakers: ${allStakes.length}`);
+```
+
+## NOS Token Service
+
+The NosService provides methods to interact with NOS token accounts on Solana.
+
+### Get All Token Holders
+
+Fetch all accounts holding NOS tokens using a single RPC call:
+
+```typescript
+// Get all holders (excludes zero balance accounts by default)
+const holders = await client.nos.getAllTokenHolders();
+
+console.log(`Found ${holders.length} NOS token holders`);
+
+holders.forEach(holder => {
+  console.log(`${holder.owner}: ${holder.uiAmount} NOS`);
+});
+
+// Include accounts with zero balance
+const allAccounts = await client.nos.getAllTokenHolders({ includeZeroBalance: true });
+console.log(`Total accounts: ${allAccounts.length}`);
+
+// Exclude PDA accounts (smart contract-owned token accounts)
+const userAccounts = await client.nos.getAllTokenHolders({ excludePdaAccounts: true });
+console.log(`User-owned accounts: ${userAccounts.length}`);
+
+// Combine filters
+const activeUsers = await client.nos.getAllTokenHolders({ 
+  includeZeroBalance: false,
+  excludePdaAccounts: true 
+});
+console.log(`Active user accounts: ${activeUsers.length}`);
+```
+
+### Get Token Account for Address
+
+Retrieve the NOS token account for a specific owner:
+
+```typescript
+const account = await client.nos.getTokenAccountForAddress('owner-address');
+
+if (account) {
+  console.log('Token Account:', account.pubkey);
+  console.log('Owner:', account.owner);
+  console.log('Balance:', account.uiAmount, 'NOS');
+  console.log('Raw Amount:', account.amount.toString());
+  console.log('Decimals:', account.decimals);
+} else {
+  console.log('No NOS token account found');
+}
+```
+
+### Get Balance
+
+Convenience method to get just the NOS balance for an address:
+
+```typescript
+const balance = await client.nos.getBalance('owner-address');
+console.log(`Balance: ${balance} NOS`);
+// Returns 0 if no token account exists
+```
+
+### Type Definitions
+
+```typescript
+interface TokenAccount {
+  pubkey: Address;
+  owner: Address;
+  mint: Address;
+  amount: bigint;
+  decimals: number;
+}
+
+interface TokenAccountWithBalance extends TokenAccount {
+  uiAmount: number;  // Balance with decimals applied
+}
+```
+
+### Use Cases
+
+- **Analytics**: Analyze token distribution and holder statistics
+- **Airdrops**: Get list of all token holders for campaigns
+- **Balance Checks**: Check NOS balances for specific addresses
+- **Leaderboards**: Create holder rankings sorted by balance
+- **Monitoring**: Track large holder movements
+
+### Example: Filter Large Holders
+
+```typescript
+const holders = await client.nos.getAllTokenHolders();
+
+// Find holders with at least 1000 NOS
+const largeHolders = holders.filter(h => h.uiAmount >= 1000);
+
+// Sort by balance descending
+largeHolders.sort((a, b) => b.uiAmount - a.uiAmount);
+
+// Display top 10
+largeHolders.slice(0, 10).forEach((holder, i) => {
+  console.log(`${i + 1}. ${holder.owner}: ${holder.uiAmount.toLocaleString()} NOS`);
+});
+```
 
 ## Error Handling
 
-The SDK provides structured error handling with specific error codes:
+The SDK provides structured error handling with specific error codes.
+
+### NosanaError
+
+```typescript
+class NosanaError extends Error {
+  code: string;
+  details?: any;
+}
+```
+
+### Error Codes
+
+```typescript
+enum ErrorCodes {
+  INVALID_NETWORK = 'INVALID_NETWORK',
+  INVALID_CONFIG = 'INVALID_CONFIG',
+  RPC_ERROR = 'RPC_ERROR',
+  TRANSACTION_ERROR = 'TRANSACTION_ERROR',
+  PROGRAM_ERROR = 'PROGRAM_ERROR',
+  VALIDATION_ERROR = 'VALIDATION_ERROR',
+  NO_WALLET = 'NO_WALLET',
+  FILE_ERROR = 'FILE_ERROR',
+  WALLET_CONVERSION_ERROR = 'WALLET_CONVERSION_ERROR'
+}
+```
+
+### Examples
 
 ```typescript
 import { NosanaError, ErrorCodes } from '@nosana/kit';
@@ -146,14 +709,121 @@ try {
   if (error instanceof NosanaError) {
     switch (error.code) {
       case ErrorCodes.RPC_ERROR:
-        console.log('RPC connection failed');
+        console.error('RPC connection failed:', error.message);
         break;
-      case ErrorCodes.INVALID_CONFIG:
-        console.log('Invalid configuration');
+      case ErrorCodes.NO_WALLET:
+        console.error('Wallet not configured');
+        await client.setWallet(keypair);
+        break;
+      case ErrorCodes.TRANSACTION_ERROR:
+        console.error('Transaction failed:', error.details);
         break;
       default:
-        console.log('Unknown error:', error.message);
+        console.error('Unknown error:', error.message);
     }
+  } else {
+    throw error;  // Re-throw non-Nosana errors
   }
 }
-```
+```
+
+## Logging
+
+The SDK includes a built-in singleton logger with configurable levels.
+
+### Log Levels
+
+```typescript
+enum NosanaLogLevel {
+  DEBUG = 'debug',
+  INFO = 'info',
+  WARN = 'warn',
+  ERROR = 'error',
+  NONE = 'none'
+}
+```
+
+### Configuration
+
+```typescript
+import { NosanaClient, NosanaLogLevel } from '@nosana/kit';
+
+// Set log level during initialization
+const client = new NosanaClient(NosanaNetwork.MAINNET, {
+  logLevel: NosanaLogLevel.DEBUG
+});
+
+// Access logger directly
+client.logger.info('Information message');
+client.logger.error('Error message');
+client.logger.debug('Debug details');
+```
+
+## Testing
+
+The SDK includes comprehensive test coverage.
+
+```bash
+# Run tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Generate coverage report
+npm run test:coverage
+```
+
+## Development
+
+```bash
+# Build the SDK
+npm run build
+
+# Lint code
+npm run lint
+
+# Format code
+npm run format
+
+# Generate Solana program clients
+npm run generate-clients
+```
+
+## TypeScript Support
+
+The SDK is written in TypeScript and provides complete type definitions. All types are exported for use in your applications:
+
+```typescript
+import type { 
+  Job, 
+  Run, 
+  Market, 
+  JobState,
+  MarketQueueType,
+  ClientConfig,
+  NosanaClient,
+  KeyPairSigner,
+  Address
+} from '@nosana/kit';
+```
+
+## Dependencies
+
+Core dependencies:
+- `gill` ^0.9.0 - Solana web3 library
+- `@solana-program/token` ^0.5.1 - Token program utilities
+- `axios` ^1.6.0 - HTTP client
+- `bs58` ^6.0.0 - Base58 encoding
+- `form-data` ^4.0.0 - Multipart form data
+
+## License
+
+MIT
+
+## Links
+
+- [Nosana Documentation](https://docs.nosana.com)
+- [Nosana Network](https://nosana.com)
+- [GitHub Repository](https://github.com/nosana-ci/nosana-kit)
+- [NPM Package](https://www.npmjs.com/package/@nosana/kit)