kiban-agent-kit/dist/tools/dexscreener/get_token_data.js

Open-source framework connecting AI agents to Katana ecosystem protocols

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SearchTokenByTickerTool = exports.GetTokenDataTool = void 0;
const tools_1 = require("@langchain/core/tools");
const axios_1 = __importDefault(require("axios"));
const zod_1 = require("zod");
const DEXSCREENER_API = "https://api.dexscreener.com/latest/dex";
class GetTokenDataTool extends tools_1.StructuredTool {
    constructor() {
        super(...arguments);
        this.name = "get_token_data";
        this.description = "Get token price and market data from DexScreener using a token address";
        this.schema = zod_1.z.object({
            tokenAddress: zod_1.z.string().describe("The token contract address to look up"),
        });
    }
    async _call(input) {
        try {
            const response = await axios_1.default.get(`${DEXSCREENER_API}/tokens/${input.tokenAddress}`);
            if (!response.data.pairs || response.data.pairs.length === 0) {
                return "No data found for this token";
            }
            const pair = response.data.pairs[0];
            const tokenData = {
                name: pair.baseToken.name,
                symbol: pair.baseToken.symbol,
                address: pair.baseToken.address,
                priceUsd: pair.priceUsd || "N/A",
                volume24h: pair.volume.h24 || "N/A",
                liquidity: pair.liquidity.usd || "N/A",
                pairAddress: pair.pairAddress,
            };
            return JSON.stringify({
                name: tokenData.name,
                symbol: tokenData.symbol,
                address: tokenData.address,
                price_usd: tokenData.priceUsd,
                volume_24h: tokenData.volume24h,
                liquidity: tokenData.liquidity,
                pair_address: tokenData.pairAddress,
            }, null, 2);
        }
        catch (error) {
            return `Error fetching token data: ${error.message}`;
        }
    }
}
exports.GetTokenDataTool = GetTokenDataTool;
class SearchTokenByTickerTool extends tools_1.StructuredTool {
    constructor() {
        super(...arguments);
        this.name = "search_token_by_ticker";
        this.description = "Search for a token on DexScreener using its ticker symbol (e.g., 'ETH', 'USDC')";
        this.schema = zod_1.z.object({
            ticker: zod_1.z.string().describe("The token ticker/symbol to search for"),
        });
    }
    async _call(input) {
        try {
            const response = await axios_1.default.get(`${DEXSCREENER_API}/search?q=${input.ticker}`);
            if (!response.data.pairs || response.data.pairs.length === 0) {
                return "No tokens found matching this ticker";
            }
            // Sort pairs by volume and get top 3
            const topPairs = response.data.pairs
                .sort((a, b) => Number(b.volume.h24) - Number(a.volume.h24))
                .slice(0, 3);
            const results = topPairs.map((pair) => ({
                name: pair.baseToken.name,
                symbol: pair.baseToken.symbol,
                address: pair.baseToken.address,
                chain: pair.chainId,
                price_usd: pair.priceUsd || "N/A",
                volume_24h: pair.volume.h24 || "N/A",
                liquidity: pair.liquidity.usd || "N/A",
                dex: pair.dexId,
            }));
            return JSON.stringify({
                message: `Found ${topPairs.length} top pairs for ${input.ticker}`,
                results,
            }, null, 2);
        }
        catch (error) {
            return `Error searching for token: ${error.message}`;
        }
    }
}
exports.SearchTokenByTickerTool = SearchTokenByTickerTool;