@nosana/kit 0.1.1

package/dist/generated_clients/jobs/types/jobType.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobType = void 0;
+exports.getJobTypeEncoder = getJobTypeEncoder;
+exports.getJobTypeDecoder = getJobTypeDecoder;
+exports.getJobTypeCodec = getJobTypeCodec;
+const kit_1 = require("@solana/kit");
+/** The `JobType` describes the type of any job. */
+var JobType;
+(function (JobType) {
+    JobType[JobType["Default"] = 0] = "Default";
+    JobType[JobType["Small"] = 1] = "Small";
+    JobType[JobType["Medium"] = 2] = "Medium";
+    JobType[JobType["Large"] = 3] = "Large";
+    JobType[JobType["Gpu"] = 4] = "Gpu";
+    JobType[JobType["Unknown"] = 5] = "Unknown";
+})(JobType || (exports.JobType = JobType = {}));
+function getJobTypeEncoder() {
+    return (0, kit_1.getEnumEncoder)(JobType);
+}
+function getJobTypeDecoder() {
+    return (0, kit_1.getEnumDecoder)(JobType);
+}
+function getJobTypeCodec() {
+    return (0, kit_1.combineCodec)(getJobTypeEncoder(), getJobTypeDecoder());
+}

package/dist/generated_clients/jobs/types/queueType.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { type Codec, type Decoder, type Encoder } from '@solana/kit';
+/** The `QueueType` describes the type of queue */
+export declare enum QueueType {
+    Job = 0,
+    Node = 1,
+    Empty = 2
+}
+export type QueueTypeArgs = QueueType;
+export declare function getQueueTypeEncoder(): Encoder<QueueTypeArgs>;
+export declare function getQueueTypeDecoder(): Decoder<QueueType>;
+export declare function getQueueTypeCodec(): Codec<QueueTypeArgs, QueueType>;

