@nosana/kit 0.1.6 → 1.0.2

package/dist/generated_clients/staking/shared/index.js

@@ -0,0 +1,86 @@
+/**
+ * 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 { AccountRole, isProgramDerivedAddress, isTransactionSigner as kitIsTransactionSigner, upgradeRoleToSigner, } from '@solana/kit';
+/**
+ * Asserts that the given value is not null or undefined.
+ * @internal
+ */
+export function expectSome(value) {
+    if (value == null) {
+        throw new Error('Expected a value but received null or undefined.');
+    }
+    return value;
+}
+/**
+ * Asserts that the given value is a PublicKey.
+ * @internal
+ */
+export function expectAddress(value) {
+    if (!value) {
+        throw new Error('Expected a Address.');
+    }
+    if (typeof value === 'object' && 'address' in value) {
+        return value.address;
+    }
+    if (Array.isArray(value)) {
+        return value[0];
+    }
+    return value;
+}
+/**
+ * Asserts that the given value is a PDA.
+ * @internal
+ */
+export function expectProgramDerivedAddress(value) {
+    if (!value || !Array.isArray(value) || !isProgramDerivedAddress(value)) {
+        throw new Error('Expected a ProgramDerivedAddress.');
+    }
+    return value;
+}
+/**
+ * Asserts that the given value is a TransactionSigner.
+ * @internal
+ */
+export function expectTransactionSigner(value) {
+    if (!value || !isTransactionSigner(value)) {
+        throw new Error('Expected a TransactionSigner.');
+    }
+    return value;
+}
+/**
+ * Get account metas and signers from resolved accounts.
+ * @internal
+ */
+export function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
+    return (account) => {
+        if (!account.value) {
+            if (optionalAccountStrategy === 'omitted')
+                return;
+            return Object.freeze({
+                address: programAddress,
+                role: AccountRole.READONLY,
+            });
+        }
+        const writableRole = account.isWritable
+            ? AccountRole.WRITABLE
+            : AccountRole.READONLY;
+        return Object.freeze({
+            address: expectAddress(account.value),
+            role: isTransactionSigner(account.value)
+                ? upgradeRoleToSigner(writableRole)
+                : writableRole,
+            ...(isTransactionSigner(account.value) ? { signer: account.value } : {}),
+        });
+    };
+}
+export function isTransactionSigner(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        'address' in value &&
+        kitIsTransactionSigner(value));
+}

package/dist/index.d.ts

@@ -1,23 +1,33 @@
 import { ClientConfig, NosanaNetwork, PartialClientConfig, WalletConfig } from './config/index.js';
 import { Logger } from './logger/Logger.js';
 import { JobsProgram } from './programs/JobsProgram.js';
-import { SolanaUtils } from './solana/SolanaUtils.js';
+import { StakeProgram } from './programs/StakeProgram.js';
+import { SolanaService } from './services/SolanaService.js';
+import { NosService } from './services/NosService.js';
+import { IPFS } from './ipfs/IPFS.js';
 import { KeyPairSigner } from 'gill';
 export declare class NosanaClient {
     readonly config: ClientConfig;
     readonly jobs: JobsProgram;
-    readonly solana: SolanaUtils;
+    readonly stake: StakeProgram;
+    readonly solana: SolanaService;
+    readonly nos: NosService;
+    readonly ipfs: IPFS;
     readonly logger: Logger;
     wallet: KeyPairSigner | undefined;
     constructor(network?: NosanaNetwork, customConfig?: PartialClientConfig);
     setWallet(wallet: WalletConfig): Promise<KeyPairSigner | undefined>;
-    private isValidFilePath;
 }
 export * from './config/index.js';
 export * from './errors/NosanaError.js';
 export * from './logger/Logger.js';
 export { JobsProgram, JobState, MarketQueueType } from './programs/JobsProgram.js';
 export type { Job, Market, Run } from './programs/JobsProgram.js';
+export { StakeProgram } from './programs/StakeProgram.js';
+export type { Stake } from './programs/StakeProgram.js';
 export * from './ipfs/IPFS.js';
-export * from './generated_clients/jobs/index.js';
+export { NosService } from './services/NosService.js';
+export type { TokenAccount, TokenAccountWithBalance } from './services/NosService.js';
+export * as JobsClient from './generated_clients/jobs/index.js';
+export * as StakingClient from './generated_clients/staking/index.js';
 export * from 'gill';

