borsajs 0.1.0

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "borsajs",
+    "version": "0.1.0",
+    "description": "Turkish financial markets data library - yfinance-like API for BIST stocks, forex, crypto, and more",
+    "type": "module",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsc --watch",
+        "test": "npx tsx test/demo.ts",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "finance",
+        "stocks",
+        "bist",
+        "turkey",
+        "forex",
+        "crypto",
+        "market-data",
+        "yfinance"
+    ],
+    "author": "Mesut Piskin",
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/mesutpiskin/borsajs"
+    },
+    "bugs": {
+        "url": "https://github.com/mesutpiskin/borsajs/issues"
+    },
+    "homepage": "https://github.com/mesutpiskin/borsajs#readme",
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "dependencies": {
+        "axios": "^1.6.0",
+        "cheerio": "^1.0.0-rc.12"
+    },
+    "devDependencies": {
+        "@types/node": "^20.10.0",
+        "tsx": "^4.21.0",
+        "typescript": "^5.3.0"
+    }
+}

package/src/cache.ts

@@ -0,0 +1,42 @@
+/**
+ * TTL-based in-memory cache for borsajs.
+ */
+
+interface CacheEntry<T> { value: T; expiresAt: number; }
+
+export class Cache {
+    private store: Map<string, CacheEntry<unknown>> = new Map();
+
+    get<T>(key: string): T | null {
+        const entry = this.store.get(key);
+        if (!entry) return null;
+        if (Date.now() > entry.expiresAt) { this.store.delete(key); return null; }
+        return entry.value as T;
+    }
+
+    set<T>(key: string, value: T, ttlSeconds: number): void {
+        this.store.set(key, { value, expiresAt: Date.now() + ttlSeconds * 1000 });
+    }
+
+    delete(key: string): boolean { return this.store.delete(key); }
+    clear(): void { this.store.clear(); }
+    get size(): number { return this.store.size; }
+}
+
+export const TTL = {
+    REALTIME_PRICE: 60,
+    OHLCV_HISTORY: 3600,
+    COMPANY_INFO: 3600,
+    FINANCIAL_STATEMENTS: 86400,
+    FX_RATES: 300,
+    COMPANY_LIST: 86400,
+    FUND_DATA: 3600,
+    INFLATION_DATA: 86400,
+    VIOP: 300,
+} as const;
+
+let globalCache: Cache | null = null;
+export function getCache(): Cache {
+    if (!globalCache) globalCache = new Cache();
+    return globalCache;
+}

package/src/crypto.ts

@@ -0,0 +1,30 @@
+/**
+ * Crypto class for cryptocurrency data.
+ */
+import { getBtcTurkProvider, TickerData, OHLCVData, HistoryOptions } from './providers/btcturk.js';
+
+export class Crypto {
+    private readonly _pair: string;
+    private _currentCache: TickerData | null = null;
+
+    constructor(pair: string) { this._pair = pair.toUpperCase(); }
+    get pair(): string { return this._pair; }
+    get symbol(): string { return this._pair; }
+
+    async getCurrent(): Promise<TickerData> {
+        if (!this._currentCache) this._currentCache = await getBtcTurkProvider().getTicker(this._pair);
+        return this._currentCache;
+    }
+
+    async getInfo(): Promise<TickerData> { return this.getCurrent(); }
+
+    async getHistory(options: HistoryOptions = {}): Promise<OHLCVData[]> {
+        return getBtcTurkProvider().getHistory(this._pair, options);
+    }
+
+    toString(): string { return `Crypto('${this._pair}')`; }
+}
+
+export async function cryptoPairs(quote: string = 'TRY'): Promise<string[]> {
+    return getBtcTurkProvider().getPairs(quote);
+}

package/src/exceptions.ts

