Jobs Examples

Create and Post a Job

To post a job, you need to create a job definition that describes what you want to run. The job definition is a JSON object that specifies container images, commands, and resource requirements.

import { 
function createNosanaClient(network: NosanaNetwork | undefined, customConfig: PartialClientConfig & {
    connect: ConnectFactoryConfig & {
        clientSecret: string;
    };
}): NosanaClient & {
    connect: ServerConnect;
} (+3 overloads)createNosanaClient, 
type NosanaNetwork = "mainnet" | "devnet" | "localnet"
const NosanaNetwork: {
    readonly MAINNET: "mainnet";
    readonly DEVNET: "devnet";
    readonly LOCALNET: "localnet";
}NosanaNetwork } from '@nosana/kit';
import type { interface Instruction<TProgramAddress extends string = string, TAccounts extends readonly (AccountLookupMeta | AccountMeta)[] = readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[]>
An instruction destined for a given program.
@example```ts
type StakeProgramInstruction = Instruction<'StakeConfig11111111111111111111111111111111'>;
```Instruction } from '@solana/kit';
import { function generateKeyPairSigner(extractable?: boolean): Promise<KeyPairSigner>
Generates a signer capable of signing messages and transactions by generating
a 
{@link 
CryptoKeyPair
}
 and creating a 
{@link 
KeyPairSigner
}
 from it.
@paramextractable Setting this to `true` makes it possible to extract the bytes of the private
key using the [`crypto.subtle.exportKey()`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/exportKey)
API. Defaults to `false`, which prevents the bytes of the private key from being visible to JS.@example```ts
import { generateKeyPairSigner } from '@solana/signers';

const signer = await generateKeyPairSigner();
```@see{@link createSignerFromKeyPair}generateKeyPairSigner } from '@solana/kit';

const const client: NosanaClientclient = function createNosanaClient(network?: NosanaNetwork, customConfig?: PartialClientConfig): NosanaClient (+3 overloads)createNosanaClient(
const NosanaNetwork: {
    readonly MAINNET: "mainnet";
    readonly DEVNET: "devnet";
    readonly LOCALNET: "localnet";
}NosanaNetwork.type DEVNET: "devnet"DEVNET);
const client: NosanaClientclient.NosanaClient.wallet: Wallet | undefined
The wallet. Must be a Wallet (supports both message and transaction signing).
Set this property directly to configure the wallet.
@example```ts
import { createNosanaClient, NosanaNetwork } from '@nosana/kit';

const client = createNosanaClient(NosanaNetwork.MAINNET);
client.wallet = myWallet;
```wallet = await function generateKeyPairSigner(extractable?: boolean): Promise<KeyPairSigner>
Generates a signer capable of signing messages and transactions by generating
a 
{@link 
CryptoKeyPair
}
 and creating a 
{@link 
KeyPairSigner
}
 from it.
@paramextractable Setting this to `true` makes it possible to extract the bytes of the private
key using the [`crypto.subtle.exportKey()`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/exportKey)
API. Defaults to `false`, which prevents the bytes of the private key from being visible to JS.@example```ts
import { generateKeyPairSigner } from '@solana/signers';

const signer = await generateKeyPairSigner();
```@see{@link createSignerFromKeyPair}generateKeyPairSigner();

// First, pin job definition to IPFS
// Learn more about job definition structure: /deployments/jobs/job-definition/intro
const const ipfsHash: stringipfsHash: string = await const client: NosanaClientclient.NosanaClient.ipfs: NosanaIpfsClientipfs.pin: (data: object) => Promise<string>pin({
  version: stringversion: '0.1',
  type: stringtype: 'container',
  
meta: {
    trigger: string;
}meta: {
    trigger: stringtrigger: 'cli',
  },
  
ops: {
    type: string;
    id: string;
    args: {
        cmd: string;
        image: string;
    };
}[]ops: [
    {
      type: stringtype: 'container/run',
      id: stringid: 'run-1',
      
args: {
    cmd: string;
    image: string;
}args: {
        cmd: stringcmd: 'echo Hello from Nosana!',
        image: stringimage: 'ubuntu:latest',
      },
    },
  ],
});