package/dist/index.js

@@ -1,14 +1,11 @@
-import { Buffer } from 'buffer';
-if (typeof window !== 'undefined' && typeof window.Buffer === 'undefined') {
-    window.Buffer = Buffer;
-}
-import { getNosanaConfig, NosanaNetwork } from './config/index.js';
+import { getNosanaConfig, NosanaNetwork, } from './config/index.js';
 import { Logger } from './logger/Logger.js';
 import { JobsProgram } from './programs/JobsProgram.js';
-import { SolanaUtils } from './solana/SolanaUtils.js';
-import { createKeyPairSignerFromBytes } from 'gill';
-import { NosanaError, ErrorCodes } from './errors/NosanaError.js';
-import bs58 from 'bs58';
+import { StakeProgram } from './programs/StakeProgram.js';
+import { SolanaService } from './services/SolanaService.js';
+import { NosService } from './services/NosService.js';
+import { IPFS } from './ipfs/IPFS.js';
+import { convertWalletConfigToKeyPairSigner } from './utils/walletConverter.js';
 export class NosanaClient {
     constructor(network = NosanaNetwork.MAINNET, customConfig) {
         this.config = getNosanaConfig(network, customConfig);
@@ -16,133 +13,15 @@ export class NosanaClient {
             this.setWallet(this.config.wallet);
         }
         this.jobs = new JobsProgram(this);
+        this.stake = new StakeProgram(this);
         this.logger = Logger.getInstance();
-        this.solana = new SolanaUtils(this);
+        this.solana = new SolanaService(this);
+        this.nos = new NosService(this);
+        this.ipfs = new IPFS(this.config.ipfs);
     }
     async setWallet(wallet) {
-        try {
-            // Check if we already have a KeyPairSigner type
-            if (wallet && typeof wallet === 'object' && 'address' in wallet && 'signMessages' in wallet) {
-                this.wallet = wallet;
-                return this.wallet;
-            }
-            // Check if it's a browser wallet adapter (has publicKey and signTransaction/signMessage)
-            if (wallet && typeof wallet === 'object' && 'publicKey' in wallet && ('signTransaction' in wallet || 'signMessage' in wallet)) {
-                // Convert browser wallet adapter to KeyPairSigner-like interface
-                const browserWallet = wallet;
-                this.wallet = {
-                    address: browserWallet.publicKey.toString(),
-                    signMessages: async (messages) => {
-                        if (browserWallet.signMessage) {
-                            return Promise.all(messages.map(msg => browserWallet.signMessage(msg)));
-                        }
-                        throw new Error('Browser wallet does not support message signing');
-                    },
-                    signTransactions: async (transactions) => {
-                        if (browserWallet.signTransaction) {
-                            return Promise.all(transactions.map(tx => browserWallet.signTransaction(tx)));
-                        }
-                        throw new Error('Browser wallet does not support transaction signing');
-                    }
-                };
-                return this.wallet;
-            }
-            // If it's a string, try multiple conversion methods
-            if (typeof wallet === 'string') {
-                // Only try file/environment loading in Node.js environment
-                if (typeof window === 'undefined') {
-                    try {
-                        // Use string concatenation to avoid bundler resolving this import at build time
-                        const nodeModule = 'gill' + '/node';
-                        const { loadKeypairSignerFromFile, loadKeypairSignerFromEnvironment, loadKeypairSignerFromEnvironmentBase58 } = await import(nodeModule);
-                        // Try to load from file path
-                        if (await this.isValidFilePath(wallet)) {
-                            try {
-                                this.wallet = await loadKeypairSignerFromFile(wallet);
-                                return this.wallet;
-                            }
-                            catch (error) {
-                                this.logger.debug(`Failed to load keypair from file: ${error}`);
-                            }
-                        }
-                        // Try to load from environment variable
-                        try {
-                            this.wallet = await loadKeypairSignerFromEnvironment(wallet);
-                            return this.wallet;
-                        }
-                        catch (error) {
-                            this.logger.debug(`Failed to load keypair from environment: ${error}`);
-                        }
-                        // Try to load from environment variable as base58
-                        try {
-                            this.wallet = await loadKeypairSignerFromEnvironmentBase58(wallet);
-                            return this.wallet;
-                        }
-                        catch (error) {
-                            this.logger.debug(`Failed to load keypair from environment base58: ${error}`);
-                        }
-                    }
-                    catch (error) {
-                        this.logger.debug(`Node.js modules not available: ${error}`);
-                    }
-                }
-                // Try to parse as JSON array
-                if (wallet.startsWith('[')) {
-                    try {
-                        const key = JSON.parse(wallet);
-                        this.wallet = await createKeyPairSignerFromBytes(new Uint8Array(key));
-                        return this.wallet;
-                    }
-                    catch (error) {
-                        this.logger.debug(`Failed to parse as JSON array: ${error}`);
-                    }
-                }
-                // Try to decode as base58
-                try {
-                    const key = Buffer.from(bs58.decode(wallet)).toJSON().data;
-                    this.wallet = await createKeyPairSignerFromBytes(new Uint8Array(key));
-                    return this.wallet;
-                }
-                catch (error) {
-                    this.logger.debug(`Failed to decode as base58: ${error}`);
-                }
-            }
-            // If it's an array, try to create from bytes
-            if (Array.isArray(wallet)) {
-                try {
-                    this.wallet = await createKeyPairSignerFromBytes(new Uint8Array(wallet));
-                    return this.wallet;
-                }
-                catch (error) {
-                    this.logger.debug(`Failed to create from byte array: ${error}`);
-                }
-            }
-            // If we get here, none of the conversion methods worked
-            throw new Error('Unable to convert wallet to KeyPairSigner using any available method');
-        }
-        catch (error) {
-            throw new NosanaError(`Failed to convert wallet to KeyPairSigner: ${error instanceof Error ? error.message : 'Unknown error'}`, ErrorCodes.WALLET_CONVERSION_ERROR, error);
-        }
-    }
-    async isValidFilePath(filePath) {
-        // Only validate file paths in Node.js environment
-        if (typeof window !== 'undefined') {
-            return false; // Browser environment, no file system access
-        }
-        try {
-            const [fs, path] = await Promise.all([
-                import('fs'),
-                import('path')
-            ]);
-            if (!path.isAbsolute(filePath) && !filePath.startsWith('./') && !filePath.startsWith('../')) {
-                return false;
-            }
-            const stats = await fs.promises.stat(filePath);
-            return stats.isFile();
-        }
-        catch {
-            return false;
-        }
+        this.wallet = await convertWalletConfigToKeyPairSigner(wallet);
+        return this.wallet;
     }
 }
 // Export types and configuration
