@nosana/kit 1.0.2 → 1.0.7

package/dist/programs/MerkleDistributorProgram.js

@@ -0,0 +1,296 @@
+import { BaseProgram } from './BaseProgram.js';
+import { parseBase64RpcAccount, address, } from 'gill';
+import { NosanaError, ErrorCodes } from '../index.js';
+import * as programClient from '../generated_clients/merkle_distributor/index.js';
+import { convertBigIntToNumber } from '../utils/index.js';
+import { findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
+import bs58 from 'bs58';
+import { SYSTEM_PROGRAM_ADDRESS } from 'gill/programs';
+/**
+ * Claim target enum for merkle distributor.
+ * Determines which address receives the claimed tokens.
+ */
+export var ClaimTarget;
+(function (ClaimTarget) {
+    ClaimTarget["YES"] = "YES";
+    ClaimTarget["NO"] = "NO";
+})(ClaimTarget || (ClaimTarget = {}));
+/**
+ * Allowed addresses for receiving claimed tokens from merkle distributor.
+ * The `to` account must be the ATA of one of these addresses.
+ */
+export const ALLOWED_RECEIVE_ADDRESSES = {
+    [ClaimTarget.YES]: address('YessuvqUauj9yW4B3eERcyRLWmQtWpFc2ERKmaedmCE'),
+    [ClaimTarget.NO]: address('NopXntmRdXhYNkoZaNTMUMShJ3aVG5RvwpiyPdd4bMh'),
+};
+/**
+ * Error thrown when a claim status account is not found
+ */
+export class ClaimStatusNotFoundError extends Error {
+    constructor(address) {
+        super(`Claim status account not found at address ${address}`);
+        this.name = 'ClaimStatusNotFoundError';
+    }
+}
+export class MerkleDistributorProgram extends BaseProgram {
+    constructor(sdk) {
+        super(sdk);
+        this.client = programClient;
+    }
+    getProgramId() {
+        return this.sdk.config.programs.merkleDistributorAddress;
+    }
+    /**
+     * Derive the ClaimStatus PDA address for a given distributor and optional claimant.
+     * If claimant is not provided, uses the wallet's address.
+     *
+     * @param distributor The address of the merkle distributor
+     * @param claimant Optional claimant address. If not provided, uses the wallet's address.
+     * @returns The ClaimStatus PDA address
+     * @throws Error if wallet is not set and claimant is not provided
+     */
+    async getClaimStatusPda(distributor, claimant) {
+        let claimantAddress;
+        if (claimant) {
+            claimantAddress = claimant;
+        }
+        else {
+            if (!this.sdk.wallet) {
+                throw new Error('Wallet not set. Please set a wallet or provide a claimant address.');
+            }
+            claimantAddress = this.sdk.wallet.address;
+        }
+        return await this.sdk.solana.pda(['ClaimStatus', claimantAddress, distributor], this.getProgramId());
+    }
+    /**
+     * Fetch a merkle distributor account by address
+     */
+    async get(addr) {
+        try {
+            const distributorAccount = await this.client.fetchMerkleDistributor(this.sdk.solana.rpc, addr);
+            const distributor = this.transformMerkleDistributorAccount(distributorAccount);
+            return distributor;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch merkle distributor ${err}`);
+            throw err;
+        }
+    }
+    /**
+     * Fetch all merkle distributor accounts
+     */
+    async all() {
+        try {
+            const getProgramAccountsResponse = await this.sdk.solana.rpc
+                .getProgramAccounts(this.getProgramId(), {
+                encoding: 'base64',
+                filters: [
+                    {
+                        memcmp: {
+                            offset: BigInt(0),
+                            bytes: bs58.encode(Buffer.from(this.client.MERKLE_DISTRIBUTOR_DISCRIMINATOR)),
+                            encoding: 'base58',
+                        },
+                    },
+                ],
+            })
+                .send();
+            const distributors = getProgramAccountsResponse
+                .map((result) => {
+                try {
+                    const distributorAccount = programClient.decodeMerkleDistributor(parseBase64RpcAccount(result.pubkey, result.account));
+                    return this.transformMerkleDistributorAccount(distributorAccount);
+                }
+                catch (err) {
+                    this.sdk.logger.error(`Failed to decode merkle distributor ${err}`);
+                    return null;
+                }
+            })
+                .filter((account) => account !== null);
+            return distributors;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch all merkle distributors ${err}`);
+            throw err;
+        }
+    }
+    /**
+     * Fetch a claim status account by address
+     */
+    async getClaimStatus(addr) {
+        try {
+            const maybeClaimStatus = await this.client.fetchMaybeClaimStatus(this.sdk.solana.rpc, addr);
+            // If account doesn't exist, throw a specific error
+            if (!maybeClaimStatus.exists) {
+                throw new ClaimStatusNotFoundError(addr);
+            }
+            // Transform and return the claim status
+            return this.transformClaimStatusAccount(maybeClaimStatus);
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch claim status ${err}`);
+            throw err;
+        }
+    }
+    /**
+     * Fetch claim status for a specific distributor and optional claimant.
+     * Derives the ClaimStatus PDA using the claimant address (or wallet's address if not provided) and the distributor address.
+     *
+     * @param distributor The address of the merkle distributor
+     * @param claimant Optional claimant address. If not provided, uses the wallet's address.
+     * @returns The claim status if it exists, null otherwise
+     * @throws Error if wallet is not set and claimant is not provided
+     */
+    async getClaimStatusForDistributor(distributor, claimant) {
+        try {
+            // Derive ClaimStatus PDA
+            const claimStatusPda = await this.getClaimStatusPda(distributor, claimant);
+            // Reuse getClaimStatus to fetch and transform the claim status
+            // If the account doesn't exist, it will throw, so we catch and return null
+            return await this.getClaimStatus(claimStatusPda);
+        }
+        catch (err) {
+            // If the account doesn't exist, return null instead of throwing
+            // Check if it's the specific ClaimStatusNotFoundError from getClaimStatus
+            if (err instanceof ClaimStatusNotFoundError) {
+                return null;
+            }
+            // For other errors, log and rethrow
+            this.sdk.logger.error(`Failed to fetch claim status ${err}`);
+            throw err;
+        }
+    }
+    /**
+     * Fetch all claim status accounts
+     * TODO: add filter for claimant and distributor
+     */
+    async allClaimStatus() {
+        try {
+            const getProgramAccountsResponse = await this.sdk.solana.rpc
+                .getProgramAccounts(this.getProgramId(), {
+                encoding: 'base64',
+                filters: [
+                    {
+                        memcmp: {
+                            offset: BigInt(0),
+                            bytes: bs58.encode(Buffer.from(this.client.CLAIM_STATUS_DISCRIMINATOR)),
+                            encoding: 'base58',
+                        },
+                    },
+                ],
+            })
+                .send();
+            const claimStatuses = getProgramAccountsResponse
+                .map((result) => {
+                try {
+                    const claimStatusAccount = programClient.decodeClaimStatus(parseBase64RpcAccount(result.pubkey, result.account));
+                    return this.transformClaimStatusAccount(claimStatusAccount);
+                }
+                catch (err) {
+                    this.sdk.logger.error(`Failed to decode claim status ${err}`);
+                    return null;
+                }
+            })
+                .filter((account) => account !== null);
+            return claimStatuses;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to fetch all claim statuses ${err}`);
+            throw err;
+        }
+    }
+    /**
+     * Transform merkle distributor account to include address and convert BigInt to numbers
+     */
+    transformMerkleDistributorAccount(distributorAccount) {
+        const { 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        discriminator: _, root, buffer0, buffer1, buffer2, ...distributorAccountData } = distributorAccount.data;
+        const converted = convertBigIntToNumber(distributorAccountData);
+        return {
+            address: distributorAccount.address,
+            ...converted,
+            root: bs58.encode(Buffer.from(root)),
+            buffer0: bs58.encode(Buffer.from(buffer0)),
+            buffer1: bs58.encode(Buffer.from(buffer1)),
+            buffer2: bs58.encode(Buffer.from(buffer2)),
+        };
+    }
+    /**
+     * Transform claim status account to include address and convert BigInt to numbers
+     */
+    transformClaimStatusAccount(claimStatusAccount) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { discriminator: _, ...claimStatusAccountData } = claimStatusAccount.data;
+        return {
+            address: claimStatusAccount.address,
+            ...convertBigIntToNumber(claimStatusAccountData),
+        };
+    }
+    /**
+     * Claim tokens from a merkle distributor.
+     * This function creates a new ClaimStatus account and claims the tokens in a single instruction.
+     *
+     * @param params Parameters for claiming tokens
+     * @param params.claimant Optional claimant signer. If not provided, uses the wallet.
+     * @returns The newClaim instruction
+     * @throws NosanaError if tokens have already been claimed
+     * @throws Error if wallet is not set and claimant is not provided
+     */
+    async claim(params) {
+        // Determine claimant signer and address
+        let claimantSigner;
+        let claimantAddress;
+        if (params.claimant) {
+            claimantSigner = params.claimant;
+            claimantAddress = params.claimant.address;
+        }
+        else {
+            if (!this.sdk.wallet) {
+                throw new Error('Wallet not set. Please set a wallet or provide a claimant signer.');
+            }
+            claimantSigner = this.sdk.wallet;
+            claimantAddress = this.sdk.wallet.address;
+        }
+        try {
+            // Get the distributor account to find mint and tokenVault
+            const distributorAccount = await this.client.fetchMerkleDistributor(this.sdk.solana.rpc, params.distributor);
+            // Derive ClaimStatus PDA using the claimant address
+            const claimStatusPda = await this.getClaimStatusPda(params.distributor, claimantAddress);
+            // Check if ClaimStatus account exists
+            const maybeClaimStatus = await this.client.fetchMaybeClaimStatus(this.sdk.solana.rpc, claimStatusPda);
+            // If ClaimStatus already exists, throw an error (already claimed)
+            if (maybeClaimStatus.exists) {
+                throw new NosanaError('Tokens have already been claimed from this distributor', ErrorCodes.VALIDATION_ERROR);
+            }
+            // Get the target address for receiving tokens (YES or NO)
+            const targetAddress = ALLOWED_RECEIVE_ADDRESSES[params.target];
+            // Find the ATA of the target address (where tokens will be sent)
+            const [targetAta] = await findAssociatedTokenPda({
+                mint: distributorAccount.data.mint,
+                owner: targetAddress,
+                tokenProgram: TOKEN_PROGRAM_ADDRESS,
+            });
+            // Create newClaim instruction which creates the account and claims the tokens
+            // Note: tokens go to the ATA of the target address (YES or NO), not the claimant's ATA
+            // The claimant in the instruction is the claimant signer (or wallet if not provided)
+            const newClaimInstruction = programClient.getNewClaimInstruction({
+                distributor: params.distributor,
+                claimStatus: claimStatusPda,
+                from: distributorAccount.data.tokenVault,
+                to: targetAta, // ATA of YES or NO address, not claimant's ATA
+                claimant: claimantSigner, // Claimant signer (or wallet if not provided)
+                tokenProgram: TOKEN_PROGRAM_ADDRESS,
+                systemProgram: SYSTEM_PROGRAM_ADDRESS,
+                amountUnlocked: params.amountUnlocked,
+                amountLocked: params.amountLocked,
+                proof: params.proof,
+            }, { programAddress: this.getProgramId() });
+            return newClaimInstruction;
+        }
+        catch (err) {
+            this.sdk.logger.error(`Failed to create claim instructions: ${err}`);
+            throw err;
+        }
+    }
+}