// Create job instruction
import { function address<TAddress extends string = string>(putativeAddress: TAddress): Address<TAddress>
Combines _asserting_ that a string is an address with _coercing_ it to the 
{@link 
Address
}
 type.
It's most useful with untrusted input.
@example```ts
import { address } from '@solana/addresses';

await transfer(address(fromAddress), address(toAddress), lamports(100000n));
```

> [!TIP]
> When starting from a known-good address as a string, it's more efficient to typecast it rather
than to use the {@link address} helper, because the helper unconditionally performs validation on
its input.
>
> ```ts
> import { Address } from '@solana/addresses';
>
> const MEMO_PROGRAM_ADDRESS =
>     'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr' as Address<'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'>;
> ```address } from '@nosana/kit';
const const instruction: Instruction<string, readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[]>instruction: interface Instruction<TProgramAddress extends string = string, TAccounts extends readonly (AccountLookupMeta | AccountMeta)[] = readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[]>
An instruction destined for a given program.
@example```ts
type StakeProgramInstruction = Instruction<'StakeConfig11111111111111111111111111111111'>;
```Instruction = await const client: NosanaClientclient.NosanaClient.jobs: JobsProgramjobs.JobsProgram.post(params: ListParams | AssignParams): Promise<ListInstruction | AssignInstruction>
Post a new job to the marketplace (can list or assign based on params)post({
  market: Address<"market-address">market: address<"market-address">(putativeAddress: "market-address"): Address<"market-address">
Combines _asserting_ that a string is an address with _coercing_ it to the 
{@link 
Address
}
 type.
It's most useful with untrusted input.
@example```ts
import { address } from '@solana/addresses';

await transfer(address(fromAddress), address(toAddress), lamports(100000n));
```

> [!TIP]
> When starting from a known-good address as a string, it's more efficient to typecast it rather
than to use the {@link address} helper, because the helper unconditionally performs validation on
its input.
>
> ```ts
> import { Address } from '@solana/addresses';
>
> const MEMO_PROGRAM_ADDRESS =
>     'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr' as Address<'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'>;
> ```address('market-address'),
  timeout: numbertimeout: 3600, // 1 hour
  ipfsHash: stringipfsHash: const ipfsHash: stringipfsHash,
});

// Submit the job
const const signature: stringsignature: string = await const client: NosanaClientclient.NosanaClient.solana: SolanaServicesolana.
SolanaService.buildSignAndSend(instructions: Instruction | Instruction[], options?: {
    feePayer?: TransactionSigner;
    commitment?: "processed" | "confirmed" | "finalized";
    estimateComputeUnits?: boolean;
}): Promise<Signature>buildSignAndSend(const instruction: Instruction<string, readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[]>instruction);
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log('Job posted:', const signature: stringsignature);

Monitor Job Updates

import { enum JobStateJobState } from '@nosana/kit';
import type { 
type SimpleMonitorEvent = {
    type: "job";
    data: Job;
} | {
    type: "market";
    data: Market;
}
Simple monitor event (run accounts are auto-merged into job events)
@group@nosana/kitSimpleMonitorEvent } from '@nosana/kit';

// Start monitoring
const [const eventStream: AsyncIterable<SimpleMonitorEvent>eventStream, const stop: () => voidstop] = await const client: NosanaClientclient.NosanaClient.jobs: JobsProgramjobs.JobsProgram.monitor(): Promise<[AsyncIterable<SimpleMonitorEvent>, () => void]>
Monitor program account updates using async iterators.
Automatically merges run account data into job account updates.
Returns a tuple of [eventStream, stopFunction].
@example```typescript
const [eventStream, stop] = await jobsProgram.monitor();
for await (const event of eventStream) {
  if (event.type === MonitorEventType.JOB) {
    console.log('Job updated:', event.data.address);
  } else if (event.type === MonitorEventType.MARKET) {
    console.log('Market updated:', event.data.address);
  }
}
```monitor();