@@ -151,9 +30,14 @@ export * from './errors/NosanaError.js';
 export * from './logger/Logger.js';
 // Export JobsProgram and related types
 export { JobsProgram, JobState, MarketQueueType } from './programs/JobsProgram.js';
+// Export StakeProgram and related types
+export { StakeProgram } from './programs/StakeProgram.js';
 // Export IPFS utilities
 export * from './ipfs/IPFS.js';
-// Export all generated client types and functions
-export * from './generated_clients/jobs/index.js';
-// Export dependencies 
+// Export NOS token service
+export { NosService } from './services/NosService.js';
+// Export generated clients under namespaces to avoid naming conflicts
+export * as JobsClient from './generated_clients/jobs/index.js';
+export * as StakingClient from './generated_clients/staking/index.js';
+// Export dependencies
 export * from 'gill';

package/dist/ipfs/IPFS.d.ts

@@ -1,19 +1,50 @@
+import { AxiosRequestConfig } from 'axios';
 import { ReadonlyUint8Array } from 'gill';
+import type { IpfsConfig } from '../config/types.js';
 /**
  * Class to interact with Pinata Cloud
  * https://www.pinata.cloud/
  */
 export declare class IPFS {
+    private api;
+    config: IpfsConfig;
+    constructor(config: IpfsConfig);
     /**
      * 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 | null;
+    static solHashToIpfsHash(hashArray: ReadonlyUint8Array | Array<number>): string | null;
     /**
      * Converts IPFS hash to byte array needed to submit results
      * @param hash IPFS hash
      * @returns Array<number>
      */
-    static IpfsHashToByteArray(hash: string): Uint8Array;
+    static IpfsHashToByteArray(hash: string): Array<number>;
+    /**
+     * Retrieve data from IPFS using the configured gateway
+     * @param hash IPFS hash string or byte array
+     * @param options Additional axios request options
+     * @returns The retrieved data
+     */
+    retrieve(hash: string | Array<number>, options?: AxiosRequestConfig): Promise<any>;
+    /**
+     * Function to pin data into Pinata Cloud
+     * @param data Object to pin into IPFS as JSON
+     * @returns The IPFS hash of the pinned data
+     */
+    pin(data: object): Promise<string>;
+    /**
+     * Function to pin a file into Pinata Cloud
+     * @param filePath Path to the file to pin
+     * @returns The IPFS hash of the pinned file
+     */
+    pinFile(filePath: string): Promise<string>;
+    /**
+     * Function to pin a file from buffer/blob into Pinata Cloud
+     * @param fileBuffer Buffer or Blob containing the file data
+     * @param fileName Name of the file
+     * @returns The IPFS hash of the pinned file
+     */
+    pinFileFromBuffer(fileBuffer: Buffer | Blob, fileName: string): Promise<string>;
 }

