Jobs Program

The Jobs Program provides methods to interact with jobs, runs, and markets on the Nosana Network.

Fetching Accounts

Get Single Job

async get(address: Address, checkRun?: boolean): Promise<Job>

Fetch a job account. If checkRun is true (default), automatically checks for associated run accounts to determine if a queued job is actually running.

import { address, Job } from '@nosana/kit';
const job: Job = await client.jobs.get(address('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

async run(address: Address): Promise<Run>

Fetch a run account by address.

import { address, Run } from '@nosana/kit';
const run: Run = await client.jobs.run(address('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

async market(address: Address): Promise<Market>

Fetch a market account by address.

import { address, Market } from '@nosana/kit';
const market: Market = await client.jobs.market(address('market-address'));
console.log(market.queueType); // MarketQueueType enum
console.log(market.jobPrice); // Market job price

Get Multiple Jobs

async multiple(addresses: Address[], checkRuns?: boolean): Promise<Job[]>

Batch fetch multiple jobs by addresses.

import { address, Job } from '@nosana/kit';
const jobs: Job[] = await client.jobs.multiple([address('job-address-1'), address('job-address-2'), address('job-address-3')], true);

Querying with Filters

Query All Jobs

async all(filters?: {
  state?: JobState,
  market?: Address,
  node?: Address,
  project?: Address
}, checkRuns?: boolean): Promise<Job[]>

Fetch all jobs matching filter criteria using getProgramAccounts.

import { JobState, address, Job } from '@nosana/kit';

// Get all running jobs in a market
const runningJobs: Job[] = await client.jobs.all({
  state: JobState.RUNNING,
  market: address('market-address'),
});

// Get all jobs for a project
const projectJobs: Job[] = await client.jobs.all({
  project: address('project-address'),
});

Query All Runs

async runs(filters?: {
  job?: Address,
  node?: Address
}): Promise<Run[]>

Fetch runs with optional filtering.

import { address, Run } from '@nosana/kit';

// Get all runs for a specific job
const jobRuns: Run[] = await client.jobs.runs({ job: address('job-address') });

// Get all runs on a specific node
const nodeRuns: Run[] = await client.jobs.runs({ node: address('node-address') });

Query All Markets

async markets(): Promise<Market[]>

Fetch all market accounts.

import { Market } from '@nosana/kit';
const markets: Market[] = await client.jobs.markets();

Creating Jobs

Post a Job

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.

import { address } from '@nosana/kit';
import type { Instruction } from '@solana/kit';

// Set wallet first
client.wallet = yourWallet;

// Create job instruction
const instruction: Instruction = await client.jobs.post({
  market: address('market-address'),
  timeout: 3600, // Timeout in seconds
  ipfsHash: 'QmXxx...', // IPFS CID of job definition
  node: address('node-address'), // Optional: target specific node
});

// Submit the instruction
await client.solana.buildSignAndSend(instruction);

Real-time Monitoring

The SDK provides monitoring methods using async iterators for real-time account updates via WebSocket. See the Examples section for detailed monitoring examples.

Account Types

Job

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

type Run = {
  address: Address;
  job: Address; // Associated job
  node: Address; // Node executing the job
  time: number; // Unix timestamp
};

Market

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,
}