@@ -0,0 +1,77 @@
+/**
+ * Custom exceptions for borsajs.
+ */
+
+export class BorsajsError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'BorsajsError';
+        Object.setPrototypeOf(this, BorsajsError.prototype);
+    }
+}
+
+export class TickerNotFoundError extends BorsajsError {
+    public readonly symbol: string;
+    constructor(symbol: string) {
+        super(`Ticker not found: ${symbol}`);
+        this.name = 'TickerNotFoundError';
+        this.symbol = symbol;
+        Object.setPrototypeOf(this, TickerNotFoundError.prototype);
+    }
+}
+
+export class DataNotAvailableError extends BorsajsError {
+    constructor(message: string = 'Data not available') {
+        super(message);
+        this.name = 'DataNotAvailableError';
+        Object.setPrototypeOf(this, DataNotAvailableError.prototype);
+    }
+}
+
+export class APIError extends BorsajsError {
+    public readonly statusCode?: number;
+    constructor(message: string, statusCode?: number) {
+        super(statusCode ? `API Error: ${message} (status: ${statusCode})` : `API Error: ${message}`);
+        this.name = 'APIError';
+        this.statusCode = statusCode;
+        Object.setPrototypeOf(this, APIError.prototype);
+    }
+}
+
+export class AuthenticationError extends BorsajsError {
+    constructor(message: string = 'Authentication failed') {
+        super(message);
+        this.name = 'AuthenticationError';
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+    }
+}
+
+export class RateLimitError extends BorsajsError {
+    constructor(message: string = 'Rate limit exceeded') {
+        super(message);
+        this.name = 'RateLimitError';
+        Object.setPrototypeOf(this, RateLimitError.prototype);
+    }
+}
+
+export class InvalidPeriodError extends BorsajsError {
+    public readonly period: string;
+    public static readonly VALID_PERIODS = ['1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max'];
+    constructor(period: string) {
+        super(`Invalid period: ${period}. Valid: ${InvalidPeriodError.VALID_PERIODS.join(', ')}`);
+        this.name = 'InvalidPeriodError';
+        this.period = period;
+        Object.setPrototypeOf(this, InvalidPeriodError.prototype);
+    }
+}
+
+export class InvalidIntervalError extends BorsajsError {
+    public readonly interval: string;
+    public static readonly VALID_INTERVALS = ['1m', '5m', '15m', '30m', '1h', '1d', '1wk', '1mo'];
+    constructor(interval: string) {
+        super(`Invalid interval: ${interval}. Valid: ${InvalidIntervalError.VALID_INTERVALS.join(', ')}`);
+        this.name = 'InvalidIntervalError';
+        this.interval = interval;
+        Object.setPrototypeOf(this, InvalidIntervalError.prototype);
+    }
+}

package/src/fund.ts

@@ -0,0 +1,37 @@
+/**
+ * Fund class for mutual fund data.
+ */
+import { getTefasProvider, FundInfo, FundHistoryData, HistoryOptions, SearchResult } from './providers/tefas.js';
+
+export interface FundPerformance { dailyReturn?: number; return1m?: number; return3m?: number; return6m?: number; returnYtd?: number; return1y?: number; return3y?: number; return5y?: number; }
+
+export class Fund {
+    private readonly _fundCode: string;
+    private _infoCache: FundInfo | null = null;
+
+    constructor(fundCode: string) { this._fundCode = fundCode.toUpperCase(); }
+    get fundCode(): string { return this._fundCode; }
+    get symbol(): string { return this._fundCode; }
+
+    async getInfo(): Promise<FundInfo> {
+        if (!this._infoCache) this._infoCache = await getTefasProvider().getFundDetail(this._fundCode);
+        return this._infoCache;
+    }
+
+    async getDetail(): Promise<FundInfo> { return this.getInfo(); }
+
+    async getPerformance(): Promise<FundPerformance> {
+        const info = await this.getInfo();
+        return { dailyReturn: info.dailyReturn, return1m: info.return1m, return3m: info.return3m, return6m: info.return6m, returnYtd: info.returnYtd, return1y: info.return1y, return3y: info.return3y, return5y: info.return5y };
+    }
+
+    async getHistory(options: HistoryOptions = {}): Promise<FundHistoryData[]> {
+        return getTefasProvider().getHistory(this._fundCode, options);
+    }
+
+    toString(): string { return `Fund('${this._fundCode}')`; }
+}
+
+export async function searchFunds(query: string, limit: number = 20): Promise<SearchResult[]> {
+    return getTefasProvider().search(query, limit);
+}

package/src/fx.ts

