@nosana/kit 1.0.10 → 2.0.10

package/dist/programs/MerkleDistributorProgram.js

@@ -1,337 +0,0 @@
-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;
-        }
-    }
-    /**
-     * Clawback tokens from a merkle distributor.
-     * This function creates a clawback instruction to transfer tokens from the distributor's token vault to the clawback receiver.
-     *
-     * @param params Parameters for clawback
-     * @param params.distributor The address of the merkle distributor
-     * @param params.claimant Optional claimant signer. If not provided, uses the wallet.
-     * @returns The clawback instruction
-     * @throws Error if wallet is not set and claimant is not provided
-     */
-    async clawback(params) {
-        // Determine claimant signer
-        let claimantSigner;
-        if (params.claimant) {
-            claimantSigner = params.claimant;
-        }
-        else {
-            if (!this.sdk.wallet) {
-                throw new Error('Wallet not set. Please set a wallet or provide a claimant signer.');
-            }
-            claimantSigner = this.sdk.wallet;
-        }
-        try {
-            // Get the distributor account to find tokenVault and clawbackReceiver
-            const distributorAccount = await this.client.fetchMerkleDistributor(this.sdk.solana.rpc, params.distributor);
-            // Create clawback instruction
-            const clawbackInstruction = this.client.getClawbackInstruction({
-                distributor: params.distributor,
-                from: distributorAccount.data.tokenVault,
-                to: distributorAccount.data.clawbackReceiver,
-                claimant: claimantSigner,
-                tokenProgram: TOKEN_PROGRAM_ADDRESS,
-                systemProgram: SYSTEM_PROGRAM_ADDRESS,
-            }, { programAddress: this.getProgramId() });
-            return clawbackInstruction;
-        }
-        catch (err) {
-            this.sdk.logger.error(`Failed to create clawback instruction: ${err}`);
-            throw err;
-        }
-    }
-}

package/dist/programs/StakeProgram.d.ts

@@ -1,29 +0,0 @@
-import { BaseProgram } from './BaseProgram.js';
-import { Address, Account } from 'gill';
-import { NosanaClient } from '../index.js';
-import * as programClient from '../generated_clients/staking/index.js';
-import { ConvertTypesForDb } from '../utils/index.js';
-export type Stake = ConvertTypesForDb<programClient.StakeAccountArgs> & {
-    address: Address;
-};
-export declare class StakeProgram extends BaseProgram {
-    readonly client: typeof programClient;
-    constructor(sdk: NosanaClient);
-    protected getProgramId(): Address;
-    /**
-     * Fetch a stake account by address
-     */
-    get(addr: Address): Promise<Stake>;
-    /**
-     * Fetch multiple stake accounts by address
-     */
-    multiple(addresses: Address[]): Promise<Stake[]>;
-    /**
-     * Fetch all stake accounts
-     */
-    all(): Promise<Stake[]>;
-    /**
-     * Transform stake account to include address and convert BigInt to numbers
-     */
-    transformStakeAccount(stakeAccount: Account<programClient.StakeAccount>): Stake;
-}

package/dist/programs/StakeProgram.js

@@ -1,91 +0,0 @@
-import { BaseProgram } from './BaseProgram.js';
-import { parseBase64RpcAccount } from 'gill';
-import * as programClient from '../generated_clients/staking/index.js';
-import { convertBigIntToNumber } from '../utils/index.js';
-import bs58 from 'bs58';
-export class StakeProgram extends BaseProgram {
-    constructor(sdk) {
-        super(sdk);
-        this.client = programClient;
-    }
-    getProgramId() {
-        return this.sdk.config.programs.stakeAddress;
-    }
-    /**
-     * Fetch a stake account by address
-     */
-    async get(addr) {
-        try {
-            const stakeAccount = await this.client.fetchStakeAccount(this.sdk.solana.rpc, addr);
-            const stake = this.transformStakeAccount(stakeAccount);
-            return stake;
-        }
-        catch (err) {
-            this.sdk.logger.error(`Failed to fetch stake ${err}`);
-            throw err;
-        }
-    }
-    /**
-     * Fetch multiple stake accounts by address
-     */
-    async multiple(addresses) {
-        try {
-            const stakeAccounts = await this.client.fetchAllStakeAccount(this.sdk.solana.rpc, addresses);
-            const stakes = stakeAccounts.map((stakeAccount) => this.transformStakeAccount(stakeAccount));
-            return stakes;
-        }
-        catch (err) {
-            this.sdk.logger.error(`Failed to fetch stakes ${err}`);
-            throw err;
-        }
-    }
-    /**
-     * Fetch all stake 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.STAKE_ACCOUNT_DISCRIMINATOR)),
-                            encoding: 'base58',
-                        },
-                    },
-                ],
-            })
-                .send();
-            const stakes = getProgramAccountsResponse
-                .map((result) => {
-                try {
-                    const stakeAccount = programClient.decodeStakeAccount(parseBase64RpcAccount(result.pubkey, result.account));
-                    return this.transformStakeAccount(stakeAccount);
-                }
-                catch (err) {
-                    this.sdk.logger.error(`Failed to decode stake ${err}`);
-                    return null;
-                }
-            })
-                .filter((account) => account !== null);
-            return stakes;
-        }
-        catch (err) {
-            this.sdk.logger.error(`Failed to fetch all stakes ${err}`);
-            throw err;
-        }
-    }
-    /**
-     * Transform stake account to include address and convert BigInt to numbers
-     */
-    transformStakeAccount(stakeAccount) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { discriminator: _, ...stakeAccountData } = stakeAccount.data;
-        return {
-            address: stakeAccount.address,
-            ...convertBigIntToNumber(stakeAccountData),
-        };
-    }
-}