// Process events using async iteration
for await (const const event: SimpleMonitorEventevent of const eventStream: AsyncIterable<SimpleMonitorEvent>eventStream) {
  if (const event: SimpleMonitorEventevent.type: "job" | "market"type === 'job') {
    var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log('Job update:', 
const event: {
    type: "job";
    data: Job;
}event.data: Jobdata.address: Addressaddress, 
const event: {
    type: "job";
    data: Job;
}event.data: Jobdata.state: JobStatestate);
    
    // Process updates - save to database, trigger workflows, etc.
    if (
const event: {
    type: "job";
    data: Job;
}event.data: Jobdata.state: JobStatestate === enum JobStateJobState.function (enum member) JobState.COMPLETED = 2COMPLETED) {
      var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log('Job completed!');
      
      // Retrieve results from IPFS
      if (
const event: {
    type: "job";
    data: Job;
}event.data: Jobdata.ipfsResult: string | nullipfsResult) {
        const const results: unknownresults = await const client: NosanaClientclient.NosanaClient.ipfs: NosanaIpfsClientipfs.retrieve: <unknown>(hash: string | Array<number>) => Promise<unknown>retrieve(
const event: {
    type: "job";
    data: Job;
}event.data: Jobdata.ipfsResult: stringipfsResult);
        var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log('Job results:', const results: unknownresults);
      }
    }
  } else if (
const event: {
    type: "market";
    data: Market;
}event.type: "market"type === 'market') {
    var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log('Market update:', 
const event: {
    type: "market";
    data: Market;
}event.data: Marketdata.address: Addressaddress);
  }
}

// Stop monitoring when done
const stop: () => voidstop();

Query Jobs by State

import { enum JobStateJobState } from '@nosana/kit';
import type { 
type Job = Omit<ConvertTypesForDb<JobAccountArgs>, "state"> & {
    address: Address;
    state: JobState;
}Job } from '@nosana/kit';
import { function address<TAddress extends string = string>(putativeAddress: TAddress): Address<TAddress>
Combines _asserting_ that a string is an address with _coercing_ it to the 
{@link 
Address
}
 type.
It's most useful with untrusted input.
@example```ts
import { address } from '@solana/addresses';

await transfer(address(fromAddress), address(toAddress), lamports(100000n));
```

> [!TIP]
> When starting from a known-good address as a string, it's more efficient to typecast it rather
than to use the {@link address} helper, because the helper unconditionally performs validation on
its input.
>
> ```ts
> import { Address } from '@solana/addresses';
>
> const MEMO_PROGRAM_ADDRESS =
>     'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr' as Address<'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'>;
> ```address } from '@nosana/kit';

// Get all running jobs
const const runningJobs: Job[]runningJobs: 
type Job = Omit<ConvertTypesForDb<JobAccountArgs>, "state"> & {
    address: Address;
    state: JobState;
}Job[] = await const client: NosanaClientclient.NosanaClient.jobs: JobsProgramjobs.
JobsProgram.all(filters?: {
    state?: JobState;
    market?: Address;
    node?: Address;
    project?: Address;
}, checkRuns?: boolean): Promise<Job[]>
Fetch all job accountsall({
  state?: JobState | undefinedstate: enum JobStateJobState.function (enum member) JobState.RUNNING = 1RUNNING,
});

// Get all jobs for a specific project
const const projectJobs: Job[]projectJobs: 
type Job = Omit<ConvertTypesForDb<JobAccountArgs>, "state"> & {
    address: Address;
    state: JobState;
}Job[] = await const client: NosanaClientclient.NosanaClient.jobs: JobsProgramjobs.
JobsProgram.all(filters?: {
    state?: JobState;
    market?: Address;
    node?: Address;
    project?: Address;
}, checkRuns?: boolean): Promise<Job[]>
Fetch all job accountsall({
  project?: Address | undefinedproject: address<"project-address">(putativeAddress: "project-address"): Address<"project-address">
Combines _asserting_ that a string is an address with _coercing_ it to the 
{@link 
Address
}
 type.
It's most useful with untrusted input.
@example```ts
import { address } from '@solana/addresses';

await transfer(address(fromAddress), address(toAddress), lamports(100000n));
```

> [!TIP]
> When starting from a known-good address as a string, it's more efficient to typecast it rather
than to use the {@link address} helper, because the helper unconditionally performs validation on
its input.
>
> ```ts
> import { Address } from '@solana/addresses';
>
> const MEMO_PROGRAM_ADDRESS =
>     'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr' as Address<'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'>;
> ```address('project-address'),
});