@@ -0,0 +1,26 @@
+/**
+ * FX class for forex and commodity data.
+ */
+import { getDovizcomProvider, FXCurrentData, FXHistoryData, HistoryOptions } from './providers/dovizcom.js';
+
+export class FX {
+    private readonly _asset: string;
+    private _currentCache: FXCurrentData | null = null;
+
+    constructor(asset: string) { this._asset = asset; }
+    get asset(): string { return this._asset; }
+    get symbol(): string { return this._asset; }
+
+    async getCurrent(): Promise<FXCurrentData> {
+        if (!this._currentCache) this._currentCache = await getDovizcomProvider().getCurrent(this._asset);
+        return this._currentCache;
+    }
+
+    async getInfo(): Promise<FXCurrentData> { return this.getCurrent(); }
+
+    async getHistory(options: HistoryOptions = {}): Promise<FXHistoryData[]> {
+        return getDovizcomProvider().getHistory(this._asset, options);
+    }
+
+    toString(): string { return `FX('${this._asset}')`; }
+}

package/src/index-class.ts

@@ -0,0 +1,39 @@
+/**
+ * Index class for market index data.
+ */
+import { getParaticProvider, QuoteData, OHLCVData, HistoryOptions } from './providers/paratic.js';
+
+export const INDICES: Record<string, string> = {
+    'XU100': 'BIST 100', 'XU050': 'BIST 50', 'XU030': 'BIST 30', 'XBANK': 'BIST Banka',
+    'XUSIN': 'BIST Sınai', 'XHOLD': 'BIST Holding', 'XUTEK': 'BIST Teknoloji', 'XGIDA': 'BIST Gıda',
+    'XTRZM': 'BIST Turizm', 'XULAS': 'BIST Ulaştırma', 'XSGRT': 'BIST Sigorta', 'XMANA': 'BIST Metal Ana',
+    'XKMYA': 'BIST Kimya', 'XMADN': 'BIST Maden', 'XELKT': 'BIST Elektrik', 'XTEKS': 'BIST Tekstil',
+    'XILTM': 'BIST İletişim', 'XUMAL': 'BIST Mali', 'XUTUM': 'BIST Tüm',
+};
+
+export interface IndexInfo extends QuoteData { name: string; type: 'index'; }
+
+export class Index {
+    private readonly _symbol: string;
+    private _infoCache: IndexInfo | null = null;
+
+    constructor(symbol: string) { this._symbol = symbol.toUpperCase(); }
+    get symbol(): string { return this._symbol; }
+
+    async getInfo(): Promise<IndexInfo> {
+        if (!this._infoCache) {
+            const quote = await getParaticProvider().getQuote(this._symbol);
+            this._infoCache = { ...quote, name: INDICES[this._symbol] ?? this._symbol, type: 'index' };
+        }
+        return this._infoCache;
+    }
+
+    async getHistory(options: HistoryOptions = {}): Promise<OHLCVData[]> {
+        return getParaticProvider().getHistory(this._symbol, options);
+    }
+
+    toString(): string { return `Index('${this._symbol}')`; }
+}
+
+export function indices(): string[] { return Object.keys(INDICES); }
+export function index(symbol: string): Index { return new Index(symbol); }

package/src/index.ts

@@ -0,0 +1,38 @@
+/**
+ * borsajs - Turkish Financial Markets Data Library
+ */
+
+export { Ticker } from './ticker.js';
+export type { TickerInfo } from './ticker.js';
+
+export { Tickers, download } from './multi.js';
+export type { DownloadOptions, MultiTickerData } from './multi.js';
+
+export { FX } from './fx.js';
+
+export { Crypto, cryptoPairs } from './crypto.js';
+
+export { Fund, searchFunds } from './fund.js';
+export type { FundPerformance } from './fund.js';
+
+export { Index, indices, index, INDICES } from './index-class.js';
+export type { IndexInfo } from './index-class.js';
+
+export { Inflation } from './inflation.js';
+
+export { VIOP } from './viop.js';
+
+export { companies, searchCompanies } from './market.js';
+
+export { BorsajsError, TickerNotFoundError, DataNotAvailableError, APIError, AuthenticationError, RateLimitError, InvalidPeriodError, InvalidIntervalError } from './exceptions.js';
+
+export { Cache, TTL, getCache } from './cache.js';
+
+export type { OHLCVData, HistoryOptions } from './providers/paratic.js';
+export type { TickerData } from './providers/btcturk.js';
+export type { FXCurrentData, FXHistoryData } from './providers/dovizcom.js';
+export type { FundInfo, FundHistoryData, SearchResult } from './providers/tefas.js';
+export type { InflationLatest, InflationData, InflationCalculation } from './providers/tcmb.js';
+export type { ContractData, Company, Disclosure } from './providers/kap.js';
+
+export const VERSION = '0.1.0';

