interface TokenInfo { name: string; symbol: string; mint: string; uri?: string; decimals: number; description?: string; image?: string; hasFileMetaData?: boolean; strictSocials?: { twitter?: string; telegram?: string; discord?: string; website?: string; }; showName?: boolean; twitter?: string; telegram?: string; website?: string; discord?: string; createdOn?: string; creation?: { creator: string; created_tx: string; created_time: number; }; [key: string]: any; } interface TokenSecurity { freezeAuthority: string | null; mintAuthority: string | null; } interface TokenPoolTxns { buys: number; sells: number; total: number; volume: number; volume24h: number; } interface TokenValuePair { quote: number; usd: number; } interface LaunchpadLiquidity { amount: number; usd: number; } interface Launchpad { name: string; url: string; logo: string; baseLiquidity: LaunchpadLiquidity; quoteLiquidity: LaunchpadLiquidity; } interface MeteoraCurveLiquidity { base?: number; quote?: number; usd: number; } interface MeteoraCurve { baseLiquidity: MeteoraCurveLiquidity; quoteLiquidity: MeteoraCurveLiquidity; fee: number; name?: string; url?: string; logo?: string; } /** Exact wallet entry returned on the Data API wire. */ interface RiskWalletWire { /** Wallet public key */ wallet: string; /** Token balance held by this wallet (UI amount) */ balance: number; /** Percent of supply held by this wallet */ percentage: number; } /** SDK-normalized risk wallet with the legacy `address` alias. */ interface RiskWallet { /** * Correct wire field. Optional in this compatibility type so 0.3.x object * literals containing only `address` continue to compile. SDK responses * always populate it; use `RiskWalletWire` for the exact wire shape. */ wallet?: string; /** * @deprecated Use `wallet`. Retained as a normalized SDK alias for 0.3.x * compatibility; the Data API wire response uses `wallet`. */ address: string; balance: number; percentage: number; } interface RiskCategory { count: number; totalBalance: number; totalPercentage: number; wallets: RiskWallet[]; } interface BundlerWallet { wallet: string; initialBalance: number; initialPercentage: number; balance: number; percentage: number; bundleTime: number; } interface BundlersCategory { count: number; totalBalance: number; totalPercentage: number; totalInitialBalance: number; totalInitialPercentage: number; wallets: BundlerWallet[]; } interface BundlersResponse { total: number; balance: number; percentage: number; initialBalance: number; initialPercentage: number; wallets: BundlerWallet[]; } interface MultiTokensResponse { tokens: { [tokenAddress: string]: TokenDetailResponse; }; } interface PoolInfo { poolId: string; liquidity: TokenValuePair; price: TokenValuePair; tokenSupply: number; lpBurn: number; tokenAddress: string; marketCap: TokenValuePair; market: string; quoteToken: string; decimals: number; security: TokenSecurity; lastUpdated: number; deployer?: string; txns?: TokenPoolTxns; curvePercentage?: number; curve?: string; createdAt?: number; bundleId?: string; launchpad?: Launchpad; meteoraCurve?: MeteoraCurve; raydium?: { baseLiquidity: number; quoteLiquidity: number; }; heaven?: { baseLiquidity: number; quoteLiquidity: number; is_migrated: boolean; migrationTime?: number; }; pumpfun?: { tokenProgram?: string; isMayhemMode?: boolean; }; 'pumpfun-amm'?: { tokenProgram?: string; isMayhemMode?: boolean; }; /** Pool creation data - only present on new/graduated pool messages */ creation?: { creator: string; created_tx: string; created_time: number; }; } interface PriceChangeData { priceChangePercentage: number; } interface TokenEvents { "1m"?: PriceChangeData; "5m"?: PriceChangeData; "15m"?: PriceChangeData; "30m"?: PriceChangeData; "1h"?: PriceChangeData; "2h"?: PriceChangeData; "3h"?: PriceChangeData; "4h"?: PriceChangeData; "5h"?: PriceChangeData; "6h"?: PriceChangeData; "12h"?: PriceChangeData; "24h"?: PriceChangeData; } interface DevHolding { percentage: number; amount: number; } interface RiskFees { jito?: number; network?: number; bloom?: number; maestro?: number; soltradingbot?: number; bullx?: number; photon?: number; trojan?: number; padre?: number; nextblock?: number; totalTrading?: number; totalTips?: number; total?: number; [key: string]: number | undefined; } interface TokenRisk { snipers: RiskCategory; insiders: RiskCategory; /** * The wire response may omit this summary. The SDK normalizes omission to an * empty category for 0.3.x compatibility; use the dedicated bundlers endpoint * for a complete list. */ bundlers: BundlersCategory; top10: number; dev: DevHolding; fees?: RiskFees; rugged: boolean; risks: TokenRiskFactor[]; score: number; jupiterVerified?: boolean; } interface TokenRiskFactor { name: string; description: string; value?: string | number; level: "warning" | "danger"; score: number; } interface TokenDetailResponse { token: TokenInfo; pools: PoolInfo[]; events: TokenEvents; risk: TokenRisk; buys: number; sells: number; txns: number; holders?: number; } interface Holder { wallet: string; amount: number; value: TokenValuePair; percentage: number; } interface TopHolder { address: string; amount: number; percentage: number; value: TokenValuePair; } /** * Flat per-token PnL returned in `/tokens/:tokenAddress/holders?enrich=walletPnl`. * * Distinct from the nested `PnlV2Position` shape: holder enrichment uses flat * field names (`buys`/`sells`, `totalBought`/`totalSold`, `avgBuy`/`avgSell`) * for backwards compatibility. */ interface EnrichedTokenPnl { realized: number | null; unrealized: number | null; total: number | null; invested: number | null; proceeds: number | null; buys: number; sells: number; totalTrades: number; roi: number | null; /** Current token balance (native units). */ balance: number | null; /** Cost basis of remaining held tokens (USD). */ costBasis: number | null; /** Current USD value of held tokens. */ value: number | null; /** Current token price (USD). */ price: number | null; /** Total tokens purchased (native units). */ totalBought: number | null; /** Total tokens sold (native units). */ totalSold: number | null; /** Average buy size (USD). */ avgBuy: number | null; /** Average sell size (USD). */ avgSell: number | null; /** Average cost per token (USD). */ avgCost?: number | null; /** Unix ms. */ firstBuy: number | null; /** Unix ms. */ lastBuy: number | null; /** Unix ms. */ firstSell: number | null; /** Unix ms. */ lastSell: number | null; /** Unix ms. */ firstTrade: number | null; /** Unix ms. */ lastTrade: number | null; /** Hold duration in seconds. */ holdTimeSecs: number | null; } interface TokenHoldersResponse { total: number; enrich?: string[]; accounts: (Holder & { pnl?: { wallet?: PnlV2WalletLifetimePnl; token?: EnrichedTokenPnl; }; identity?: PnlV2Identity | null; })[]; } interface AthPrice { highest_price: number; highest_market_cap: number; timestamp: number; pool_id: string; } interface DeployerToken { name: string; symbol: string; mint: string; image?: string; decimals: number; hasSocials: boolean; poolAddress?: string; liquidityUsd: number; marketCapUsd: number; priceUsd: number; lpBurn: number; market: string; freezeAuthority: string | null; mintAuthority: string | null; createdAt: number; lastUpdated: number; buys: number; sells: number; totalTransactions: number; } interface DeployerTokensResponse { total: number; tokens: T[]; } /** * Parameters for the deployer endpoint (/deployer/:wallet) */ interface DeployerParams { /** Page number (default: 1) */ page?: number; /** Number of items per page (default: 250, max: 500, max: 100 when format=full) */ limit?: number; /** Filter by market(s) - single value or array (e.g., 'raydium' or ['raydium', 'orca', 'pumpfun']) */ market?: string | string[]; /** Filter by launchpad(s) - single value or array (e.g., 'pumpfun' or ['pumpfun', 'boop']) */ launchpad?: string | string[]; /** Return full token objects (same shape as /tokens/:token). Max limit is capped at 100. */ format?: 'full'; } interface SearchParams { query?: string; symbol?: string; page?: number; limit?: number; cursor?: string; sortBy?: string; sortOrder?: string; showAllPools?: boolean; showPriceChanges?: boolean; minCreatedAt?: number; maxCreatedAt?: number; minLiquidity?: number; maxLiquidity?: number; minMarketCap?: number; maxMarketCap?: number; minVolume?: number; maxVolume?: number; volumeTimeframe?: string; minVolume_5m?: number; maxVolume_5m?: number; minVolume_15m?: number; maxVolume_15m?: number; minVolume_30m?: number; maxVolume_30m?: number; minVolume_1h?: number; maxVolume_1h?: number; minVolume_6h?: number; maxVolume_6h?: number; minVolume_12h?: number; maxVolume_12h?: number; minVolume_24h?: number; maxVolume_24h?: number; minBuys?: number; maxBuys?: number; minSells?: number; maxSells?: number; minTotalTransactions?: number; maxTotalTransactions?: number; minHolders?: number; maxHolders?: number; minTop10?: number; maxTop10?: number; minDev?: number; maxDev?: number; minInsiders?: number; maxInsiders?: number; minSnipers?: number; maxSnipers?: number; lpBurn?: number; /** Filter by market(s) - single value or array (e.g., 'raydium' or ['raydium', 'orca', 'pumpfun']) */ market?: string | string[]; freezeAuthority?: string; mintAuthority?: string; deployer?: string; creator?: string; status?: string; minCurvePercentage?: number; maxCurvePercentage?: number; twitter?: string; telegram?: string; discord?: string; website?: string; facebook?: string; instagram?: string; youtube?: string; reddit?: string; tiktok?: string; github?: string; minBundlers?: number; maxBundlers?: number; minBundlerPercentage?: number; maxBundlerPercentage?: number; minRiskScore?: number; maxRiskScore?: number; minFeesTotal?: number; maxFeesTotal?: number; minFeesTrading?: number; maxFeesTrading?: number; minFeesTips?: number; maxFeesTips?: number; hasImage?: boolean; image?: string; hasSocials?: boolean; /** When `true`, only tokens with at least one monitored community message. When `false`, only tokens with zero messages. */ hasCoinCommunity?: boolean; /** Minimum live community message count (inclusive). */ minCommunityMessages?: number; /** Maximum live community message count (inclusive). */ maxCommunityMessages?: number; /** Filter by launchpad(s) - single value or array (e.g., 'pumpfun' or ['pumpfun', 'boop']) */ launchpad?: string | string[]; minGraduatedAt?: number; maxGraduatedAt?: number; /** Return full token objects (same shape as /tokens/:token). Max limit is capped at 100. */ format?: 'full'; [key: string]: string | number | boolean | string[] | undefined; } interface SearchResult { id: string; name: string; symbol: string; mint: string; image?: string; decimals: number; hasSocials: boolean; poolAddress: string; liquidityUsd: number; marketCapUsd: number; priceUsd: number; lpBurn: number; market: string; quoteToken: string; freezeAuthority: string | null; mintAuthority: string | null; deployer: string; status: string; createdAt: number; lastUpdated: number; holders: number; buys: number; sells: number; totalTransactions: number; volume: number; volume_5m: number; volume_15m: number; volume_30m: number; volume_1h: number; volume_6h: number; volume_12h: number; volume_24h: number; jupiter?: boolean; verified?: boolean; top10?: number; dev?: number; insiders?: number; snipers?: number; bundlers?: { count: number; balance: number; percentage: number; }; riskScore?: number; socials?: { twitter?: string; telegram?: string; discord?: string; website?: string; facebook?: string; instagram?: string; youtube?: string; reddit?: string; tiktok?: string; github?: string; }; fees?: { total?: number; totalTrading?: number; totalTips?: number; }; tokenDetails?: { creator: string; tx: string; time: number; }; launchpad?: { name: string; curvePercentage?: number; }; graduatedAt?: number; /** Whether the token has monitored Coin Communities chat activity. */ hasCoinCommunity?: boolean; /** Live community message count (messages observed since the feed monitor started). */ communityMessages?: number; events?: { "1m"?: { priceChangePercentage: number; }; "5m"?: { priceChangePercentage: number; }; "15m"?: { priceChangePercentage: number; }; "30m"?: { priceChangePercentage: number; }; "1h"?: { priceChangePercentage: number; }; "2h"?: { priceChangePercentage: number; }; "3h"?: { priceChangePercentage: number; }; "4h"?: { priceChangePercentage: number; }; "5h"?: { priceChangePercentage: number; }; "6h"?: { priceChangePercentage: number; }; "12h"?: { priceChangePercentage: number; }; "24h"?: { priceChangePercentage: number; }; }; } interface SearchResponse { status: string; data: T[]; total?: number; pages?: number; page?: number; cursor?: string; nextCursor?: string; hasMore?: boolean; } interface TokenOverview { latest: TokenDetailResponse[]; graduating: TokenDetailResponse[]; graduated: TokenDetailResponse[]; } /** Price change percentage for a single timeframe (percent units, e.g. `-3.91`). */ interface PriceChangePercentage { priceChangePercentage: number; } /** * Present when `priceChanges=true` on price endpoints. * Timeframe keys may be omitted when unavailable. */ interface PriceChanges { '1m'?: PriceChangePercentage; '5m'?: PriceChangePercentage; '15m'?: PriceChangePercentage; '30m'?: PriceChangePercentage; '1h'?: PriceChangePercentage; '2h'?: PriceChangePercentage; '3h'?: PriceChangePercentage; '4h'?: PriceChangePercentage; '5h'?: PriceChangePercentage; '6h'?: PriceChangePercentage; '12h'?: PriceChangePercentage; '24h'?: PriceChangePercentage; } interface PriceData { /** Token price in USD */ price: number; /** Token price in quote units when available */ priceQuote?: number; /** Liquidity in USD */ liquidity: number; /** Market cap in USD */ marketCap: number; /** Unix timestamp in milliseconds */ lastUpdated: number; /** Present when `priceChanges=true` */ priceChanges?: PriceChanges; } interface PriceHistoryData { current: number; "3d"?: number; "5d"?: number; "7d"?: number; "14d"?: number; "30d"?: number; } interface PriceTimestampData { price: number; timestamp: number; timestamp_unix: number; pool: string; } interface PriceRangeData { token: string; price: { lowest: { price: number; time: number; }; highest: { price: number; time: number; }; }; } interface PriceChange { timeframe: string; percentage: number; } interface MultiPriceResponse { [tokenAddress: string]: PriceData; } interface WalletTokenData { address: string; balance: number; value: number; price: TokenValuePair; marketCap: TokenValuePair; liquidity: TokenValuePair; } interface WalletBasicResponse { tokens: WalletTokenData[]; total: number; totalSol: number; } interface TokenMetadata { name: string; symbol: string; image?: string; decimals: number; } interface TradeTokenInfo { address: string; amount: number; token: TokenMetadata; } interface TradeTransaction { tx: string; from?: TradeTokenInfo; to?: TradeTokenInfo; amount?: number; priceUsd?: number; volume?: number; solVolume?: number; type?: string; wallet: string; time: number; program: string; pools?: string[]; token?: { from: TradeTokenInfo; to: TradeTokenInfo; }; } /** Event selection on the four token-scoped trade history routes. */ type TradeEvents = 'trades' | 'all' | 'liquidity'; /** LP modes require an explicit opt-in; an omitted events field means swaps. */ type TradeParams = TradeQueryParams & (E extends 'trades' ? { events?: E; } : { events: E; }); interface TradeQueryParams { /** Keep scope, events and sortDirection unchanged when reusing nextCursor. */ cursor?: number | string; /** Page size: 1–500; server default: 250. */ limit?: number; sortDirection?: 'ASC' | 'DESC'; enrich?: 'identity' | 'all' | '*' | 'pool' | 'developer'; /** Adds token metadata to swaps only. */ showMeta?: boolean; /** Retained for existing API consumers. */ parseJupiter?: boolean; /** Filters swap legs; liquidity actions are retained. */ hideArb?: boolean; } interface LiquidityTokenAmount { address: string; /** Exact decimal token amount. Do not coerce to a floating-point number. */ amount: string; amountRaw: string; decimals: number; feeAmountRaw?: string; transferredAmountRaw?: string; } interface LiquidityEvent { tx: string; type: 'add_liquidity' | 'remove_liquidity'; program: string; programId: string; instruction: string; pool: string; wallet: string; /** Unix milliseconds (live events can differ from confirmed REST history). */ time: number; slot: number; amountBasis: 'transfer' | 'principal'; tokens: LiquidityTokenAmount[]; /** Present when identity enrichment is requested; unknown wallets return null. */ identity?: PnlV2Identity | null; } /** Live LP activity is provisional at processed commitment. */ interface LiquidityUpdate extends LiquidityEvent { /** Incomplete lookup; no later identity correction is sent. */ identityStatus?: 'partial'; } interface EnrichedStreamOptions { /** Subscribe to the :enriched room for current wallet identity. */ enriched?: boolean; } /** Identity fields on the opt-in history API; legacy Trade keys stay unchanged. */ interface EnrichedTrade extends Trade { identity?: PnlV2Identity | null; } type TradeEvent = EnrichedTrade | LiquidityEvent; type TradeEventFor = E extends 'liquidity' ? LiquidityEvent : E extends 'all' ? TradeEvent : EnrichedTrade; /** Legacy swaps-only response. Retains the 0.4 numeric cursor type. */ interface TradesResponse { trades: Trade[]; nextCursor?: number; hasNextPage?: boolean; } /** Exact history response used by the opt-in trade history methods. */ interface TradeHistoryResponse { trades: T[]; /** Timestamp for swaps; opaque cursor for mixed/LP feeds; null at the end. */ nextCursor?: number | string | null; hasNextPage?: boolean; sortDirection?: 'ASC' | 'DESC'; } interface WalletTradesResponse { trades: WalletTrade[]; nextCursor?: number; hasNextPage?: boolean; } interface WalletTokenDetail { token: TokenInfo; pools?: PoolInfo[]; events?: TokenEvents; risk?: TokenRisk; balance: number; value: number; } interface WalletResponse { tokens: WalletTokenDetail[]; total: number; totalSol: number; timestamp: string; } interface OHLCVData { open: number; close: number; low: number; high: number; volume: number; time: number; } interface ChartResponse { oclhv: OHLCVData[]; } interface HolderChartData { holders: number; time: number; } interface HoldersChartResponse { holders: HolderChartData[]; } interface SnipersChartData { percentage: number; time: number; } interface SnipersChartResponse { snipers: SnipersChartData[]; } interface InsidersChartData { percentage: number; time: number; } interface InsidersChartResponse { insiders: InsidersChartData[]; } interface BundlersChartData { percentage: number; time: number; } interface BundlersChartResponse { bundlers: BundlersChartData[]; } interface PnLData { holding: number; held: number; sold: number; realized: number; unrealized: number; total: number; total_sold: number; total_invested: number; average_buy_amount: number; current_value: number; cost_basis: number; sold_usd?: number; first_buy_time?: number; last_buy_time?: number; last_sell_time?: number; last_trade_time?: number; buy_transactions?: number; sell_transactions?: number; total_transactions?: number; } interface PnLSummary { realized: number; unrealized: number; total: number; totalInvested: number; averageBuyAmount: number; totalWins: number; totalLosses: number; winPercentage: number; lossPercentage: number; neutralPercentage?: number; } interface PnLResponse { tokens: { [tokenAddress: string]: PnLData; }; summary: PnLSummary; } interface TokenPnLResponse extends PnLData { } interface FirstBuyTransaction { signature: string; amount: number; volume_usd: number; time: number; } interface FirstBuyerData { wallet: string; first_buy_time: number; first_buy: FirstBuyTransaction; first_sell_time: number | null; last_transaction_time: number; held: number; sold: number; sold_usd: number; holding: number; realized: number; unrealized: number; total: number; total_invested: number; buy_transactions: number; sell_transactions: number; total_transactions: number; average_buy_amount: number; average_sell_amount: number; current_value: number; cost_basis: number; } interface TopTrader { wallet: string; summary: PnLSummary; } interface TopTradersResponse { wallets: TopTrader[]; } interface TokenStats { "1m"?: TimeframeStats; "5m"?: TimeframeStats; "15m"?: TimeframeStats; "30m"?: TimeframeStats; "1h"?: TimeframeStats; "4h"?: TimeframeStats; "24h"?: TimeframeStats; } interface TokenStatsTotal { buys: number; sells: number; total: number; volume: number; } interface WalletChartDataPoint { date: string; value: number; timestamp: number; pnlPercentage: number; } interface WalletChartPnLPeriod { value: number; percentage: number; } interface WalletChartResponse { chartData: WalletChartDataPoint[]; pnl: { '24h': WalletChartPnLPeriod; '30d': WalletChartPnLPeriod; }; } interface CreditsResponse { credits: number; } interface TradeMetadataToken { name: string; symbol: string; image?: string; decimals: number; amount: number; address: string; priceUsd: number; mint?: string; uri?: string; isMutable?: boolean; description?: string; tags?: string[]; extensions?: { website?: string; twitter?: string; telegram?: string; }; hasFileMetaData?: boolean; [key: string]: any; } interface TradeMetadata { from: TradeMetadataToken; to: TradeMetadataToken; } interface Trade { tx: string; amount: number; priceUsd: number; volume: number; volumeSol: number; type: "buy" | "sell"; wallet: string; time: number; program: string; pools: string[]; meta?: TradeMetadata; } interface WalletTrade { tx: string; from: { address: string; amount: number; token?: { name: string; symbol: string; image: string; decimals: number; price?: { usd: number; }; }; priceUsd: number; }; to: { address: string; amount: number; token?: { name: string; symbol: string; image: string; decimals: number; price?: { usd: number; }; }; priceUsd: number; }; price: { usd: number; sol?: string; }; volume: { usd: number; sol?: number; }; wallet: string; program: string; time: number; } interface EventsParams { /** Whether to decode the binary data into events array */ decode?: boolean; /** Whether to process events into statistics */ process?: boolean; /** Whether to process events asynchronously (for large datasets) */ async?: boolean; } interface TimeframeStats { buyers: number; sellers: number; volume: { buys: number; sells: number; total: number; }; transactions: number; buys: number; sells: number; wallets: number; price: number; priceChangePercentage: number; } interface TimeframeStats { buyers: number; sellers: number; volume: { buys: number; sells: number; total: number; }; transactions: number; buys: number; sells: number; wallets: number; price: number; priceChangePercentage: number; } interface ProcessedStats { '1m'?: TimeframeStats; '5m'?: TimeframeStats; '15m'?: TimeframeStats; '30m'?: TimeframeStats; '1h'?: TimeframeStats; '2h'?: TimeframeStats; '3h'?: TimeframeStats; '4h'?: TimeframeStats; '5h'?: TimeframeStats; '6h'?: TimeframeStats; '12h'?: TimeframeStats; '24h'?: TimeframeStats; } interface ProcessedEvent { wallet: string; amount: number; priceUsd: number; volume: number; type: 'buy' | 'sell'; time: number; } interface ProcessedEvent { wallet: string; amount: number; priceUsd: number; volume: number; type: 'buy' | 'sell'; time: number; } interface SubscriptionResponse { credits: number; plan: string; next_billing_date: string; status: string; } interface WalletBalanceUpdate { wallet: string; token: string; amount: number; } type PnlMode = 'strict' | 'adjusted' | 'raw'; interface PnlV2Block { realized: number | null; realizedRaw?: number | null; unrealized: number | null; total: number | null; } interface PnlV2Pagination { hasMore: boolean; nextCursor: string | null; count: number; total: number; pnlMode?: PnlMode; enrich?: string[]; } interface PnlV2IdentityBot { name: string | null; avatar: string | null; } interface PnlV2IdentityPool { program: string | null; poolAddress: string | null; tokenA?: string | null; tokenB?: string | null; } interface PnlV2IdentityDeveloper { token?: string | null; via?: string[]; pools?: string[]; creationTx?: string | null; createdAt?: number | null; tokens?: string[]; } interface PnlV2IdentityHacker { label: string | null; } interface PnlV2IdentitySpamDusting { label: string | null; } interface PnlV2IdentityExchange { name: string | null; } /** Primary `.sol` domain from Ridge (Solscan-style domain label). */ interface PnlV2IdentitySns { domain: string; } interface PnlV2Identity { /** * Display name. For SNS-only wallets this is the primary domain (e.g. `solanatracker.sol`). * When a higher-priority label exists (KOL, exchange, bot, etc.), that label keeps `name` * and the domain is still available on `sns.domain`. */ name?: string | null; twitter?: string | null; avatar?: string | null; /** Primary label type, e.g. `kol`, `sns`, `bot`, `developer`, `pool`, `exchange`. */ type?: string | null; /** All resolved labels, e.g. `['kol', 'sns']`. */ tags?: string[]; platforms?: string[]; /** Present when the wallet has a primary `.sol` domain (may coexist with other tags). */ sns?: PnlV2IdentitySns; bot?: PnlV2IdentityBot; pool?: PnlV2IdentityPool; developer?: PnlV2IdentityDeveloper; hacker?: PnlV2IdentityHacker; spamDusting?: PnlV2IdentitySpamDusting; exchange?: PnlV2IdentityExchange; } interface PnlV2WalletLifetimePnl { realized: number | null; unrealized: number | null; total: number | null; invested: number | null; proceeds: number | null; totalTrades: number; tokensTraded: number; } interface PnlV2TokenScopedPnl { token: PnlV2Block; /** * Lifetime wallet PnL summary. Only populated when the underlying response * is enriched with wallet PnL data (always on for `/v2/pnl/tokens/...` endpoints, * opt-in for `/tokens/:token/holders?enrich=walletPnl`). */ wallet?: PnlV2WalletLifetimePnl; } interface PnlV2PnlAdjustments { mode: PnlMode; invalidPnl: number | null; adjustedCorrection: number | null; } interface PnlV2TokenMeta { symbol: string | null; name: string | null; image?: string; decimals: number | null; price: number | null; snapshotPrice?: number | null; marketCap: number | null; liquidity: number | null; primaryMarket: string | null; } interface PnlV2WalletQueued { indexed: false; queued: true; message: string; } interface PnlV2Trader { wallet: string; pnl: PnlV2Block; invested: number | null; proceeds: number | null; openPositions: { cost: number | null; value: number | null; }; counts: { buys: number; sells: number; trades: number; tokensTraded: number; tokensHeldEver: number; }; averages: { buy: number | null; sell: number | null; }; tokens: { profitable: number; losing: number; closed: number; }; winRate: number | null; roi: number | null; timing: { firstTrade: number | null; lastTrade: number | null; }; updatedAt: string | null; } interface PnlV2TraderWithIdentity extends PnlV2Trader { identity: PnlV2Identity | null; } interface PnlV2PeriodTrader { wallet: string; period: { realized: number | null; volume: number | null; tradingDays: number; }; ending: { pnl: PnlV2Block; }; lastSnapshotDate: string | null; } interface PnlV2PeriodTraderWithIdentity extends PnlV2PeriodTrader { identity: PnlV2Identity | null; } interface PnlV2DayTrader { wallet: string; day: { realized: number | null; volume: number | null; cost: number | null; buys: number; sells: number; }; cumulative: { pnl: PnlV2Block; invested: number | null; proceeds: number | null; }; } interface PnlV2DayTraderWithIdentity extends PnlV2DayTrader { identity: PnlV2Identity | null; } interface PnlV2Top90dTrader { wallet: string; period: { realized: number | null; realizedRaw?: number | null; volume: number | null; tradingDays: number; roi: number | null; days?: { profitable: number; losing: number; maxSinglePnl: number | null; winRate: number | null; }; }; pnlAdjustments?: PnlV2PnlAdjustments; ending: { pnl: { realized: number | null; total: number | null; }; }; invested: number | null; proceeds: number | null; counts: { buys: number; sells: number; trades: number; tokensTraded: number; }; averages: { buy: number | null; sell: number | null; }; tokens: { profitable: number; losing: number; closed: number; }; winRate: number | null; timing: { firstTrade: number | null; lastTrade: number | null; }; lastSnapshotDate: string | null; updatedAt: string | null; identity?: PnlV2Identity | null; } interface PnlV2Holder { wallet: string; pnl: PnlV2TokenScopedPnl; identity?: PnlV2Identity | null; /** Legacy current-position snapshot. Same values as `current` (kept for compatibility). */ position: { balance: number | null; costBasis: number | null; value: number | null; price: number | null; }; /** Legacy. Same as `volume.buyUsd` / `invested`. */ buyUsd: number | null; /** Legacy. Same as `volume.sellUsd` / `proceeds`. */ sellUsd: number | null; counts: { buys: number; sells: number; total: number; }; roi: number | null; /** Total cost basis (USD spent buying). */ invested: number | null; /** Total USD received from selling. */ proceeds: number | null; volume: { tokensBought: number | null; tokensSold: number | null; buyUsd: number | null; sellUsd: number | null; }; averages: { buy: number | null; sell: number | null; }; current: { balance: number | null; costBasis: number | null; value: number | null; price: number | null; avgCost: number | null; }; /** Trade timing. All values are unix ms except `holdTimeSecs` (seconds). */ timing: { firstTrade: number | null; lastTrade: number | null; firstBuy: number | null; lastBuy: number | null; firstSell: number | null; lastSell: number | null; holdTimeSecs: number | null; }; } interface PnlV2Summary { pnl: PnlV2Block; invested: number | null; proceeds: number | null; openPositions: { cost: number | null; value: number | null; }; counts: { buys: number; sells: number; trades: number; tokensTraded: number; tokensHeldEver: number; }; averages: { buy: number | null; sell: number | null; }; roi: number | null; timing: { firstTrade: number | null; lastTrade: number | null; /** Average hold time in seconds across all positions with a first buy. */ avgHoldTimeSecs?: number | null; }; } interface PnlV2Position { token: string; pnl: PnlV2Block; invested: number | null; proceeds: number | null; roi: number | null; current: { balance: number | null; costBasis: number | null; value: number | null; price: number | null; avgCost: number | null; }; volume: { tokensBought: number | null; tokensSold: number | null; buyUsd: number | null; sellUsd: number | null; }; averages: { buy: number | null; sell: number | null; }; counts: { buys: number; sells: number; total: number; }; timing: { firstBuy: number | null; lastBuy: number | null; firstSell: number | null; lastSell: number | null; firstTrade: number | null; lastTrade: number | null; holdTimeSecs: number | null; }; meta?: PnlV2TokenMeta; portfolioPercent?: number | null; } interface PnlV2PositionWithWallet extends PnlV2Position { wallet: string; } interface PnlV2Snapshot { date: string; cumulative: { pnl: PnlV2Block; cost: number | null; proceeds: number | null; openPositions: { cost: number | null; value: number | null; }; counts: { buys: number; sells: number; tokensTraded: number; }; }; activity: { pnl: { realized: number | null; }; counts: { buys: number; sells: number; }; volume: { costUsd: number | null; total: number | null; }; averages: { buy: number | null; sell: number | null; realizedPnl: number | null; holdTimeSecs: number | null; }; }; } interface PnlV2ChartPoint { date: string; time: number; pnl: { realized: number | null; total: number | null; }; invested: number | null; proceeds: number | null; activity: { realizedPnl: number | null; buys: number; sells: number; volume: number | null; avgHoldTimeSecs: number | null; }; counts: { buys: number; sells: number; tokensTraded: number; }; } interface PnlV2KOLLeaderboardParams { sort?: 'total' | 'realized' | 'unrealized' | 'invested' | 'proceeds' | 'value' | 'trades' | 'tokens' | 'roi' | 'win_percentage' | 'last_trade'; direction?: 'asc' | 'desc'; limit?: number; cursor?: string; } interface PnlV2KOLPeriodParams { sort?: 'realized' | 'volume' | 'days' | 'ending_total'; direction?: 'asc' | 'desc'; limit?: number; cursor?: string; period?: '1d' | '7d' | '14d' | '30d' | '90d' | 'all'; start?: string; end?: string; } interface PnlV2KOLCalendarParams { year?: number; month?: number; } interface PnlV2KOLByDateParams { date?: string; } interface PnlV2TopTradersParams { sort?: 'realized' | 'volume' | 'days' | 'roi' | 'win_percentage' | 'trades' | 'tokens'; direction?: 'asc' | 'desc'; limit?: number; cursor?: string; platform?: string; excludeArbitrage?: string; pnlMode?: PnlMode; days?: number; minTrades?: number; minInvested?: number; minDays?: number; minWinRate?: number; minRoi?: number; minClosedTokens?: number; maxSingleTokenPct?: number; } interface PnlV2TokenTradersParams { sort?: 'holding' | 'value' | 'pnl' | 'realized' | 'unrealized' | 'invested' | 'roi' | 'last_trade' | 'first_trade'; direction?: 'asc' | 'desc'; limit?: number; cursor?: string; platform?: string; excludeArbitrage?: string; excludeZeroBuys?: string; activeOnly?: string; minTrades?: number; } interface PnlV2TokenFirstBuyersParams { sort?: 'first_trade'; direction?: 'asc'; limit?: number; cursor?: string; platform?: string; excludeArbitrage?: string; excludeZeroBuys?: string; activeOnly?: string; minTrades?: number; } interface PnlV2WalletHistoryParams { period?: '1d' | '7d' | '14d' | '30d' | '90d' | 'all'; start?: string; end?: string; limit?: number; /** * Denomination for monetary fields. Defaults to `usd`. * Pass `sol` or `eur` to convert USD snapshot values at read time. * Historical endpoints use the daily rate for each snapshot date. * Counts, percentages, timestamps, and ROI are not converted. */ currency?: 'usd' | 'sol' | 'eur'; } interface PnlV2WalletPerformanceParams { period?: '1d' | '7d' | '14d' | '30d' | '90d' | 'all'; days?: number; /** * Denomination for monetary fields. Defaults to `usd`. * Pass `sol` or `eur` to convert USD snapshot values at read time. * Counts, percentages, timestamps, and ROI are not converted. */ currency?: 'usd' | 'sol' | 'eur'; } interface PnlV2WalletPositionsParams { sort?: 'last_trade' | 'pnl' | 'realized' | 'unrealized' | 'roi' | 'value' | 'holding' | 'invested' | 'cost' | 'proceeds' | 'buys' | 'sells'; direction?: 'asc' | 'desc'; cursor?: string; limit?: number; filter?: 'all' | 'holding' | 'active' | 'sold' | 'profitable' | 'losing'; period?: '1d' | '7d' | '14d' | '30d' | '90d' | 'all'; pnlMode?: PnlMode; tokens?: string; minValue?: number; maxValue?: number; minPnl?: number; maxPnl?: number; minInvested?: number; maxInvested?: number; minRoi?: number; maxRoi?: number; minTrades?: number; minHolding?: number; market?: string; minLiquidity?: number; minMarketCap?: number; } interface PnlV2WalletChartParams { time_from?: number; time_to?: number; } interface PnlV2WalletOverviewParams { pnlMode?: PnlMode; /** * Denomination for monetary fields. Defaults to `usd`. * Pass `sol` or `eur` to convert USD snapshot values at read time using current spot. * Counts, percentages, timestamps, and ROI are not converted. */ currency?: 'usd' | 'sol' | 'eur'; } interface PnlV2WalletTokenPositionParams { pnlMode?: PnlMode; } interface PnlV2BatchParams { pnlMode?: PnlMode; } interface PnlV2KOLLeaderboardResponse { traders: PnlV2TraderWithIdentity[]; pagination: PnlV2Pagination; } interface PnlV2KOLPeriodResponse { traders: PnlV2PeriodTraderWithIdentity[]; pagination: PnlV2Pagination; } interface PnlV2KOLCalendarDayData { realizedPnl: number | null; volume: number | null; buys: number; sells: number; traders: number; } interface PnlV2KOLCalendarResponse { year: number; month: number; days: { [day: string]: PnlV2KOLCalendarDayData; }; summary: { tradingDays: number; positiveDays: number; negativeDays: number; totalRealizedPnl: number | null; totalVolume: number | null; }; } interface PnlV2KOLByDateResponse { traders: PnlV2DayTraderWithIdentity[]; summary: { totalRealizedPnl: number | null; totalVolume: number | null; }; date: string; } interface PnlV2TopTradersResponse { traders: PnlV2Top90dTrader[]; pagination: PnlV2Pagination; } interface PnlV2TokenTradersResponse { meta: PnlV2TokenMeta; traders: PnlV2Holder[]; pagination: PnlV2Pagination; } interface PnlV2WalletTokenPositionResponse extends PnlV2Position { wallet?: string; identity?: PnlV2Identity | null; pnlMode?: PnlMode; } interface PnlV2WalletHistoryResponse { wallet?: string; identity?: PnlV2Identity | null; /** Present when a non-USD `currency` was requested (`sol` or `eur`). */ currency?: 'sol' | 'eur'; days: PnlV2Snapshot[]; summary: { days: { trading: number; positive: number; negative: number; breakEven: number; }; totals: { realizedPnl: number | null; volume: number | null; }; winRate: number | null; totalDays: number; deltas: { realized: number | null; total: number | null; } | null; }; } interface PnlV2WalletPerformanceDay { date: string; realizedPnl: number | null; unrealizedPnl: number | null; totalPnl: number | null; volume: number | null; /** Daily activity within the window (`day_buys + day_sells`), not cumulative lifetime totals. */ trades: number; } interface PnlV2WalletPerformanceResponse { wallet?: string; identity?: PnlV2Identity | null; /** Present when a non-USD `currency` was requested (`sol` or `eur`). */ currency?: 'sol' | 'eur'; window: number; totals: { realizedPnl: number | null; volume: number | null; /** Sum of daily activity trades within the window (`day_buys + day_sells`). */ trades: number; }; bestDay: { date: string; realizedPnl: number | null; volume: number | null; totalPnl: number | null; trades: number; } | null; worstDay: { date: string; realizedPnl: number | null; volume: number | null; totalPnl: number | null; trades: number; } | null; streaks: { positive: number | null; negative: number | null; currentPositive: number | null; currentNegative: number | null; }; drawdown: { /** Maximum drawdown in the response currency. */ amount: number | null; percent: number | null; }; days: PnlV2WalletPerformanceDay[]; updatedAt: string | null; } interface PnlV2WalletHighlightsResponse { wallet?: string; identity?: PnlV2Identity | null; counts: { positions: number; open: number; closed: number; }; highlights: { biggestWinner: PnlV2Position | null; biggestLoser: PnlV2Position | null; biggestBag: PnlV2Position | null; mostProfitableClosed: PnlV2Position | null; fastestFlip: PnlV2Position | null; longestHold: PnlV2Position | null; mostActive: PnlV2Position | null; }; updatedAt: string | null; } interface PnlV2WalletRiskResponse { wallet?: string; identity?: PnlV2Identity | null; openPositions: { count: number; cost: number | null; value: number | null; profitableValue: number | null; profitableValuePercent: number | null; }; concentration: { top1Percent: number | null; top5Percent: number | null; score: number | null; }; pnlMix: { realized: number | null; unrealized: number | null; realizedPercent: number | null; unrealizedPercent: number | null; }; largestPositions: PnlV2Position[]; updatedAt: string | null; } interface PnlV2WalletPositionsResponse { wallet?: string; identity?: PnlV2Identity | null; positions: PnlV2Position[]; stats: { total: number; filtered: number; holding: number; sold: number; profitable: number; losing: number; }; pagination: PnlV2Pagination; } interface PnlV2WalletChartResponse { wallet?: string; identity?: PnlV2Identity | null; points: PnlV2ChartPoint[]; summary: { days: { trading: number; positive: number; negative: number; breakEven: number; }; totals: { realizedPnl: number | null; volume: number | null; }; winRate: number | null; bestDay: { date: string; realizedPnl: number | null; } | null; worstDay: { date: string; realizedPnl: number | null; } | null; streaks: { positive: number; negative: number; currentPositive: number; currentNegative: number; }; drawdown: { amount: number | null; percent: number | null; }; averages: { dailyVolume: number | null; dailyRealizedPnl: number | null; holdTimeSecs: number | null; }; }; pagination: { count: number; hasMore: boolean; nextTimeTo: number | null; }; } interface PnlV2WalletOverviewResponse { wallet?: string; identity?: PnlV2Identity | null; pnlMode?: PnlMode; /** Present when a non-USD `currency` was requested (`sol` or `eur`). */ currency?: 'sol' | 'eur'; summary: PnlV2Summary; analysis: { winRate: number | null; avgPnlPerAsset: number | null; avgBuyValue: number | null; tokens: { closed: number; winning: number; losing: number; }; distribution: Array<{ range: string; count: number; rate: number | null; }>; }; stats: { total: number; holding: number; sold: number; profitable: number; losing: number; }; tags: { isArbitrage: boolean; platforms: string[]; }; updatedAt: string | null; } interface PnlV2BatchWalletPositionsResponse { wallet: string; identity?: PnlV2Identity | null; pnlMode?: PnlMode; count: number; positions: PnlV2Position[]; notFound: string[]; invalid?: string[]; } interface PnlV2BatchWalletSummary { wallet: string; identity?: PnlV2Identity | null; summary: PnlV2Summary; tags: { isArbitrage: boolean; platforms: string[]; }; updatedAt: string | number | null; } interface PnlV2BatchWalletSummariesResponse { count: number; wallets: PnlV2BatchWalletSummary[]; notFound?: string[]; invalid?: string[]; truncated?: { requested: number; limit: number; }; } interface PnlV2TokenScopedPositionWithWallet extends Omit { wallet: string; identity?: PnlV2Identity | null; pnl: PnlV2TokenScopedPnl; } interface PnlV2BatchTokenPositionsResponse { token: string; pnlMode?: PnlMode; count: number; positions: PnlV2TokenScopedPositionWithWallet[]; notFound: string[]; invalid?: string[]; } interface PnlV2BatchPositionPairsResponse { pnlMode?: PnlMode; count: number; positions: (PnlV2PositionWithWallet & { identity?: PnlV2Identity | null; })[]; notFound: Array<{ wallet: string; token: string; }>; invalid?: Array<{ wallet?: string; token?: string; }>; } interface ChartDataParams { /** Token address */ tokenAddress: string; /** Pool address (only for pool-specific charts) */ poolAddress?: string; /** Time interval (e.g., "1s", "1m", "1h", "1d") */ type?: string; /** Start time (Unix timestamp in seconds) */ timeFrom?: number; /** End time (Unix timestamp in seconds) */ timeTo?: number; /** Return chart for market cap instead of pricing */ marketCap?: boolean; /** Disable outlier removal if set to false (default: true) */ removeOutliers?: boolean; /** Dynamically picks the main pool over time for consistent charts (default: true, only applies without pool) */ dynamicPools?: boolean; /** Timezone for chart data - use "current" for auto-detection or specify timezone (e.g., "PST", "UTC", "America/New_York") */ timezone?: string | 'current'; /** Enable live cache for faster response times (default: false) */ fastCache?: boolean; /** Currency for price data (default: "usd") */ currency?: 'usd' | 'eur' | 'sol'; } /** * Represents a holder in the paginated response with account address */ interface PaginatedHolder { wallet: string; account: string; amount: number; value: TokenValuePair; percentage: number; } /** * Response for paginated token holders endpoint */ interface PaginatedTokenHoldersResponse { total: number; accounts: PaginatedHolder[]; cursor: string; hasMore: boolean; limit: number; } /** Status of a single DCA order. */ type DcaOrderStatus = 'active' | 'paused' | 'completed' | 'pending'; /** Status filter accepted by DCA list endpoints (adds `'all'`). */ type DcaOrderStatusFilter = DcaOrderStatus | 'all'; /** Trade direction relative to the wallet across its DCA orders. */ type DcaDirection = 'buying' | 'selling' | 'mixed'; /** Sort field accepted by DCA list endpoints. */ type DcaSort = 'volume' | 'deposited' | 'remaining' | 'progress' | 'recent' | 'created' | 'status'; /** A supported DCA program. */ interface DcaProgram { id: string; label: string; programId: string; } interface DcaProgramsResponse { programs: DcaProgram[]; } /** Token metadata embedded on a DCA order. */ interface DcaToken { mint: string; symbol: string; name: string; decimals: number; image?: string | null; uri?: string | null; description?: string | null; twitter?: string | null; website?: string | null; hasFileMetaData?: boolean; /** Current USD price; null/omitted when unavailable. */ priceUsd?: number | null; } /** Raw on-chain amounts (strings, base units). Keys depend on program. */ type DcaOrderRaw = Record; /** A single DCA (recurring) order. */ interface DcaOrder { program: string; programId: string; /** DCA account pubkey. */ address: string; owner: string; status: DcaOrderStatus; direction: DcaDirection; /** Human readable pair, e.g. "USDC → SOL". */ pair: string; input: DcaToken; output: DcaToken; deposited: number; depositedUsd?: number | null; used: number; usedUsd?: number | null; remaining: number; remainingUsd?: number | null; received: number; receivedUsd?: number | null; perCycle: number; perCycleUsd?: number | null; /** Cycle frequency, e.g. "1h". */ frequency: string; progressPercent: number; volume: number; volumeUsd?: number | null; /** ISO 8601 timestamp. */ createdAt: string; /** ISO 8601 timestamp; null when no further cycle is scheduled. */ nextCycleAt: string | null; raw: DcaOrderRaw; } /** Status counts for a wallet's DCA orders. */ interface DcaSummary { total: number; active: number; paused: number; completed: number; pending: number; } /** Pagination block returned by paginated DCA endpoints. */ interface DcaPagination { limit: number; /** Cursor to pass as `cursor` for the next page; null when no more results. */ nextCursor: string | null; hasMore: boolean; count: number; total: number; } /** Common query parameters for DCA list endpoints. */ interface DcaListParams { /** DCA program id (default `"jupiter"`). */ program?: string; /** Alias for `program`. */ dex?: string; /** Alias for `program`. */ platform?: string; /** * Page size. Defaults differ by endpoint: * - wallet / wallet orders / pair: default `50`, max `100` * - token buyers / sellers / users: default `200`, max `1000` */ limit?: number; /** Opaque cursor (the previous page's last order `address`). */ cursor?: string; sort?: DcaSort; /** Alias for `sort`. */ sortBy?: DcaSort; status?: DcaOrderStatusFilter; } /** Query parameters accepted by single-order/program endpoints. */ interface DcaProgramParams { /** DCA program id (default `"jupiter"`). */ program?: string; /** Alias for `program`. */ dex?: string; /** Alias for `program`. */ platform?: string; } /** Standard error envelope returned by DCA endpoints on failure. */ interface DcaErrorResponse { error: { code: 'INVALID_WALLET' | 'INVALID_MINT' | 'INVALID_ORDER' | 'NOT_FOUND' | 'INVALID_SORT' | 'INVALID_STATUS' | 'INVALID_LIMIT' | 'INVALID_PROGRAM' | 'PROGRAM_PARAM_CONFLICT' | 'INVALID_CURSOR' | 'TIMEOUT' | 'SERVER_ERROR'; message: string; }; } interface DcaWalletResponse { wallet: string; summary: DcaSummary; orders: DcaOrder[]; pagination: DcaPagination; } interface DcaOrdersListResponse { orders: DcaOrder[]; pagination: DcaPagination; } interface DcaTokenFlowResponse { mint: string; buyers: { count: number; volumeUsd: number | null; }; sellers: { count: number; volumeUsd: number | null; }; } interface DcaTokenOrdersResponse { mint: string; orders: DcaOrder[]; pagination: DcaPagination; } interface DcaTokenUser { wallet: string; orderCount: number; volumeUsd: number | null; } interface DcaTokenUsersResponse { mint: string; users: DcaTokenUser[]; } interface DcaPairResponse { inputMint: string; outputMint: string; pair: string; orders: DcaOrder[]; pagination: DcaPagination; } /** Map of mint address → USD price at event time. */ type DcaPricesMap = Record; /** * Order snapshot embedded on a DCA stream event. * * Position events carry the full {@link DcaOrder} shape; transaction events * (Filled, Deposit, etc.) often include only a subset of fields, so all * properties are typed as optional. */ type DcaOrderSnapshot = Partial; interface DcaEventBase { program: string; programId: string; /** DCA account address. */ address: string; owner: string; signature: string; slot: number; /** Unix ms. */ timestamp: number; eventIndex: number; dcaKey: string; /** Snapshot of the order at event time. */ order: DcaOrderSnapshot; } interface DcaOpenedEvent extends DcaEventBase { eventName: 'Opened'; openInstruction: 'openDca' | 'openDcaV2'; userKey: string; inputMint: string; outputMint: string; /** Raw deposited amount as base-units string. */ inDeposited: string; /** Cycle frequency in seconds, as string. */ cycleFrequency: string; /** Raw amount per cycle as base-units string. */ inAmountPerCycle: string; /** Created at as unix seconds string. */ createdAt: string; usd: { inDepositedUsd?: number; inAmountPerCycleUsd?: number; }; prices: DcaPricesMap; } interface DcaFilledEvent extends DcaEventBase { eventName: 'Filled'; userKey: string; inputMint: string; outputMint: string; inAmount: string; outAmount: string; feeMint: string; fee: string; fillInstruction: string; usd: { inAmountUsd?: number; outAmountUsd?: number; feeUsd?: number; }; prices: DcaPricesMap; } interface DcaClosedEvent extends DcaEventBase { eventName: 'Closed'; userKey: string; inputMint: string; outputMint: string; inDeposited: string; totalInWithdrawn: string; totalOutWithdrawn: string; unfilledAmount: string; userClosed: boolean; usd: { totalInWithdrawnUsd?: number; totalOutWithdrawnUsd?: number; unfilledAmountUsd?: number; }; prices: DcaPricesMap; } interface DcaDepositEvent extends DcaEventBase { eventName: 'Deposit'; amount: string; usd: { amountUsd?: number; }; } interface DcaWithdrawEvent extends DcaEventBase { eventName: 'Withdraw'; inAmount: string; outAmount: string; userWithdraw: boolean; usd: { inAmountUsd?: number; outAmountUsd?: number; }; } interface DcaCollectedFeeEvent extends DcaEventBase { eventName: 'CollectedFee'; userKey: string; mint: string; amount: string; usd: { amountUsd?: number; }; prices: DcaPricesMap; } /** DCA account snapshot. No transaction signature; throttled per account. */ interface DcaPositionEvent { program: string; programId: string; /** DCA account pubkey (alias of `address`). */ pubkey: string; address: string; owner: string; slot: number; /** Unix ms. */ timestamp: number; /** Account write version. */ writeVersion: number; order: DcaOrder; } /** Discriminated union over all DCA stream events. */ type DcaStreamEvent = DcaOpenedEvent | DcaFilledEvent | DcaClosedEvent | DcaDepositEvent | DcaWithdrawEvent | DcaCollectedFeeEvent | DcaPositionEvent; /** Transaction events (everything except the position snapshot). */ type DcaTransactionEvent = Exclude; /** Metric with current-window total and percent change vs the previous equal-length window. */ interface MetricWithChange { /** Value for the current window. */ total: number; /** Percent change vs the previous equal-length window. `0` when the previous window total is `0`. */ changePct: number; } /** Buy/sell split metric with percent change on `total`. */ interface SideSplitMetric { /** Total for the current window. */ total: number; /** Buy-side portion of the current window. */ buys: number; /** Sell-side portion of the current window. */ sells: number; /** Percent change of `total` vs the previous equal-length window. */ changePct: number; } interface LighthouseTimeframeStats { transactions: SideSplitMetric; /** Approximate unique trader wallets (HyperLogLog). */ wallets: MetricWithChange; /** USD volume for the window. */ volume: SideSplitMetric; tokensCreated: MetricWithChange; migrations: MetricWithChange; } interface LighthouseMarketStats { '5m': LighthouseTimeframeStats; '1h': LighthouseTimeframeStats; '6h': LighthouseTimeframeStats; '24h': LighthouseTimeframeStats; } /** One DEX, launchpad, or aggregate market row from `GET /lighthouse`. */ interface LighthouseMarket { /** Market key (e.g. `all`, `pumpfun`, `raydium-all`, `meteora-curve:bags`). */ market: string; /** Human-readable display name. */ label: string; /** Logo URL, or an empty string when unavailable. */ icon: string; /** DEX or launchpad URL, or an empty string when unavailable. */ url: string; /** Parent DEX/launchpad key for child markets. Omitted for top-level markets. */ parent?: string; stats: LighthouseMarketStats; } /** Response for `GET /lighthouse` — top-level array of markets. */ type LighthouseResponse = LighthouseMarket[]; /** Allowed minimum USD volume thresholds for whale trade feeds. */ type WhaleMinVolume = 1000 | 2500 | 5000 | 10000; /** Allowed minimum USD volume thresholds for KOL trade feeds (`0` = all eligible). */ type KolMinVolume = 0 | 1000 | 2500 | 5000 | 10000; /** KOL identity metadata when the wallet is on the shared KOL roster. */ interface TradeIdentity { name?: string | null; twitter?: string | null; avatar?: string; } interface WhaleKolTokenMetaSide { name?: string | null; symbol?: string | null; image?: string | null; decimals?: number | null; amount?: number; address?: string; priceUsd?: number | null; [key: string]: unknown; } /** A single whale or KOL trade row. */ interface WhaleKolTrade { tx: string; amount: number; priceUsd: number | null; /** USD volume at or above `$minVolume`. */ volume: number; volumeSol: number; type: 'buy' | 'sell'; wallet: string; /** Unix timestamp in milliseconds. */ time: number; program: string; pools: string[]; /** Present when the wallet is on the shared KOL roster. */ identity?: TradeIdentity; /** Present when `showMeta=true`. */ meta?: { from?: WhaleKolTokenMetaSide; to?: WhaleKolTokenMetaSide; }; } interface WhaleTradesParams { /** Minimum absolute USD volume. Allowed: `1000`, `2500`, `5000`, `10000`. Default `1000`. */ minVolume?: WhaleMinVolume; /** Opaque `nextCursor` from a previous response, or a raw millisecond timestamp. */ cursor?: string; /** Page size. Default `250`, max `500`. */ limit?: number; /** When true, attach `meta.from` / `meta.to` token metadata and historical prices. */ showMeta?: boolean; /** Keep rows where either swap side matches the selected/main token. */ hideArb?: boolean; /** Only `DESC` is supported. */ sortDirection?: 'DESC'; } interface KolTradesParams { /** Minimum absolute USD volume. Use `0` or omit for all eligible KOL trades. Default `0`. */ minVolume?: KolMinVolume; cursor?: string; limit?: number; showMeta?: boolean; /** Keep rows where either swap side matches the selected/main token. */ hideArb?: boolean; sortDirection?: 'DESC'; } /** Params for `GET /trades/kols/{token}`. */ type KolTokenTradesParams = KolTradesParams; interface WhaleKolTradesResponse { trades: WhaleKolTrade[]; /** Opaque base64url cursor for the next page. */ nextCursor: string | null; hasNextPage: boolean; sortDirection: 'DESC'; /** Echoed request filter when the effective threshold is at least $1,000. */ minVolume?: WhaleMinVolume; } export type { AthPrice, BundlerWallet, BundlersCategory, BundlersChartData, BundlersChartResponse, BundlersResponse, ChartDataParams, ChartResponse, CreditsResponse, DcaClosedEvent, DcaCollectedFeeEvent, DcaDepositEvent, DcaDirection, DcaErrorResponse, DcaFilledEvent, DcaListParams, DcaOpenedEvent, DcaOrder, DcaOrderRaw, DcaOrderSnapshot, DcaOrderStatus, DcaOrderStatusFilter, DcaOrdersListResponse, DcaPagination, DcaPairResponse, DcaPositionEvent, DcaPricesMap, DcaProgram, DcaProgramParams, DcaProgramsResponse, DcaSort, DcaStreamEvent, DcaSummary, DcaToken, DcaTokenFlowResponse, DcaTokenOrdersResponse, DcaTokenUser, DcaTokenUsersResponse, DcaTransactionEvent, DcaWalletResponse, DcaWithdrawEvent, DeployerParams, DeployerToken, DeployerTokensResponse, DevHolding, EnrichedStreamOptions, EnrichedTokenPnl, EnrichedTrade, EventsParams, FirstBuyTransaction, FirstBuyerData, Holder, HolderChartData, HoldersChartResponse, InsidersChartData, InsidersChartResponse, KolMinVolume, KolTokenTradesParams, KolTradesParams, Launchpad, LaunchpadLiquidity, LighthouseMarket, LighthouseMarketStats, LighthouseResponse, LighthouseTimeframeStats, LiquidityEvent, LiquidityTokenAmount, LiquidityUpdate, MeteoraCurve, MeteoraCurveLiquidity, MetricWithChange, MultiPriceResponse, MultiTokensResponse, OHLCVData, PaginatedHolder, PaginatedTokenHoldersResponse, PnLData, PnLResponse, PnLSummary, PnlMode, PnlV2BatchParams, PnlV2BatchPositionPairsResponse, PnlV2BatchTokenPositionsResponse, PnlV2BatchWalletPositionsResponse, PnlV2BatchWalletSummariesResponse, PnlV2BatchWalletSummary, PnlV2Block, PnlV2ChartPoint, PnlV2DayTrader, PnlV2DayTraderWithIdentity, PnlV2Holder, PnlV2Identity, PnlV2IdentityBot, PnlV2IdentityDeveloper, PnlV2IdentityExchange, PnlV2IdentityHacker, PnlV2IdentityPool, PnlV2IdentitySns, PnlV2IdentitySpamDusting, PnlV2KOLByDateParams, PnlV2KOLByDateResponse, PnlV2KOLCalendarDayData, PnlV2KOLCalendarParams, PnlV2KOLCalendarResponse, PnlV2KOLLeaderboardParams, PnlV2KOLLeaderboardResponse, PnlV2KOLPeriodParams, PnlV2KOLPeriodResponse, PnlV2Pagination, PnlV2PeriodTrader, PnlV2PeriodTraderWithIdentity, PnlV2PnlAdjustments, PnlV2Position, PnlV2PositionWithWallet, PnlV2Snapshot, PnlV2Summary, PnlV2TokenFirstBuyersParams, PnlV2TokenMeta, PnlV2TokenScopedPnl, PnlV2TokenScopedPositionWithWallet, PnlV2TokenTradersParams, PnlV2TokenTradersResponse, PnlV2Top90dTrader, PnlV2TopTradersParams, PnlV2TopTradersResponse, PnlV2Trader, PnlV2TraderWithIdentity, PnlV2WalletChartParams, PnlV2WalletChartResponse, PnlV2WalletHighlightsResponse, PnlV2WalletHistoryParams, PnlV2WalletHistoryResponse, PnlV2WalletLifetimePnl, PnlV2WalletOverviewParams, PnlV2WalletOverviewResponse, PnlV2WalletPerformanceDay, PnlV2WalletPerformanceParams, PnlV2WalletPerformanceResponse, PnlV2WalletPositionsParams, PnlV2WalletPositionsResponse, PnlV2WalletQueued, PnlV2WalletRiskResponse, PnlV2WalletTokenPositionParams, PnlV2WalletTokenPositionResponse, PoolInfo, PriceChange, PriceChangeData, PriceChangePercentage, PriceChanges, PriceData, PriceHistoryData, PriceRangeData, PriceTimestampData, ProcessedEvent, ProcessedStats, RiskCategory, RiskFees, RiskWallet, RiskWalletWire, SearchParams, SearchResponse, SearchResult, SideSplitMetric, SnipersChartData, SnipersChartResponse, SubscriptionResponse, TimeframeStats, TokenDetailResponse, TokenEvents, TokenHoldersResponse, TokenInfo, TokenMetadata, TokenOverview, TokenPnLResponse, TokenPoolTxns, TokenRisk, TokenRiskFactor, TokenSecurity, TokenStats, TokenStatsTotal, TokenValuePair, TopHolder, TopTrader, TopTradersResponse, Trade, TradeEvent, TradeEventFor, TradeEvents, TradeHistoryResponse, TradeIdentity, TradeMetadata, TradeMetadataToken, TradeParams, TradeTokenInfo, TradeTransaction, TradesResponse, WalletBalanceUpdate, WalletBasicResponse, WalletChartDataPoint, WalletChartPnLPeriod, WalletChartResponse, WalletResponse, WalletTokenData, WalletTokenDetail, WalletTrade, WalletTradesResponse, WhaleKolTokenMetaSide, WhaleKolTrade, WhaleKolTradesResponse, WhaleMinVolume, WhaleTradesParams };