@nosana/kit 0.1.7 → 1.0.3

package/dist/{solana/SolanaUtils.js → services/SolanaService.js}

@@ -1,12 +1,14 @@
-import { createSolanaClient, address, getProgramDerivedAddress, getAddressEncoder, createTransaction, signTransactionMessageWithSigners, getExplorerLink, getSignatureFromTransaction } from 'gill';
+import { createSolanaClient, address, getProgramDerivedAddress, getAddressEncoder, createTransaction, signTransactionMessageWithSigners, getExplorerLink, getSignatureFromTransaction, } from 'gill';
 import { NosanaError, ErrorCodes } from '../errors/NosanaError.js';
-export class SolanaUtils {
+export class SolanaService {
     constructor(sdk) {
         this.sdk = sdk;
         const rpcEndpoint = this.sdk.config.solana.rpcEndpoint;
         if (!rpcEndpoint)
             throw new NosanaError('RPC URL is required', ErrorCodes.INVALID_CONFIG);
-        const { rpc, rpcSubscriptions, sendAndConfirmTransaction } = createSolanaClient({ urlOrMoniker: rpcEndpoint });
+        const { rpc, rpcSubscriptions, sendAndConfirmTransaction } = createSolanaClient({
+            urlOrMoniker: rpcEndpoint,
+        });
         this.rpc = rpc;
         this.rpcSubscriptions = rpcSubscriptions;
         this.sendAndConfirmTransaction = sendAndConfirmTransaction;
@@ -15,7 +17,7 @@ export class SolanaUtils {
         const addressEncoder = getAddressEncoder();
         const [pda] = await getProgramDerivedAddress({
             programAddress: programId,
-            seeds: seeds.map(seed => typeof seed !== 'string' ? addressEncoder.encode(seed) : seed),
+            seeds: seeds.map((seed) => (typeof seed !== 'string' ? addressEncoder.encode(seed) : seed)),
         });
         return pda;
     }
@@ -45,13 +47,21 @@ export class SolanaUtils {
      * Type guard to check if the input is a transaction
      */
     isTransaction(input) {
-        return 'instructions' in input && 'version' in input && !('programAddress' in input);
+        return (typeof input === 'object' &&
+            input !== null &&
+            'instructions' in input &&
+            'version' in input &&
+            !('programAddress' in input));
     }
     /**
      * Type guard to check if the input is a signed transaction
      */
     isSignedTransaction(input) {
-        return 'signatures' in input && input.signatures && input.signatures.length > 0;
+        return (typeof input === 'object' &&
+            input !== null &&
+            'signatures' in input &&
+            Array.isArray(input.signatures) &&
+            input.signatures.length > 0);
     }
     /**
      * Create, sign, and send a transaction with proper logging and error handling
@@ -95,7 +105,7 @@ export class SolanaUtils {
             // Log the transaction explorer link
             const explorerLink = getExplorerLink({
                 cluster: this.sdk.config.solana.cluster,
-                transaction: signature
+                transaction: signature,
             });
             this.sdk.logger.info(`Sending transaction: ${explorerLink}`);
             // Send and confirm the transaction

package/dist/utils/index.d.ts

@@ -16,4 +16,5 @@ export type ConvertTypesForDb<T> = {
  * @param obj Object that may contain bigint values
  * @returns Object with all bigint values converted to numbers
  */
-export declare function convertBigIntToNumber<T extends Record<string, any>>(obj: T): ConvertBigIntToNumber<T>;
+export declare function convertBigIntToNumber<T extends Record<string, unknown>>(obj: T): ConvertBigIntToNumber<T>;
+export * from './walletConverter.js';

package/dist/utils/index.js

@@ -12,3 +12,5 @@ export function convertBigIntToNumber(obj) {
     }
     return result;
 }
+// Export wallet conversion utilities
+export * from './walletConverter.js';

package/dist/utils/walletConverter.d.ts

@@ -0,0 +1,9 @@
+import { KeyPairSigner } from 'gill';
+import { WalletConfig } from '../config/index.js';
+/**
+ * Converts various wallet configurations to a KeyPairSigner
+ * @param wallet The wallet configuration to convert
+ * @returns A KeyPairSigner instance
+ * @throws NosanaError if conversion fails
+ */
+export declare function convertWalletConfigToKeyPairSigner(wallet: WalletConfig): Promise<KeyPairSigner>;

package/dist/utils/walletConverter.js

@@ -0,0 +1,141 @@
+import { Buffer } from 'buffer';
+import { createKeyPairSignerFromBytes } from 'gill';
+import { NosanaError, ErrorCodes } from '../errors/NosanaError.js';
+import { Logger } from '../logger/Logger.js';
+import bs58 from 'bs58';
+/**
+ * Converts various wallet configurations to a KeyPairSigner
+ * @param wallet The wallet configuration to convert
+ * @returns A KeyPairSigner instance
+ * @throws NosanaError if conversion fails
+ */
+export async function convertWalletConfigToKeyPairSigner(wallet) {
+    const logger = Logger.getInstance();
+    try {
+        // Check if we already have a KeyPairSigner type
+        if (wallet && typeof wallet === 'object' && 'address' in wallet && 'signMessages' in wallet) {
+            return 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;
+            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 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 isValidFilePath(wallet)) {
+                        try {
+                            wallet = await loadKeypairSignerFromFile(wallet);
+                            return wallet;
+                        }
+                        catch (error) {
+                            logger.debug(`Failed to load keypair from file: ${error}`);
+                        }
+                    }
+                    // Try to load from environment variable
+                    try {
+                        wallet = await loadKeypairSignerFromEnvironment(wallet);
+                        return wallet;
+                    }
+                    catch (error) {
+                        logger.debug(`Failed to load keypair from environment: ${error}`);
+                    }
+                    // Try to load from environment variable as base58
+                    try {
+                        wallet = await loadKeypairSignerFromEnvironmentBase58(wallet);
+                        return wallet;
+                    }
+                    catch (error) {
+                        logger.debug(`Failed to load keypair from environment base58: ${error}`);
+                    }
+                }
+                catch (error) {
+                    logger.debug(`Node.js modules not available: ${error}`);
+                }
+            }
+            // Try to parse as JSON array
+            if (wallet.startsWith('[')) {
+                try {
+                    const key = JSON.parse(wallet);
+                    wallet = await createKeyPairSignerFromBytes(new Uint8Array(key));
+                    return wallet;
+                }
+                catch (error) {
+                    logger.debug(`Failed to parse as JSON array: ${error}`);
+                }
+            }
+            // Try to decode as base58
+            try {
+                const key = Buffer.from(bs58.decode(wallet)).toJSON().data;
+                wallet = await createKeyPairSignerFromBytes(new Uint8Array(key));
+                return wallet;
+            }
+            catch (error) {
+                logger.debug(`Failed to decode as base58: ${error}`);
+            }
+        }
+        // If it's an array, try to create from bytes
+        if (Array.isArray(wallet)) {
+            try {
+                wallet = await createKeyPairSignerFromBytes(new Uint8Array(wallet));
+                return wallet;
+            }
+            catch (error) {
+                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);
+    }
+}
+/**
+ * Checks if a file path is valid and accessible
+ * @param filePath The file path to validate
+ * @returns True if the file path is valid and accessible
+ */
+async function 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;
+    }
+}

