@nosana/kit 0.1.7 → 1.0.2

package/dist/index.d.ts

@@ -1,25 +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,15 +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 { StakeProgram } from './programs/StakeProgram.js';
+import { SolanaService } from './services/SolanaService.js';
+import { NosService } from './services/NosService.js';
 import { IPFS } from './ipfs/IPFS.js';
-import { createKeyPairSignerFromBytes } from 'gill';
-import { NosanaError, ErrorCodes } from './errors/NosanaError.js';
-import bs58 from 'bs58';
+import { convertWalletConfigToKeyPairSigner } from './utils/walletConverter.js';
 export class NosanaClient {
     constructor(network = NosanaNetwork.MAINNET, customConfig) {
         this.config = getNosanaConfig(network, customConfig);
@@ -17,134 +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
@@ -153,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.js

@@ -1,7 +1,9 @@
 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 () => {
@@ -80,6 +82,7 @@ export class IPFS {
      * @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);

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;