@nosana/kit 1.0.3 → 1.0.8

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nosana/kit",
-  "version": "1.0.3",
+  "version": "1.0.8",
   "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,15 +41,20 @@
     "@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"
-  }
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ]
 }

package/.gitlab-ci.yml

@@ -1,54 +0,0 @@
-#   _ __   ___  ___  __ _ _ __   __ _
-#  | '_ \ / _ \/ __|/ _` | '_ \ / _` |
-#  | | | | (_) \__ \ (_| | | | | (_| |
-#  |_| |_|\___/|___/\__,_|_| |_|\__,_|
-
-image: node:22.8.0
-
-include:
-  - project: nosana-ci/tools/cicd/gitlab-ci
-    file: templates/semver.yml
-
-npm prettier:
-  stage: test
-  script:
-    - npm ci
-    - npm run prettier
-  rules:
-    - if: $CI_MERGE_REQUEST_ID
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
-
-npm lint:
-  stage: test
-  script:
-    - npm ci
-    - npm run lint
-  rules:
-    - if: $CI_MERGE_REQUEST_ID
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
-
-npm test:
-  stage: test
-  script:
-    - npm ci
-    - npm test
-  rules:
-    - if: $CI_MERGE_REQUEST_ID
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
-
-release:
-  stage: deploy
-  extends: .release
-  rules:
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
-
-npm publish prod:
-  stage: deploy
-  script:
-    - sed -i "s/0.0.0/${CI_COMMIT_TAG:1}/" package.json
-    - npm ci
-    - npm config set '//registry.npmjs.org/:_authToken' "${NPM_TOKEN}"
-    - npm run publish:public
-  when: manual
-  rules:
-    - if: $CI_COMMIT_TAG && $CI_COMMIT_TAG != "latest"

package/.prettierignore

@@ -1,17 +0,0 @@
-# Generated code
-src/generated_clients/
-
-# Examples
-examples/
-
-# Build output
-dist/
-build/
-
-# Dependencies
-node_modules/
-
-# Coverage
-coverage/
-.nyc_output/
-

package/eslint.config.js

@@ -1,47 +0,0 @@
-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/browser/.gitlab-ci.yml

@@ -1,78 +0,0 @@
-include:
-  - project: nosana-ci/tools/cicd/gitlab-ci
-    file: templates/semver.yml
-  - project: nosana-ci/tools/cicd/gitlab-ci
-    file: templates/cacheflush.yml
-
-variables:
-  NODE_VERSION: 22
-  OUTPUT_DIR: .output/public
-  PURGE_FILE: purge.json
-
-.npm:
-  image: node:$NODE_VERSION
-  cache:
-    key:
-      files:
-        - examples/browser/package-lock.json
-    paths:
-      - examples/browser/node_modules
-      - examples/browser/.npm
-
-build:
-  extends: .npm
-  stage: build
-  before_script:
-    - cd examples/browser
-  script: npm ci --cache .npm --prefer-offline
-  rules:
-    - if: $CI_MERGE_REQUEST_ID                                          # merge requests
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH                       # main
-    - if: $DEPLOYMENT_BRANCH && $CI_COMMIT_BRANCH == $DEPLOYMENT_BRANCH # optional deployment branch
-
-pages:
-  extends: .npm
-  stage: deploy
-  before_script:
-    - cd examples/browser
-  script:
-    - NODE_OPTIONS=--max_old_space_size=25384 npm run generate
-    - |
-      if [ -z ${SKIP_CACHEFLUSH} ] && [ -n ${FQDN} ]
-      then
-        apt update
-        apt install -y jq
-        find $OUTPUT_DIR -type f | sed "s/${OUTPUT_DIR//\//\\/}/https:\/\/$FQDN/g" | jq -R -s -c 'split("\n")[:-1]' > ../../$PURGE_FILE
-      fi
-    - mv $OUTPUT_DIR ../../public
-  artifacts:
-    paths:
-      - public
-      - $PURGE_FILE
-  rules:
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $AUTO_DEPLOY != null # main
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $AUTO_DEPLOY == null # main
-      when: manual
-    - if: $DEPLOYMENT_BRANCH && $CI_COMMIT_BRANCH == $DEPLOYMENT_BRANCH && $AUTO_DEPLOY != null # deployment branch
-    - if: $DEPLOYMENT_BRANCH && $CI_COMMIT_BRANCH == $DEPLOYMENT_BRANCH && $AUTO_DEPLOY == null # deployment branch
-      when: manual
-
-release:
-  extends: .release
-  stage: .post
-  rules:
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH                       # main
-    - if: $DEPLOYMENT_BRANCH && $CI_COMMIT_BRANCH == $DEPLOYMENT_BRANCH # optional deployment branch
-
-gitlab-release:
-  extends: .gitlab-release
-  stage: .post
-
-cacheflush:
-  extends: .cacheflush
-  stage: .post
-  rules:
-    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH                       # main
-    - if: $DEPLOYMENT_BRANCH && $CI_COMMIT_BRANCH == $DEPLOYMENT_BRANCH # optional deployment branch
-
-