package/eslint.config.js

@@ -0,0 +1,47 @@
+import tseslint from '@typescript-eslint/eslint-plugin';
+import tsparser from '@typescript-eslint/parser';
+
+export default [
+  {
+    ignores: [
+      'dist/',
+      'node_modules/',
+      'coverage/',
+      'src/generated_clients/',
+      'examples/',
+      '**/*.config.js',
+      '**/*.config.ts',
+    ],
+  },
+  {
+    files: ['**/*.ts'],
+    languageOptions: {
+      parser: tsparser,
+      parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: 'module',
+      },
+    },
+    plugins: {
+      '@typescript-eslint': tseslint,
+    },
+    rules: {
+      ...tseslint.configs.recommended.rules,
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        { argsIgnorePattern: '^_' },
+      ],
+      'no-console': ['warn', { allow: ['warn', 'error', 'debug', 'info'] }],
+    },
+  },
+  {
+    // More lenient rules for test files
+    files: ['tests/**/*.ts', '**/*.test.ts', '**/*.spec.ts'],
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'off'
+    },
+  },
+];
+

package/examples/node/README.md

@@ -128,6 +128,121 @@ Comprehensive unit tests have been created in `src/__tests__/setWallet.test.ts`
 
 **Note**: Due to Jest/TypeScript configuration complexities with the `gill/dist/node` imports, running the tests may require additional setup. The functionality works correctly at runtime.
 