package/dist/ipfs/IPFS.js

@@ -1,9 +1,43 @@
 import bs58 from 'bs58';
+import axios, { AxiosHeaders } from 'axios';
+// Import form-data dynamically for Node.js environments
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let FormData;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let fs;
+// Dynamically import Node.js-specific modules
+const loadNodeModules = async () => {
+    if (typeof window === 'undefined') {
+        try {
+            const formDataModule = await import('form-data');
+            FormData = formDataModule.default;
+            fs = await import('fs');
+        }
+        catch (error) {
+            console.warn('Node.js modules not available for file operations');
+        }
+    }
+    else {
+        // Use browser FormData
+        FormData = window.FormData;
+    }
+};
 /**
  * Class to interact with Pinata Cloud
  * https://www.pinata.cloud/
  */
 export class IPFS {
+    constructor(config) {
+        this.config = config;
+        const headers = new AxiosHeaders();
+        if (this.config.jwt) {
+            headers.set('Authorization', `Bearer ${this.config.jwt}`);
+        }
+        this.api = axios.create({
+            baseURL: this.config.api,
+            headers,
+        });
+    }
     /**
      * 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.
@@ -11,16 +45,17 @@ export class IPFS {
      */
     static solHashToIpfsHash(hashArray) {
         let finalArray;
-        if (hashArray.length === 32) {
+        const inputArray = Array.isArray(hashArray) ? hashArray : Array.from(hashArray);
+        if (inputArray.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);
+            finalArray.set(inputArray, 2);
         }
         else {
             // Use the array as-is if it's not 32 bytes
-            finalArray = new Uint8Array(hashArray);
+            finalArray = new Uint8Array(inputArray);
         }
         const hash = bs58.encode(Buffer.from(finalArray));
         if (hash === 'QmNLei78zWmzUdbeRB3CiUfAizWUrbeeZh5K1rhAQKCh51') {
@@ -35,10 +70,80 @@ export class IPFS {
      */
     static IpfsHashToByteArray(hash) {
         if (hash.length === 34) {
-            return new Uint8Array([...bs58.decode(hash).subarray(2)]);
+            return [...bs58.decode(hash).subarray(2)];
         }
         else {
-            return new Uint8Array([...bs58.decode(hash)]);
+            return [...bs58.decode(hash)];
+        }
+    }
+    /**
+     * Retrieve data from IPFS using the configured gateway
+     * @param hash IPFS hash string or byte array
+     * @param options Additional axios request options
+     * @returns The retrieved data
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async retrieve(hash, options = {}) {
+        if (typeof hash !== 'string') {
+            const convertedHash = IPFS.solHashToIpfsHash(hash);
+            if (!convertedHash) {
+                throw new Error('Invalid hash provided');
+            }
+            hash = convertedHash;
+        }
+        const response = await axios.get(this.config.gateway + hash, options);
+        return response.data;
+    }
+    /**
+     * Function to pin data into Pinata Cloud
+     * @param data Object to pin into IPFS as JSON
+     * @returns The IPFS hash of the pinned data
+     */
+    async pin(data) {
+        const response = await this.api.post('/pinning/pinJSONToIPFS', data);
+        return response.data.IpfsHash;
+    }
+    /**
+     * Function to pin a file into Pinata Cloud
+     * @param filePath Path to the file to pin
+     * @returns The IPFS hash of the pinned file
+     */
+    async pinFile(filePath) {
+        // Ensure Node.js modules are loaded
+        await loadNodeModules();
+        if (!FormData || !fs) {
+            throw new Error('File operations are not supported in this environment');
+        }
+        const data = new FormData();
+        data.append('file', fs.createReadStream(filePath));
+        const response = await this.api.post('/pinning/pinFileToIPFS', data, {
+            headers: {
+                'Content-Type': `multipart/form-data; boundary=${data.getBoundary()}`,
+                Authorization: `Bearer ${this.config.jwt}`,
+            },
+        });
+        return response.data.IpfsHash;
+    }
+    /**
+     * Function to pin a file from buffer/blob into Pinata Cloud
+     * @param fileBuffer Buffer or Blob containing the file data
+     * @param fileName Name of the file
+     * @returns The IPFS hash of the pinned file
+     */
+    async pinFileFromBuffer(fileBuffer, fileName) {
+        // Ensure FormData is available
+        await loadNodeModules();
+        if (!FormData) {
+            throw new Error('FormData is not available in this environment');
         }
+        const data = new FormData();
+        data.append('file', fileBuffer, fileName);
+        const response = await this.api.post('/pinning/pinFileToIPFS', data, {
+            headers: {
+                'Content-Type': `multipart/form-data${data.getBoundary ? `; boundary=${data.getBoundary()}` : ''}`,
+                Authorization: `Bearer ${this.config.jwt}`,
+            },
+        });
+        return response.data.IpfsHash;
     }
 }

package/dist/programs/BaseProgram.d.ts

@@ -12,7 +12,7 @@ export declare abstract class BaseProgram {
     /**
      * Gets the static accounts, initializing them if needed.
      */
-    protected getStaticAccounts(): Promise<staticAccounts>;
+    getStaticAccounts(): Promise<staticAccounts>;
     private initializeStaticAccounts;
     protected readonly sdk: NosanaClient;
     constructor(sdk: NosanaClient);

package/dist/programs/BaseProgram.js

@@ -19,14 +19,10 @@ export class BaseProgram {
     }
     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),
+            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
+            jobsProgram: this.sdk.config.programs.jobsAddress,
         };
     }
     constructor(sdk) {

package/dist/programs/JobsProgram.d.ts

@@ -1,7 +1,7 @@
 import { BaseProgram } from './BaseProgram.js';
 import { Address, Account } from 'gill';
 import { NosanaClient } from '../index.js';
-import * as programClient from "../generated_clients/jobs/index.js";
+import * as programClient from '../generated_clients/jobs/index.js';
 import { ConvertTypesForDb } from '../utils/index.js';
 export declare enum JobState {
     QUEUED = 0,
@@ -37,16 +37,16 @@ export declare class JobsProgram extends BaseProgram {
      */
     run(addr: Address): Promise<Run>;
     /**
-   * Fetch a run account by address
-   */
+     * Fetch a run account by address
+     */
     market(addr: Address): Promise<Market>;
     /**
-   * Fetch multiple job accounts by address
-   */
+     * Fetch multiple job accounts by address
+     */
     multiple(addresses: Address[], checkRuns?: boolean): Promise<Job[]>;
     /**
-    * Fetch all job accounts
-    */
+     * Fetch all job accounts
+     */
     all(filters?: {
         state?: JobState;
         market?: Address;
@@ -54,15 +54,15 @@ export declare class JobsProgram extends BaseProgram {
         project?: Address;
     }, checkRuns?: boolean): Promise<Job[]>;
     /**
-    * Fetch all run accounts
-    */
+     * Fetch all run accounts
+     */
     runs(filters?: {
         node?: Address;
         job?: Address;
     }): Promise<Run[]>;
     /**
-    * Fetch all market accounts
-    */
+     * Fetch all market accounts
+     */
     markets(): Promise<Market[]>;
     /**
      * Post a new job to the marketplace
@@ -76,32 +76,32 @@ export declare class JobsProgram extends BaseProgram {
         node?: Address;
     }): Promise<ReturnType<typeof this.client.getListInstruction>>;
     /**
-   * 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 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;