package/dist/services/NosService.d.ts

@@ -1,48 +0,0 @@
-import { Address } from 'gill';
-import { NosanaClient } from '../index.js';
-export interface TokenAccount {
-    pubkey: Address;
-    owner: Address;
-    mint: Address;
-    amount: bigint;
-    decimals: number;
-}
-export interface TokenAccountWithBalance extends TokenAccount {
-    uiAmount: number;
-}
-export declare class NosService {
-    private readonly sdk;
-    constructor(sdk: NosanaClient);
-    /**
-     * Get the NOS token mint address for the current network
-     */
-    private getNosTokenMint;
-    /**
-     * Retrieve all token accounts for all NOS token holders
-     * Uses a single RPC call to fetch all accounts holding the NOS token
-     *
-     * @param options - Optional configuration
-     * @param options.includeZeroBalance - Whether to include accounts with zero balance (default: false)
-     * @param options.excludePdaAccounts - Whether to exclude PDA (Program Derived Address) accounts owned by smart contracts (default: false)
-     * @returns Array of token accounts with their balances
-     */
-    getAllTokenHolders(options?: {
-        includeZeroBalance?: boolean;
-        excludePdaAccounts?: boolean;
-    }): Promise<TokenAccountWithBalance[]>;
-    /**
-     * Retrieve the NOS token account for a specific owner address
-     *
-     * @param owner - The owner address to query
-     * @returns The token account with balance, or null if no account exists
-     */
-    getTokenAccountForAddress(owner: string | Address): Promise<TokenAccountWithBalance | null>;
-    /**
-     * Get the NOS token balance for a specific owner address
-     * Convenience method that returns just the balance
-     *
-     * @param owner - The owner address to query
-     * @returns The token balance as a UI amount (with decimals), or 0 if no account exists
-     */
-    getBalance(owner: string | Address): Promise<number>;
-}

package/dist/services/NosService.js