+## NOS Token Service Example
+
+The `nos-service.ts` example demonstrates how to interact with NOS token accounts using the NosService.
+
+### Features
+
+1. **Get all NOS token holders** - Fetch all token accounts holding NOS tokens (excludes zero balances by default)
+2. **Include zero balance accounts** - Optional flag to include accounts with zero balance
+3. **Exclude PDA accounts** - Filter out smart contract-owned token accounts (PDAs)
+4. **Get token account for address** - Retrieve token account details for a specific owner
+5. **Get balance** - Convenience method to get just the NOS balance
+6. **Batch queries** - Fetch balances for multiple addresses
+7. **Filter and analyze** - Find large holders and analyze token distribution
+
+### Running the Example
+
+```bash
+# Navigate to the examples/node directory
+cd examples/node
+
+# Install dependencies
+npm install
+
+# Run the nos-service example
+npm run nos-service
+```
+
+### Example Usage
+
+```typescript
+import { NosanaClient, NosanaNetwork } from '@nosana/kit';
+
+const client = new NosanaClient(NosanaNetwork.MAINNET);
+
+// Get all token holders (single RPC call, excludes zero balances by default)
+const holders = await client.nos.getAllTokenHolders();
+console.log(`Found ${holders.length} NOS token holders`);
+
+// Include accounts with zero balance
+const allAccounts = await client.nos.getAllTokenHolders({ includeZeroBalance: true });
+console.log(`Total accounts: ${allAccounts.length}`);
+
+// Exclude PDA accounts (smart contract-owned accounts)
+const userAccounts = await client.nos.getAllTokenHolders({ excludePdaAccounts: true });
+console.log(`User-owned accounts: ${userAccounts.length}`);
+
+// Get token account for specific address
+const account = await client.nos.getTokenAccountForAddress('owner-address');
+if (account) {
+  console.log(`Balance: ${account.uiAmount} NOS`);
+}
+
+// Get just the balance (convenience method)
+const balance = await client.nos.getBalance('owner-address');
+console.log(`Balance: ${balance} NOS`);
+
+// Filter holders by minimum balance
+const largeHolders = holders.filter(holder => holder.uiAmount >= 1000);
+```
+
+### Use Cases
+
+- **Analytics**: Analyze token distribution and holder statistics
+- **Airdrops**: Get list of all token holders for airdrop campaigns
+- **Balance checks**: Check NOS balances for specific addresses
+- **Leaderboards**: Create holder leaderboards sorted by balance
+- **Monitoring**: Track large holder movements
+
+## Stake Program Example
+
+The `stake-program.ts` example demonstrates how to interact with Nosana staking accounts using the StakeProgram.
+
+### Features
+
+1. **Get all stake accounts** - Fetch all staking accounts on-chain
+2. **Get single stake** - Fetch details of a specific stake account
+3. **Get multiple stakes** - Fetch multiple stake accounts by address
+4. **Analyze distribution** - Calculate staking statistics (total, average, largest)
+
+### Running the Example
+
+```bash
+# Navigate to the examples/node directory
+cd examples/node
+
+# Install dependencies
+npm install
+
+# Run the stake-program example
+npm run stake-program
+```
+
+### Example Usage
+
+```typescript
+import { NosanaClient, NosanaNetwork } from '@nosana/kit';
+
+const client = new NosanaClient(NosanaNetwork.MAINNET);
+
+// Get all stake accounts
+const allStakes = await client.stake.all();
+console.log(`Found ${allStakes.length} stake accounts`);
+
+// Get single stake account
+const stake = await client.stake.get('stake-account-address');
+console.log(`Staked amount: ${stake.amount}`);
+console.log(`xNOS tokens: ${stake.xnos}`);
+
+// Analyze staking distribution
+const totalStaked = allStakes.reduce((sum, s) => sum + s.amount, 0);
+const averageStake = totalStaked / allStakes.length;
+console.log(`Total staked: ${totalStaked.toLocaleString()}`);
+console.log(`Average stake: ${averageStake.toLocaleString()}`);
+```
+
 ## Other Examples
 
 - `retrieve.ts` - Example of retrieving job data