package/dist/generated_clients/jobs/types/queueType.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueType = void 0;
+exports.getQueueTypeEncoder = getQueueTypeEncoder;
+exports.getQueueTypeDecoder = getQueueTypeDecoder;
+exports.getQueueTypeCodec = getQueueTypeCodec;
+const kit_1 = require("@solana/kit");
+/** The `QueueType` describes the type of queue */
+var QueueType;
+(function (QueueType) {
+    QueueType[QueueType["Job"] = 0] = "Job";
+    QueueType[QueueType["Node"] = 1] = "Node";
+    QueueType[QueueType["Empty"] = 2] = "Empty";
+})(QueueType || (exports.QueueType = QueueType = {}));
+function getQueueTypeEncoder() {
+    return (0, kit_1.getEnumEncoder)(QueueType);
+}
+function getQueueTypeDecoder() {
+    return (0, kit_1.getEnumDecoder)(QueueType);
+}
+function getQueueTypeCodec() {
+    return (0, kit_1.combineCodec)(getQueueTypeEncoder(), getQueueTypeDecoder());
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { ClientConfig, NosanaNetwork, PartialClientConfig } from './config/index.js';
+import { Logger } from './logger/Logger.js';
+import { JobsProgram } from './programs/JobsProgram.js';
+import { SolanaUtils } from './solana/SolanaUtils.js';
+export declare class NosanaClient {
+    readonly config: ClientConfig;
+    readonly jobs: JobsProgram;
+    readonly solana: SolanaUtils;
+    readonly logger: Logger;
+    constructor(network?: NosanaNetwork, customConfig?: PartialClientConfig);
+}
+export * from './config/index.js';
+export * from './errors/NosanaError.js';
+export * from './logger/Logger.js';
+export { JobsProgram } from './programs/JobsProgram.js';
+export type { Job, Market, Run } from './programs/JobsProgram.js';
+export * from './ipfs/IPFS.js';
+export * from './generated_clients/jobs/index.js';
+export * from 'gill';

package/dist/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobsProgram = exports.NosanaClient = void 0;
+const index_js_1 = require("./config/index.js");
+const Logger_js_1 = require("./logger/Logger.js");
+const JobsProgram_js_1 = require("./programs/JobsProgram.js");
+const SolanaUtils_js_1 = require("./solana/SolanaUtils.js");
+class NosanaClient {
+    constructor(network = index_js_1.NosanaNetwork.MAINNET, customConfig) {
+        this.config = (0, index_js_1.getNosanaConfig)(network, customConfig);
+        this.jobs = new JobsProgram_js_1.JobsProgram(this);
+        this.logger = Logger_js_1.Logger.getInstance();
+        this.solana = new SolanaUtils_js_1.SolanaUtils(this);
+    }
+}
+exports.NosanaClient = NosanaClient;
+// Export types and configuration
+__exportStar(require("./config/index.js"), exports);
+__exportStar(require("./errors/NosanaError.js"), exports);
+__exportStar(require("./logger/Logger.js"), exports);
+// Export JobsProgram and related types
+var JobsProgram_js_2 = require("./programs/JobsProgram.js");
+Object.defineProperty(exports, "JobsProgram", { enumerable: true, get: function () { return JobsProgram_js_2.JobsProgram; } });
+// Export IPFS utilities
+__exportStar(require("./ipfs/IPFS.js"), exports);
+// Export all generated client types and functions
+__exportStar(require("./generated_clients/jobs/index.js"), exports);
+// Export dependencies
+__exportStar(require("gill"), exports);

package/dist/ipfs/IPFS.d.ts

@@ -0,0 +1,19 @@
+import { ReadonlyUint8Array } from 'gill';
+/**
+ * Class to interact with Pinata Cloud
+ * https://www.pinata.cloud/
+ */
+export declare class IPFS {
+    /**
+     * Convert the ipfs bytes from a solana job to a CID
+     * It prepends the 0x1220 (18,32) to make it 34 bytes and Base58 encodes it.
+     * This result is IPFS addressable.
+     */
+    static solHashToIpfsHash(hashArray: ReadonlyUint8Array): string;
+    /**
+     * Converts IPFS hash to byte array needed to submit results
+     * @param hash IPFS hash
+     * @returns Array<number>
+     */
+    static IpfsHashToByteArray(hash: string): Uint8Array;
+}

package/dist/ipfs/IPFS.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPFS = void 0;
+const bs58_1 = __importDefault(require("bs58"));
+/**
+ * Class to interact with Pinata Cloud
+ * https://www.pinata.cloud/
+ */
+class IPFS {
+    /**
+     * Convert the ipfs bytes from a solana job to a CID
+     * It prepends the 0x1220 (18,32) to make it 34 bytes and Base58 encodes it.
+     * This result is IPFS addressable.
+     */
+    static solHashToIpfsHash(hashArray) {
+        let finalArray;
+        if (hashArray.length === 32) {
+            // Create a new array with the prepended bytes [18, 32] + original array
+            finalArray = new Uint8Array(34);
+            finalArray[0] = 18;
+            finalArray[1] = 32;
+            finalArray.set(hashArray, 2);
+        }
+        else {
+            // Use the array as-is if it's not 32 bytes
+            finalArray = new Uint8Array(hashArray);
+        }
+        return bs58_1.default.encode(Buffer.from(finalArray));
+    }
+    /**
+     * Converts IPFS hash to byte array needed to submit results
+     * @param hash IPFS hash
+     * @returns Array<number>
+     */
+    static IpfsHashToByteArray(hash) {
+        if (hash.length === 34) {
+            return new Uint8Array([...bs58_1.default.decode(hash).subarray(2)]);
+        }
+        else {
+            return new Uint8Array([...bs58_1.default.decode(hash)]);
+        }
+    }
+}
+exports.IPFS = IPFS;

package/dist/logger/Logger.d.ts

@@ -0,0 +1,24 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LoggerOptions {
+    level?: LogLevel;
+    prefix?: string;
+    enabled?: boolean;
+}
+export declare class Logger {
+    private static instance;
+    private level;
+    private prefix;
+    private enabled;
+    private constructor();
+    static getInstance(options?: LoggerOptions): Logger;
+    private shouldLog;
+    private formatMessage;
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    setLevel(level: LogLevel): void;
+    setPrefix(prefix: string): void;
+    enable(): void;
+    disable(): void;
+}

package/dist/logger/Logger.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+class Logger {
+    constructor(options) {
+        this.level = 'info';
+        this.prefix = '[Nosana]';
+        this.enabled = true;
+        if (options) {
+            this.level = options.level || this.level;
+            this.prefix = options.prefix || this.prefix;
+            this.enabled = options.enabled ?? this.enabled;
+        }
+    }
+    static getInstance(options) {
+        if (!Logger.instance) {
+            Logger.instance = new Logger(options);
+        }
+        return Logger.instance;
+    }
+    shouldLog(messageLevel) {
+        if (!this.enabled)
+            return false;
+        const levels = ['debug', 'info', 'warn', 'error'];
+        return levels.indexOf(messageLevel) >= levels.indexOf(this.level);
+    }
+    formatMessage(level, message) {
+        return `${this.prefix} [${level.toUpperCase()}] ${message}`;
+    }
+    debug(message) {
+        if (this.shouldLog('debug')) {
+            console.debug(this.formatMessage('debug', message));
+        }
+    }
+    info(message) {
+        if (this.shouldLog('info')) {
+            console.info(this.formatMessage('info', message));
+        }
+    }
+    warn(message) {
+        if (this.shouldLog('warn')) {
+            console.warn(this.formatMessage('warn', message));
+        }
+    }
+    error(message) {
+        if (this.shouldLog('error')) {
+            console.error(this.formatMessage('error', message));
+        }
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    setPrefix(prefix) {
+        this.prefix = prefix;
+    }
+    enable() {
+        this.enabled = true;
+    }
+    disable() {
+        this.enabled = false;
+    }
+}
+exports.Logger = Logger;

package/dist/programs/BaseProgram.d.ts

@@ -0,0 +1,20 @@
+import { Address } from 'gill';
+import { NosanaClient } from '../index.js';
+export type staticAccounts = {
+    rewardsReflection: Address;
+    rewardsVault: Address;
+    rewardsProgram: Address;
+    jobsProgram: Address;
+};
+export declare abstract class BaseProgram {
+    private _staticAccounts;
+    private _initializingAccounts;
+    /**
+     * Gets the static accounts, initializing them if needed.
+     */
+    protected getStaticAccounts(): Promise<staticAccounts>;
+    private initializeStaticAccounts;
+    protected readonly sdk: NosanaClient;
+    constructor(sdk: NosanaClient);
+    protected abstract getProgramId(): Address;
+}

package/dist/programs/BaseProgram.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProgram = void 0;
+class BaseProgram {
+    /**
+     * Gets the static accounts, initializing them if needed.
+     */
+    async getStaticAccounts() {
+        if (this._staticAccounts) {
+            return this._staticAccounts;
+        }
+        // If we're already initializing, return the existing promise
+        if (this._initializingAccounts) {
+            return this._initializingAccounts;
+        }
+        // Start initialization and store the promise
+        this._initializingAccounts = this.initializeStaticAccounts();
+        // Wait for initialization to complete
+        this._staticAccounts = await this._initializingAccounts;
+        this._initializingAccounts = undefined;
+        return this._staticAccounts;
+    }
+    async initializeStaticAccounts() {
+        return {
+            rewardsReflection: await this.sdk.solana.pda([
+                'reflection',
+            ], this.sdk.config.programs.rewardsAddress),
+            rewardsVault: await this.sdk.solana.pda([
+                this.sdk.config.programs.nosTokenAddress,
+            ], this.sdk.config.programs.rewardsAddress),
+            rewardsProgram: this.sdk.config.programs.rewardsAddress,
+            jobsProgram: this.sdk.config.programs.jobsAddress
+        };
+    }
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+}
+exports.BaseProgram = BaseProgram;

package/dist/programs/JobsProgram.d.ts

@@ -0,0 +1,118 @@
+import { BaseProgram } from './BaseProgram.js';
+import { Address, Signature, Account } from 'gill';
+import { NosanaClient } from '../index.js';
+import * as programClient from "../generated_clients/jobs/index.js";
+import { ConvertTypesForDb } from '../utils/index.js';
+export type Job = ConvertTypesForDb<programClient.JobAccountArgs> & {
+    address: Address;
+};
+export type Market = ConvertTypesForDb<programClient.MarketAccountArgs> & {
+    address: Address;
+};
+export type Run = ConvertTypesForDb<programClient.RunAccountArgs> & {
+    address: Address;
+};
+export declare class JobsProgram extends BaseProgram {
+    readonly client: typeof programClient;
+    constructor(sdk: NosanaClient);
+    protected getProgramId(): Address;
+    /**
+     * Fetch a job account by address
+     */
+    get(addr: Address, checkRun?: boolean): Promise<Job>;
+    /**
+     * Fetch a run account by address
+     */
+    run(addr: Address): Promise<Run>;
+    /**
+   * Fetch a run account by address
+   */
+    market(addr: Address): Promise<Market>;
+    /**
+   * Fetch multiple job accounts by address
+   */
+    multiple(addresses: Address[], checkRuns?: boolean): Promise<Job[]>;
+    /**
+    * Fetch all job accounts
+    */
+    all(filters?: {
+        state?: number;
+        market?: Address;
+        node?: Address;
+        project?: Address;
+    }, checkRuns?: boolean): Promise<Job[]>;
+    /**
+    * Fetch all run accounts
+    */
+    runs(filters?: {
+        node?: Address;
+        job?: Address;
+    }): Promise<Run[]>;
+    /**
+    * Fetch all market accounts
+    */
+    markets(): Promise<Market[]>;
+    /**
+     * Post a new job to the marketplace
+     * @param params Parameters for listing a job
+     * @returns The transaction signature
+     */
+    post(params: {
+        market: Address;
+        timeout: number | bigint;
+        ipfsHash: string;
+        node?: Address;
+        instructionOnly?: boolean;
+    }): Promise<ReturnType<typeof this.client.getListInstruction> | Signature>;
+    /**
+   * Monitor program account updates using callback functions
+   * Uses WebSocket subscriptions with automatic restart on failure
+   *
+   * @example
+   * ```typescript
+   * // Example: Monitor job accounts and save to file
+   * const stopMonitoring = await jobsProgram.monitor({
+   *   onJobAccount: async (jobAccount) => {
+   *     console.log('Job updated:', jobAccount.address.toString());
+   *     // Save to database, file, or process as needed
+   *   },
+   *   onRunAccount: async (runAccount) => {
+   *     console.log('Run updated:', runAccount.address.toString());
+   *   },
+   *   onError: async (error, accountType) => {
+   *     console.error('Error processing account:', error, accountType);
+   *   }
+   * });
+   *
+   * // Stop monitoring when done
+   * stopMonitoring();
+   * ```
+   *
+   * @param options Configuration options for monitoring
+   * @returns A function to stop monitoring
+   */
+    monitor(options?: {
+        onJobAccount?: (jobAccount: Job) => Promise<void> | void;
+        onMarketAccount?: (marketAccount: Market) => Promise<void> | void;
+        onRunAccount?: (runAccount: Run) => Promise<void> | void;
+        onError?: (error: Error, accountType?: string) => Promise<void> | void;
+    }): Promise<() => void>;
+    /**
+     * Set up WebSocket subscription for program notifications
+     */
+    private setupSubscription;
+    /**
+     * Process subscription notifications
+     */
+    private processSubscriptionNotifications;
+    transformJobAccount(jobAccount: Account<programClient.JobAccount>): Job;
+    transformRunAccount(runAccount: Account<programClient.RunAccount>): Run;
+    transformMarketAccount(marketAccount: Account<programClient.MarketAccount>): Market;
+    /**
+     * Handle account update using callback functions
+     */
+    private handleAccountUpdate;
+    private handleJobAccount;
+    private handleMarketAccount;
+    private handleRunAccount;
+}