@@ -1,139 +0,0 @@
-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 {
-    constructor(sdk) {
-        this.sdk = sdk;
-    }
-    /**
-     * Get the NOS token mint address for the current network
-     */
-    getNosTokenMint() {
-        return this.sdk.config.programs.nosTokenAddress;
-    }
-    /**
-     * Retrieve all token accounts for all NOS token holders
-     * Uses a single RPC call to fetch all accounts holding the NOS token
-     *
-     * @param options - Optional configuration
-     * @param options.includeZeroBalance - Whether to include accounts with zero balance (default: false)
-     * @param options.excludePdaAccounts - Whether to exclude PDA (Program Derived Address) accounts owned by smart contracts (default: false)
-     * @returns Array of token accounts with their balances
-     */
-    async getAllTokenHolders(options) {
-        try {
-            const nosMint = this.getNosTokenMint();
-            this.sdk.logger.debug(`Fetching all NOS token holders for mint: ${nosMint}`);
-            // Use getProgramAccounts to fetch all token accounts for the NOS mint
-            const accounts = await this.sdk.solana.rpc
-                .getProgramAccounts(TOKEN_PROGRAM_ADDRESS, {
-                encoding: 'jsonParsed',
-                filters: [
-                    {
-                        dataSize: BigInt(TOKEN_ACCOUNT_SIZE),
-                    },
-                    {
-                        memcmp: {
-                            offset: BigInt(MINT_OFFSET),
-                            bytes: nosMint.toString(),
-                            encoding: 'base58',
-                        },
-                    },
-                ],
-            })
-                .send();
-            this.sdk.logger.info(`Found ${accounts.length} NOS token accounts`);
-            // Parse the response
-            const allAccounts = accounts.map((accountInfo) => {
-                const parsed = accountInfo.account.data.parsed.info;
-                return {
-                    pubkey: accountInfo.pubkey,
-                    owner: parsed.owner,
-                    mint: parsed.mint,
-                    amount: BigInt(parsed.tokenAmount.amount),
-                    decimals: parsed.tokenAmount.decimals,
-                    uiAmount: parsed.tokenAmount.uiAmount ?? 0,
-                };
-            });
-            // Apply filters
-            const includeZeroBalance = options?.includeZeroBalance ?? false;
-            const excludePdaAccounts = options?.excludePdaAccounts ?? false;
-            let filteredAccounts = allAccounts;
-            // Filter out zero balance accounts unless explicitly included
-            if (!includeZeroBalance) {
-                filteredAccounts = filteredAccounts.filter((account) => account.uiAmount > 0);
-            }
-            // Filter out PDA accounts (where token account equals owner, indicating smart contract ownership)
-            if (excludePdaAccounts) {
-                const beforePdaFilter = filteredAccounts.length;
-                filteredAccounts = filteredAccounts.filter((account) => account.pubkey !== account.owner);
-                const pdaCount = beforePdaFilter - filteredAccounts.length;
-                this.sdk.logger.debug(`Filtered out ${pdaCount} PDA accounts`);
-            }
-            const filterInfo = [];
-            if (!includeZeroBalance)
-                filterInfo.push('excluding zero balances');
-            if (excludePdaAccounts)
-                filterInfo.push('excluding PDA accounts');
-            const filterText = filterInfo.length > 0 ? ` (${filterInfo.join(', ')})` : '';
-            this.sdk.logger.info(`Returning ${filteredAccounts.length} NOS token holders${filterText}`);
-            return filteredAccounts;
-        }
-        catch (error) {
-            this.sdk.logger.error(`Failed to fetch NOS token holders: ${error}`);
-            throw new NosanaError('Failed to fetch NOS token holders', ErrorCodes.RPC_ERROR, error);
-        }
-    }
-    /**
-     * Retrieve the NOS token account for a specific owner address
-     *
-     * @param owner - The owner address to query
-     * @returns The token account with balance, or null if no account exists
-     */
-    async getTokenAccountForAddress(owner) {
-        try {
-            const ownerAddr = typeof owner === 'string' ? address(owner) : owner;
-            const nosMint = this.getNosTokenMint();
-            this.sdk.logger.debug(`Fetching NOS token account for owner: ${ownerAddr}`);
-            // Use getTokenAccountsByOwner to fetch token accounts for this owner filtered by NOS mint
-            const response = await this.sdk.solana.rpc
-                .getTokenAccountsByOwner(ownerAddr, { mint: nosMint }, { encoding: 'jsonParsed' })
-                .send();
-            if (response.value.length === 0) {
-                this.sdk.logger.debug(`No NOS token account found for owner: ${ownerAddr}`);
-                return null;
-            }
-            // Typically there should only be one token account per owner per mint
-            const accountInfo = response.value[0];
-            const parsed = accountInfo.account.data.parsed.info;
-            this.sdk.logger.info(`Found NOS token account for owner ${ownerAddr}: balance = ${parsed.tokenAmount.uiAmount}`);
-            return {
-                pubkey: accountInfo.pubkey,
-                owner: parsed.owner,
-                mint: parsed.mint,
-                amount: BigInt(parsed.tokenAmount.amount),
-                decimals: parsed.tokenAmount.decimals,
-                uiAmount: parsed.tokenAmount.uiAmount ?? 0,
-            };
-        }
-        catch (error) {
-            this.sdk.logger.error(`Failed to fetch NOS token account for owner: ${error}`);
-            throw new NosanaError('Failed to fetch NOS token account', ErrorCodes.RPC_ERROR, error);
-        }
-    }
-    /**
-     * Get the NOS token balance for a specific owner address
-     * Convenience method that returns just the balance
-     *
-     * @param owner - The owner address to query
-     * @returns The token balance as a UI amount (with decimals), or 0 if no account exists
-     */
-    async getBalance(owner) {
-        const account = await this.getTokenAccountForAddress(owner);
-        return account ? account.uiAmount : 0;
-    }
-}

package/dist/utils/walletConverter.d.ts

@@ -1,9 +0,0 @@
-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>;