package/src/inflation.ts

@@ -0,0 +1,31 @@
+/**
+ * Inflation class for TCMB inflation data.
+ */
+import { getTcmbProvider, InflationLatest, InflationData, InflationCalculation, InflationDataOptions } from './providers/tcmb.js';
+
+export class Inflation {
+    async getLatest(inflationType: string = 'tufe'): Promise<InflationLatest> {
+        return getTcmbProvider().getLatest(inflationType);
+    }
+
+    async getTufe(options: InflationDataOptions = {}): Promise<InflationData[]> {
+        return getTcmbProvider().getData('tufe', options);
+    }
+
+    async getUfe(options: InflationDataOptions = {}): Promise<InflationData[]> {
+        return getTcmbProvider().getData('ufe', options);
+    }
+
+    async calculate(amount: number, start: string, end: string): Promise<InflationCalculation> {
+        const parseYM = (s: string): [number, number] => {
+            const [y, m] = s.split('-').map(Number);
+            if (!y || !m || m < 1 || m > 12) throw new Error(`Invalid date format: ${s}. Use YYYY-MM`);
+            return [y, m];
+        };
+        const [sy, sm] = parseYM(start);
+        const [ey, em] = parseYM(end);
+        return getTcmbProvider().calculateInflation({ startYear: sy, startMonth: sm, endYear: ey, endMonth: em, basketValue: amount });
+    }
+
+    toString(): string { return 'Inflation()'; }
+}

package/src/market.ts

@@ -0,0 +1,7 @@
+/**
+ * Market-level functions for BIST data.
+ */
+import { getKapProvider, Company } from './providers/kap.js';
+
+export async function companies(): Promise<Company[]> { return getKapProvider().getCompanies(); }
+export async function searchCompanies(query: string): Promise<Company[]> { return getKapProvider().search(query); }

package/src/multi.ts

@@ -0,0 +1,46 @@
+/**
+ * Multi-ticker functions and classes.
+ */
+import { Ticker } from './ticker.js';
+import { getParaticProvider, OHLCVData, HistoryOptions } from './providers/paratic.js';
+
+export interface DownloadOptions extends HistoryOptions { groupBy?: 'column' | 'ticker'; progress?: boolean; }
+export interface MultiTickerData { [ticker: string]: OHLCVData[]; }
+
+export class Tickers {
+    private readonly _symbols: string[];
+    private readonly _tickers: Map<string, Ticker>;
+
+    constructor(symbols: string | string[]) {
+        this._symbols = (typeof symbols === 'string' ? symbols.split(/\s+/) : symbols).filter(s => s.trim()).map(s => s.trim().toUpperCase());
+        this._tickers = new Map();
+        for (const symbol of this._symbols) this._tickers.set(symbol, new Ticker(symbol));
+    }
+
+    get symbols(): string[] { return [...this._symbols]; }
+    get tickers(): Map<string, Ticker> { return this._tickers; }
+    get length(): number { return this._tickers.size; }
+
+    getTicker(symbol: string): Ticker {
+        const ticker = this._tickers.get(symbol.toUpperCase());
+        if (!ticker) throw new Error(`Symbol not found: ${symbol}`);
+        return ticker;
+    }
+
+    async getHistory(options: DownloadOptions = {}): Promise<MultiTickerData> { return download(this._symbols, options); }
+
+    *[Symbol.iterator](): Iterator<[string, Ticker]> { for (const entry of this._tickers) yield entry; }
+    toString(): string { return `Tickers(${JSON.stringify(this._symbols)})`; }
+}
+
+export async function download(tickers: string | string[], options: DownloadOptions = {}): Promise<MultiTickerData> {
+    const symbols = (typeof tickers === 'string' ? tickers.split(/\s+/) : tickers).filter(s => s.trim()).map(s => s.trim().toUpperCase());
+    if (symbols.length === 0) throw new Error('No symbols provided');
+    const { period, interval, start, end } = options;
+    const provider = getParaticProvider();
+    const result: MultiTickerData = {};
+    for (const symbol of symbols) {
+        try { const data = await provider.getHistory(symbol, { period, interval, start, end }); if (data.length > 0) result[symbol] = data; } catch { /* skip */ }
+    }
+    return result;
+}