package/examples/node/nos-service.ts

@@ -0,0 +1,117 @@
+/**
+ * Example: Using the NosService to interact with NOS token accounts
+ * 
+ * This example demonstrates how to use the NosService to:
+ * 1. Get all NOS token holders
+ * 2. Get a specific token account for an address
+ * 3. Get the NOS balance for an address
+ */
+
+import { NosanaClient, NosanaNetwork } from '@nosana/kit';
+
+async function main() {
+  // Initialize the Nosana client (use MAINNET for real data)
+  const client = new NosanaClient(NosanaNetwork.MAINNET);
+
+  // Example 1: Get all NOS token holders (excludes zero balance by default)
+  console.log('Fetching all NOS token holders...');
+  try {
+    const holders = await client.nos.getAllTokenHolders();
+
+    console.log(`Found ${holders.length} NOS token holders (with non-zero balances)`);
+
+    // Display first 5 holders
+    holders.slice(0, 5).forEach((holder, index) => {
+      console.log(`\nHolder ${index + 1}:`);
+      console.log(`  Token Account: ${holder.pubkey}`);
+      console.log(`  Owner: ${holder.owner}`);
+      console.log(`  Balance: ${holder.uiAmount} NOS`);
+      console.log(`  Raw Amount: ${holder.amount.toString()}`);
+      console.log(`  Decimals: ${holder.decimals}`);
+    });
+
+    // Include zero balance accounts
+    console.log('\nFetching all accounts including zero balances...');
+    const allAccounts = await client.token.getAllTokenHolders({ includeZeroBalance: true });
+    console.log(`Total accounts (including zero balance): ${allAccounts.length}`);
+    console.log(`Accounts with zero balance: ${allAccounts.length - holders.length}`);
+
+    // Exclude PDA accounts (smart contract-owned accounts)
+    console.log('\nFetching user-owned accounts only (excluding PDAs)...');
+    const userAccounts = await client.token.getAllTokenHolders({ excludePdaAccounts: true });
+    console.log(`User-owned accounts: ${userAccounts.length}`);
+    console.log(`PDA accounts: ${holders.length - userAccounts.length}`);
+  } catch (error) {
+    console.error('Error fetching token holders:', error);
+  }
+
+  // Example 2: Get token account for a specific address
+  const ownerAddress = 'YourWalletAddressHere';
+
+  console.log(`\nFetching NOS token account for ${ownerAddress}...`);
+  try {
+    const account = await client.nos.getTokenAccountForAddress(ownerAddress);
+
+    if (account) {
+      console.log('Token Account found:');
+      console.log(`  Account Address: ${account.pubkey}`);
+      console.log(`  Owner: ${account.owner}`);
+      console.log(`  Mint: ${account.mint}`);
+      console.log(`  Balance: ${account.uiAmount} NOS`);
+      console.log(`  Raw Amount: ${account.amount.toString()}`);
+      console.log(`  Decimals: ${account.decimals}`);
+    } else {
+      console.log('No NOS token account found for this address');
+    }
+  } catch (error) {
+    console.error('Error fetching token account:', error);
+  }
+
+  // Example 3: Get just the balance (convenience method)
+  console.log(`\nFetching NOS balance for ${ownerAddress}...`);
+  try {
+    const balance = await client.nos.getBalance(ownerAddress);
+    console.log(`Balance: ${balance} NOS`);
+  } catch (error) {
+    console.error('Error fetching balance:', error);
+  }
+
+  // Example 4: Working with multiple addresses
+  const addresses = [
+    'Address1Here',
+    'Address2Here',
+    'Address3Here',
+  ];
+
+  console.log('\nFetching balances for multiple addresses...');
+  for (const addr of addresses) {
+    try {
+      const balance = await client.nos.getBalance(addr);
+      console.log(`${addr}: ${balance} NOS`);
+    } catch (error) {
+      console.error(`Error fetching balance for ${addr}:`, error);
+    }
+  }
+
+  // Example 5: Filter holders by minimum balance
+  console.log('\nFinding holders with at least 1000 NOS...');
+  try {
+    const holders = await client.nos.getAllTokenHolders();
+    const largeHolders = holders.filter(holder => holder.uiAmount >= 1000);
+
+    console.log(`Found ${largeHolders.length} holders with >= 1000 NOS`);
+
+    // Sort by balance descending
+    const sorted = largeHolders.sort((a, b) => b.uiAmount - a.uiAmount);
+
+    // Display top 10
+    sorted.slice(0, 10).forEach((holder, index) => {
+      console.log(`${index + 1}. ${holder.owner}: ${holder.uiAmount.toLocaleString()} NOS`);
+    });
+  } catch (error) {
+    console.error('Error analyzing holders:', error);
+  }
+}
+
+main().catch(console.error);
+

