@nosana/kit/dist/services/token/TokenService.d.ts

Nosana KIT

import { Address, Instruction, TransactionSigner } from '@solana/kit';
import { Logger } from '../../logger/Logger.js';
import { Wallet } from '../../types.js';
export interface TokenAccount {
    pubkey: Address;
    owner: Address;
    mint: Address;
    amount: bigint;
    decimals: number;
}
export interface TokenAccountWithBalance extends TokenAccount {
    uiAmount: number;
}
import type { SolanaService } from '../solana/index.js';
/**
 * Dependencies for TokenService
 * @group @nosana/kit
 */
export interface TokenServiceDeps {
    logger: Logger;
    solana: SolanaService;
    getWallet: () => Wallet | undefined;
}
/**
 * Config for TokenService
 * @group @nosana/kit
 */
export interface TokenServiceConfig {
    tokenAddress: Address;
}
/**
 * TokenService interface
 * @group @nosana/kit
 */
export interface TokenService {
    getAllTokenHolders(options?: {
        includeZeroBalance?: boolean;
        excludePdaAccounts?: boolean;
    }): Promise<TokenAccountWithBalance[]>;
    getTokenAccountForAddress(owner: string | Address): Promise<TokenAccountWithBalance | null>;
    getBalance(owner?: string | Address): Promise<number>;
    /**
     * Get the associated token account address for a given owner.
     *
     * @param owner The owner address
     * @returns The associated token account address
     */
    getATA(owner: Address | string): Promise<Address>;
    /**
     * Get instruction(s) to transfer SPL tokens from one address to another.
     * May return 1 or 2 instructions depending on whether the recipient's associated token account needs to be created.
     *
     * @param params Transfer parameters
     * @param params.to Recipient address
     * @param params.amount Amount in token base units (number or bigint)
     * @param params.from Optional sender TransactionSigner. If not provided, uses wallet from client.
     * @param params.payerForATA Optional payer for creating the recipient's ATA. Can be a TransactionSigner
     *                           (for full signing) or an Address (for deferred signing scenarios where the
     *                           payer signs later, e.g., as the transaction fee payer).
     *                           If not provided, uses the sender as the ATA payer.
     * @returns Array of instructions (create ATA instruction if needed, then transfer instruction)
     */
    transfer(params: {
        to: Address | string;
        amount: number | bigint;
        from?: TransactionSigner;
        payerForATA?: TransactionSigner | Address | string;
    }): Promise<Instruction[]>;
}
/**
 * Creates a TokenService instance.
 */
export declare function createTokenService(deps: TokenServiceDeps, config: TokenServiceConfig): TokenService;
//# sourceMappingURL=TokenService.d.ts.map