// Get all jobs in a market
const const marketJobs: Job[]marketJobs: 
type Job = Omit<ConvertTypesForDb<JobAccountArgs>, "state"> & {
    address: Address;
    state: JobState;
}Job[] = await const client: NosanaClientclient.NosanaClient.jobs: JobsProgramjobs.
JobsProgram.all(filters?: {
    state?: JobState;
    market?: Address;
    node?: Address;
    project?: Address;
}, checkRuns?: boolean): Promise<Job[]>
Fetch all job accountsall({
  market?: Address | undefinedmarket: address<"market-address">(putativeAddress: "market-address"): Address<"market-address">
Combines _asserting_ that a string is an address with _coercing_ it to the 
{@link 
Address
}
 type.
It's most useful with untrusted input.
@example```ts
import { address } from '@solana/addresses';

await transfer(address(fromAddress), address(toAddress), lamports(100000n));
```

> [!TIP]
> When starting from a known-good address as a string, it's more efficient to typecast it rather
than to use the {@link address} helper, because the helper unconditionally performs validation on
its input.
>
> ```ts
> import { Address } from '@solana/addresses';
>
> const MEMO_PROGRAM_ADDRESS =
>     'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr' as Address<'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'>;
> ```address('market-address'),
});

Get Job with Run Information

import type { 
type Job = Omit<ConvertTypesForDb<JobAccountArgs>, "state"> & {
    address: Address;
    state: JobState;
}Job } from '@nosana/kit';
// Get job and automatically check for associated run
import { function address<TAddress extends string = string>(putativeAddress: TAddress): Address<TAddress>
Combines _asserting_ that a string is an address with _coercing_ it to the 
{@link 
Address
}
 type.
It's most useful with untrusted input.
@example```ts
import { address } from '@solana/addresses';

await transfer(address(fromAddress), address(toAddress), lamports(100000n));
```

> [!TIP]
> When starting from a known-good address as a string, it's more efficient to typecast it rather
than to use the {@link address} helper, because the helper unconditionally performs validation on
its input.
>
> ```ts
> import { Address } from '@solana/addresses';
>
> const MEMO_PROGRAM_ADDRESS =
>     'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr' as Address<'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'>;
> ```address } from '@nosana/kit';
const const job: Jobjob: 
type Job = Omit<ConvertTypesForDb<JobAccountArgs>, "state"> & {
    address: Address;
    state: JobState;
}Job = await const client: NosanaClientclient.NosanaClient.jobs: JobsProgramjobs.JobsProgram.get(addr: Address, checkRun?: boolean): Promise<Job>
Fetch a job account by addressget(address<"job-address">(putativeAddress: "job-address"): Address<"job-address">
Combines _asserting_ that a string is an address with _coercing_ it to the 
{@link 
Address
}
 type.
It's most useful with untrusted input.
@example```ts
import { address } from '@solana/addresses';

await transfer(address(fromAddress), address(toAddress), lamports(100000n));
```

> [!TIP]
> When starting from a known-good address as a string, it's more efficient to typecast it rather
than to use the {@link address} helper, because the helper unconditionally performs validation on
its input.
>
> ```ts
> import { Address } from '@solana/addresses';
>
> const MEMO_PROGRAM_ADDRESS =
>     'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr' as Address<'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'>;
> ```address('job-address'), true);

if (const job: Jobjob.state: JobStatestate === enum JobStateJobState.function (enum member) JobState.RUNNING = 1RUNNING) {
  var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log('Job is running on node:', const job: Jobjob.node: Addressnode);
  var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v24.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v24.x/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v24.x/api/util.html#utilformatformat-args) for more information.
@sincev0.1.100log('Started at:', new 
var Date: DateConstructor
new (value: number | string | Date) => Date (+4 overloads)Date(
var Number: NumberConstructor
(value?: any) => number
An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers.Number(const job: Jobjob.timeStart: number | biginttimeStart) * 1000));
}