package/dist/services/NosService.js

@@ -1,6 +1,8 @@
 import { address } from 'gill';
 import { NosanaError, ErrorCodes } from '../errors/NosanaError.js';
 import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
+// Standard SPL token account size
+const TOKEN_ACCOUNT_SIZE = 165;
 // Offset of mint address in token account data structure
 const MINT_OFFSET = 0;
 export class NosService {
@@ -31,6 +33,9 @@ export class NosService {
                 .getProgramAccounts(TOKEN_PROGRAM_ADDRESS, {
                 encoding: 'jsonParsed',
                 filters: [
+                    {
+                        dataSize: BigInt(TOKEN_ACCOUNT_SIZE),
+                    },
                     {
                         memcmp: {
                             offset: BigInt(MINT_OFFSET),

package/eslint.config.js

@@ -40,9 +40,7 @@ export default [
     // More lenient rules for test files
     files: ['tests/**/*.ts', '**/*.test.ts', '**/*.spec.ts'],
     rules: {
-      '@typescript-eslint/no-explicit-any': 'off',
-      '@typescript-eslint/no-unused-vars': 'warn',
-      'no-console': 'off',
+      '@typescript-eslint/no-explicit-any': 'off'
     },
   },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nosana/kit",
-  "version": "1.0.2",
+  "version": "1.0.7",
   "description": "Nosana KIT",
   "type": "module",
   "main": "dist/index.js",
@@ -13,8 +13,8 @@
     "generate-clients": "npx tsx scripts/generate-clients.ts",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "format": "prettier --write \"**/*.ts\"",
-    "prettier": "prettier --check \"**/*.ts\"",
+    "format": "prettier --check \"**/*.ts\"",
+    "format:fix": "prettier --write \"**/*.ts\"",
     "publish:public": "npm run build && npm publish --access public"
   },
   "keywords": [
@@ -27,12 +27,13 @@
   "author": "Nosana",
   "license": "MIT",
   "dependencies": {
-    "@solana-program/token": "^0.5.1",
-    "axios": "^1.6.0",
-    "bs58": "^6.0.0",
-    "buffer": "^6.0.3",
-    "form-data": "^4.0.0",
-    "gill": "^0.9.0"
+    "@solana-program/token": "0.5.1",
+    "@solana/sysvars": "5.0.0",
+    "axios": "1.6.0",
+    "bs58": "6.0.0",
+    "buffer": "6.0.3",
+    "form-data": "4.0.0",
+    "gill": "0.12.0"
   },
   "devDependencies": {
     "@codama/nodes-from-anchor": "^1.2.0",
@@ -40,13 +41,13 @@
     "@types/node": "^20.11.24",
     "@typescript-eslint/eslint-plugin": "^7.1.0",
     "@typescript-eslint/parser": "^7.1.0",
+    "@vitest/coverage-v8": "^1.6.0",
     "codama": "^1.3.0",
     "eslint": "^8.57.0",
-    "vitest": "^1.6.0",
-    "@vitest/coverage-v8": "^1.6.0",
     "prettier": "^3.2.5",
     "ts-node": "^10.9.2",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "vitest": "^1.6.0"
   },
   "engines": {
     "node": ">=20.18.0"

package/scripts/generate-clients.ts

@@ -3,6 +3,7 @@ import { rootNodeFromAnchor, AnchorIdl } from '@codama/nodes-from-anchor';
 import { renderVisitor as renderJavaScriptVisitor } from '@codama/renderers-js';
 import anchorJobsIdl from '../../spl/target/idl/nosana_jobs.json';
 import anchorStakingIdl from '../../spl/target/idl/nosana_staking.json';
+import merkleDistributorIdl from '../src/idl/merkle_distributor.json';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
@@ -20,3 +21,13 @@ const codamaStaking = createFromRoot(rootNodeFromAnchor(anchorStakingIdl as Anch
 codamaStaking.accept(
   renderJavaScriptVisitor(path.join(__dirname, '..', 'src', 'generated_clients', 'staking'))
 );
+
+const codamaMerkleDistributor = createFromRoot(
+  rootNodeFromAnchor(merkleDistributorIdl as AnchorIdl)
+);
+
+codamaMerkleDistributor.accept(
+  renderJavaScriptVisitor(
+    path.join(__dirname, '..', 'src', 'generated_clients', 'merkle_distributor')
+  )
+);