package/src/providers/base.ts

@@ -0,0 +1,35 @@
+/**
+ * Base provider class for all data providers.
+ */
+import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { Cache, getCache } from '../cache.js';
+
+export interface ProviderOptions { timeout?: number; cache?: Cache; }
+
+export abstract class BaseProvider {
+    protected readonly client: AxiosInstance;
+    protected readonly cache: Cache;
+
+    protected static readonly DEFAULT_HEADERS = {
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Accept': 'application/json, text/plain, */*',
+        'Accept-Language': 'tr-TR,tr;q=0.9,en-US;q=0.8,en;q=0.7',
+    };
+
+    constructor(options: ProviderOptions = {}) {
+        const { timeout = 30000, cache } = options;
+        this.client = axios.create({ timeout, headers: BaseProvider.DEFAULT_HEADERS });
+        this.cache = cache ?? getCache();
+    }
+
+    protected async get<T = unknown>(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse<T>> {
+        return this.client.get<T>(url, config);
+    }
+
+    protected async post<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<AxiosResponse<T>> {
+        return this.client.post<T>(url, data, config);
+    }
+
+    protected cacheGet<T>(key: string): T | null { return this.cache.get<T>(key); }
+    protected cacheSet<T>(key: string, value: T, ttl: number): void { this.cache.set(key, value, ttl); }
+}

package/src/providers/btcturk.ts

@@ -0,0 +1,100 @@
+/**
+ * BtcTurk provider for cryptocurrency data.
+ */
+import { BaseProvider, ProviderOptions } from './base.js';
+import { TTL } from '../cache.js';
+import { APIError, DataNotAvailableError } from '../exceptions.js';
+
+export interface TickerData {
+    symbol: string; last: number; open: number; high: number; low: number;
+    bid: number; ask: number; volume: number; change: number; changePercent: number; timestamp?: number;
+}
+
+export interface OHLCVData { date: Date; open: number; high: number; low: number; close: number; volume: number; }
+export interface HistoryOptions { period?: string; interval?: string; start?: Date; end?: Date; }
+
+interface BtcTurkTickerResponse { success: boolean; message?: string; data: Array<{ pair: string; last: string | number; open: string | number; high: string | number; low: string | number; bid: string | number; ask: string | number; volume: string | number; daily: string | number; dailyPercent: string | number; timestamp: number; }>; }
+interface GraphAPIResponse { s: string; t: number[]; o: number[]; h: number[]; l: number[]; c: number[]; v: number[]; }
+
+export class BtcTurkProvider extends BaseProvider {
+    private static readonly BASE_URL = 'https://api.btcturk.com/api/v2';
+    private static readonly GRAPH_API_URL = 'https://graph-api.btcturk.com';
+    private static readonly RESOLUTION_MAP: Record<string, number> = { '1m': 1, '5m': 5, '15m': 15, '30m': 30, '1h': 60, '4h': 240, '1d': 1440, '1wk': 10080 };
+    private static readonly PERIOD_DAYS: Record<string, number> = { '1d': 1, '5d': 5, '1mo': 30, '3mo': 90, '6mo': 180, '1y': 365 };
+
+    constructor(options?: ProviderOptions) { super(options); }
+
+    async getTicker(pair: string): Promise<TickerData> {
+        pair = pair.toUpperCase();
+        const cacheKey = `btcturk:ticker:${pair}`;
+        const cached = this.cacheGet<TickerData>(cacheKey);
+        if (cached) return cached;
+
+        try {
+            const response = await this.get<BtcTurkTickerResponse>(`${BtcTurkProvider.BASE_URL}/ticker`, { params: { pairSymbol: pair } });
+            const data = response.data;
+            if (!data.success) throw new APIError(data.message ?? 'Unknown error');
+            if (!data.data || data.data.length === 0) throw new DataNotAvailableError(`No data for pair: ${pair}`);
+
+            const ticker = data.data[0];
+            const result: TickerData = {
+                symbol: ticker.pair, last: Number(ticker.last) || 0, open: Number(ticker.open) || 0,
+                high: Number(ticker.high) || 0, low: Number(ticker.low) || 0, bid: Number(ticker.bid) || 0,
+                ask: Number(ticker.ask) || 0, volume: Number(ticker.volume) || 0, change: Number(ticker.daily) || 0,
+                changePercent: Number(ticker.dailyPercent) || 0, timestamp: ticker.timestamp,
+            };
+            this.cacheSet(cacheKey, result, TTL.REALTIME_PRICE);
+            return result;
+        } catch (error) {
+            if (error instanceof APIError || error instanceof DataNotAvailableError) throw error;
+            throw new APIError(`Failed to fetch ticker for ${pair}: ${error}`);
+        }
+    }
+
+    async getHistory(pair: string, options: HistoryOptions = {}): Promise<OHLCVData[]> {
+        pair = pair.toUpperCase();
+        const { period = '1mo', interval = '1d', start, end } = options;
+        const endDt = end ?? new Date();
+        const startDt = start ?? new Date(endDt.getTime() - (BtcTurkProvider.PERIOD_DAYS[period] ?? 30) * 24 * 60 * 60 * 1000);
+        const fromTs = Math.floor(startDt.getTime() / 1000);
+        const toTs = Math.floor(endDt.getTime() / 1000);
+
+        const cacheKey = `btcturk:history:${pair}:${interval}:${fromTs}:${toTs}`;
+        const cached = this.cacheGet<OHLCVData[]>(cacheKey);
+        if (cached) return cached;
+
+        try {
+            const resolution = BtcTurkProvider.RESOLUTION_MAP[interval] ?? 1440;
+            const response = await this.get<GraphAPIResponse>(`${BtcTurkProvider.GRAPH_API_URL}/v1/klines/history`, { params: { symbol: pair, resolution, from: fromTs, to: toTs } });
+            const data = response.data;
+            if (data.s !== 'ok') throw new DataNotAvailableError(`No data available for ${pair}`);
+
+            const records: OHLCVData[] = data.t.map((ts, i) => ({
+                date: new Date(ts * 1000), open: Number(data.o[i]) || 0, high: Number(data.h[i]) || 0,
+                low: Number(data.l[i]) || 0, close: Number(data.c[i]) || 0, volume: Number(data.v[i]) || 0,
+            }));
+            records.sort((a, b) => a.date.getTime() - b.date.getTime());
+            this.cacheSet(cacheKey, records, TTL.OHLCV_HISTORY);
+            return records;
+        } catch (error) {
+            if (error instanceof DataNotAvailableError) throw error;
+            throw new APIError(`Failed to fetch history for ${pair}: ${error}`);
+        }
+    }
+
+    async getPairs(quote: string = 'TRY'): Promise<string[]> {
+        const cacheKey = `btcturk:pairs:${quote}`;
+        const cached = this.cacheGet<string[]>(cacheKey);
+        if (cached) return cached;
+        try {
+            const response = await this.get<BtcTurkTickerResponse>(`${BtcTurkProvider.BASE_URL}/ticker`);
+            if (!response.data.success) return [];
+            const pairs = response.data.data.map(t => t.pair).filter(p => p.endsWith(quote.toUpperCase()));
+            this.cacheSet(cacheKey, pairs, TTL.COMPANY_LIST);
+            return pairs;
+        } catch { return []; }
+    }
+}
+
+let provider: BtcTurkProvider | null = null;
+export function getBtcTurkProvider(): BtcTurkProvider { if (!provider) provider = new BtcTurkProvider(); return provider; }