package/examples/node/package.json

@@ -6,7 +6,9 @@
   "scripts": {
     "retrieve": "tsx retrieve.ts",
     "monitor": "tsx monitor.ts",
-    "set-wallet": "tsx set-wallet.ts"
+    "set-wallet": "tsx set-wallet.ts",
+    "nos-service": "tsx nos-service.ts",
+    "stake-program": "tsx stake-program.ts"
   },
   "dependencies": {
     "@nosana/kit": "file:../.."

package/examples/node/retrieve.ts

@@ -2,11 +2,11 @@ import { address, NosanaClient, NosanaNetwork } from '@nosana/kit';
 
 async function main() {
   // Initialize the client with devnet for testing
-  const client = new NosanaClient(NosanaNetwork.MAINNET);
+  const client = new NosanaClient(NosanaNetwork.DEVNET);
 
   try {
     // Example: Get job details
-    const jobAddress = 'BwBURHTRMM3Ckzo2Dzmw99hv6gV8Ve12b6iw4sm9qeyR'; // Replace with actual job address
+    const jobAddress = 'FMbwxyhhAwXzixRqoSFhYzbx6RAQE4kgoTCdHXkNQ6AR'; // Replace with actual job address
     const jobDetails = await client.jobs.get(address(jobAddress));
     console.log('Job details:', jobDetails);
 

package/examples/node/stake-program.ts

@@ -0,0 +1,84 @@
+/**
+ * Example: Using the StakeProgram to interact with staking accounts
+ * 
+ * This example demonstrates how to use the StakeProgram to:
+ * 1. Get all stake accounts
+ * 2. Get stake accounts for a specific authority
+ * 3. Get a single stake account by address
+ */
+
+import { NosanaClient, NosanaNetwork } from '@nosana/kit';
+
+async function main() {
+  // Initialize the client
+  const client = new NosanaClient(NosanaNetwork.MAINNET);
+
+  console.log('=== Stake Program Example ===\n');
+
+  try {
+    // Example 1: Get all stake accounts
+    console.log('1. Fetching all stake accounts...');
+    const allStakes = await client.stake.all();
+    console.log(`   Found ${allStakes.length} stake accounts`);
+
+    if (allStakes.length > 0) {
+      const firstStake = allStakes[0];
+      console.log('   First stake account:');
+      console.log(`   - Address: ${firstStake.address}`);
+      console.log(`   - Authority: ${firstStake.authority}`);
+      console.log(`   - Amount: ${firstStake.amount}`);
+      console.log(`   - xNOS: ${firstStake.xnos}`);
+      console.log(`   - Duration: ${firstStake.duration}`);
+      console.log(`   - Time Unstake: ${firstStake.timeUnstake}`);
+      console.log(`   - Vault: ${firstStake.vault}`);
+      console.log(`   - Vault Bump: ${firstStake.vaultBump}`);
+    }
+    console.log();
+
+    // Example 2: Get a single stake account (if you know a stake account address)
+    if (allStakes.length > 0) {
+      console.log('2. Fetching single stake account...');
+      const stakeAddress = allStakes[0].address;
+      const stake = await client.stake.get(stakeAddress);
+      console.log(`   Retrieved stake account: ${stake.address}`);
+      console.log(`   - Authority: ${stake.authority}`);
+      console.log(`   - Staked Amount: ${stake.amount}`);
+      console.log(`   - xNOS Tokens: ${stake.xnos}`);
+      console.log();
+    }
+
+    // Example 3: Get multiple stake accounts by address
+    if (allStakes.length >= 2) {
+      console.log('3. Fetching multiple stake accounts...');
+      const addresses = allStakes.slice(0, 2).map(s => s.address);
+      const stakes = await client.stake.multiple(addresses);
+      console.log(`   Retrieved ${stakes.length} stake accounts`);
+      stakes.forEach((stake, i) => {
+        console.log(`   Stake ${i + 1}:`);
+        console.log(`   - Address: ${stake.address}`);
+        console.log(`   - Authority: ${stake.authority}`);
+        console.log(`   - Amount: ${stake.amount}`);
+      });
+      console.log();
+    }
+
+    // Example 4: Analyze staking distribution
+    console.log('4. Analyzing staking distribution...');
+    const totalStaked = allStakes.reduce((sum, stake) => sum + stake.amount, 0);
+    const averageStake = allStakes.length > 0 ? totalStaked / allStakes.length : 0;
+    const largestStake = allStakes.reduce((max, stake) =>
+      stake.amount > max ? stake.amount : max, 0
+    );
+
+    console.log(`   Total staked: ${totalStaked}`);
+    console.log(`   Average stake: ${averageStake.toFixed(2)}`);
+    console.log(`   Largest stake: ${largestStake}`);
+    console.log(`   Number of stakers: ${allStakes.length}`);
+
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+
+main();
+

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "@nosana/kit",
-  "version": "0.1.7",
+  "version": "1.0.3",
   "description": "Nosana KIT",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "test": "jest",
-    "generate-clients": "ts-node scripts/generate-clients.ts",
-    "lint": "eslint . --ext .ts",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "generate-clients": "npx tsx scripts/generate-clients.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "format": "prettier --write \"**/*.ts\"",
-    "publish:public": "npm version patch && npm run build && npm publish --access public"
+    "prettier": "prettier --check \"**/*.ts\"",
+    "publish:public": "npm run build && npm publish --access public"
   },
   "keywords": [
     "nosana",
@@ -33,15 +37,14 @@
   "devDependencies": {
     "@codama/nodes-from-anchor": "^1.2.0",
     "@codama/renderers-js": "^1.2.14",
-    "@types/jest": "^29.5.12",
     "@types/node": "^20.11.24",
     "@typescript-eslint/eslint-plugin": "^7.1.0",
     "@typescript-eslint/parser": "^7.1.0",
     "codama": "^1.3.0",
     "eslint": "^8.57.0",
-    "jest": "^29.7.0",
+    "vitest": "^1.6.0",
+    "@vitest/coverage-v8": "^1.6.0",
     "prettier": "^3.2.5",
-    "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",
     "typescript": "^5.3.3"
   },