pmxtjs 0.3.1 → 0.4.1

package/dist/exchanges/kalshi/kalshi.test.js

@@ -0,0 +1,309 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const kalshi_1 = require("../kalshi");
+const axios_1 = __importDefault(require("axios"));
+const auth_1 = require("./auth");
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+// Mock KalshiAuth
+jest.mock('./auth');
+const MockedKalshiAuth = auth_1.KalshiAuth;
+describe('KalshiExchange', () => {
+    let exchange;
+    const mockCredentials = {
+        apiKey: 'test-api-key',
+        privateKey: 'mock-private-key'
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock the getHeaders method
+        MockedKalshiAuth.prototype.getHeaders = jest.fn().mockReturnValue({
+            'KALSHI-ACCESS-KEY': 'test-api-key',
+            'KALSHI-ACCESS-TIMESTAMP': '1234567890',
+            'KALSHI-ACCESS-SIGNATURE': 'mock-signature',
+            'Content-Type': 'application/json'
+        });
+    });
+    describe('Authentication', () => {
+        it('should throw error when trading without credentials', async () => {
+            exchange = new kalshi_1.KalshiExchange();
+            await expect(exchange.fetchBalance()).rejects.toThrow('Trading operations require authentication');
+        });
+        it('should initialize with credentials', () => {
+            exchange = new kalshi_1.KalshiExchange(mockCredentials);
+            expect(exchange).toBeDefined();
+        });
+    });
+    describe('Market Data Methods', () => {
+        beforeEach(() => {
+            exchange = new kalshi_1.KalshiExchange();
+        });
+        it('should fetch markets', async () => {
+            const mockResponse = {
+                data: {
+                    markets: [
+                        {
+                            ticker: 'TEST-MARKET',
+                            title: 'Test Market',
+                            yes_bid: 50,
+                            yes_ask: 52,
+                            volume: 1000
+                        }
+                    ]
+                }
+            };
+            mockedAxios.get.mockResolvedValue(mockResponse);
+            const markets = await exchange.fetchMarkets();
+            expect(markets).toBeDefined();
+        });
+    });
+    describe('Trading Methods', () => {
+        beforeEach(() => {
+            exchange = new kalshi_1.KalshiExchange(mockCredentials);
+        });
+        describe('createOrder', () => {
+            it('should create buy order with yes_price for buy side', async () => {
+                const orderParams = {
+                    marketId: 'TEST-MARKET',
+                    outcomeId: 'yes',
+                    side: 'buy',
+                    type: 'limit',
+                    amount: 10,
+                    price: 0.55
+                };
+                const mockResponse = {
+                    data: {
+                        order: {
+                            order_id: 'order-123',
+                            ticker: 'TEST-MARKET',
+                            status: 'resting',
+                            count: 10,
+                            remaining_count: 10,
+                            created_time: '2026-01-13T12:00:00Z',
+                            queue_position: 1
+                        }
+                    }
+                };
+                mockedAxios.post.mockResolvedValue(mockResponse);
+                const order = await exchange.createOrder(orderParams);
+                expect(mockedAxios.post).toHaveBeenCalledWith('https://trading-api.kalshi.com/trade-api/v2/portfolio/orders', expect.objectContaining({
+                    ticker: 'TEST-MARKET',
+                    side: 'yes',
+                    action: 'buy',
+                    count: 10,
+                    type: 'limit',
+                    yes_price: 55 // 0.55 * 100
+                }), expect.any(Object));
+                expect(order.id).toBe('order-123');
+                expect(order.status).toBe('open');
+            });
+            it('should create sell order with no_price for sell side', async () => {
+                const orderParams = {
+                    marketId: 'TEST-MARKET',
+                    outcomeId: 'no',
+                    side: 'sell',
+                    type: 'limit',
+                    amount: 5,
+                    price: 0.45
+                };
+                const mockResponse = {
+                    data: {
+                        order: {
+                            order_id: 'order-456',
+                            ticker: 'TEST-MARKET',
+                            status: 'resting',
+                            count: 5,
+                            remaining_count: 5,
+                            created_time: '2026-01-13T12:00:00Z',
+                            queue_position: 1
+                        }
+                    }
+                };
+                mockedAxios.post.mockResolvedValue(mockResponse);
+                await exchange.createOrder(orderParams);
+                expect(mockedAxios.post).toHaveBeenCalledWith('https://trading-api.kalshi.com/trade-api/v2/portfolio/orders', expect.objectContaining({
+                    ticker: 'TEST-MARKET',
+                    side: 'no',
+                    action: 'sell',
+                    count: 5,
+                    type: 'limit',
+                    no_price: 45 // 0.45 * 100
+                }), expect.any(Object));
+            });
+        });
+        describe('fetchOpenOrders', () => {
+            it('should sign request without query parameters', async () => {
+                const mockResponse = {
+                    data: {
+                        orders: [
+                            {
+                                order_id: 'order-123',
+                                ticker: 'TEST-MARKET',
+                                side: 'yes',
+                                type: 'limit',
+                                yes_price: 55,
+                                count: 10,
+                                remaining_count: 10,
+                                created_time: '2026-01-13T12:00:00Z'
+                            }
+                        ]
+                    }
+                };
+                mockedAxios.get.mockResolvedValue(mockResponse);
+                await exchange.fetchOpenOrders();
+                // Verify the request URL includes query params
+                expect(mockedAxios.get).toHaveBeenCalledWith('https://trading-api.kalshi.com/trade-api/v2/portfolio/orders?status=resting', expect.any(Object));
+                // Verify getHeaders was called with base path only (no query params)
+                expect(MockedKalshiAuth.prototype.getHeaders).toHaveBeenCalledWith('GET', '/trade-api/v2/portfolio/orders');
+            });
+            it('should include ticker in query params when marketId provided', async () => {
+                const mockResponse = { data: { orders: [] } };
+                mockedAxios.get.mockResolvedValue(mockResponse);
+                await exchange.fetchOpenOrders('TEST-MARKET');
+                expect(mockedAxios.get).toHaveBeenCalledWith('https://trading-api.kalshi.com/trade-api/v2/portfolio/orders?status=resting&ticker=TEST-MARKET', expect.any(Object));
+            });
+        });
+        describe('fetchPositions', () => {
+            it('should handle positions with zero contracts', async () => {
+                const mockResponse = {
+                    data: {
+                        market_positions: [
+                            {
+                                ticker: 'TEST-MARKET',
+                                position: 0,
+                                total_cost: 0,
+                                market_exposure: 0,
+                                realized_pnl: 0
+                            }
+                        ]
+                    }
+                };
+                mockedAxios.get.mockResolvedValue(mockResponse);
+                const positions = await exchange.fetchPositions();
+                expect(positions).toHaveLength(1);
+                expect(positions[0].size).toBe(0);
+                expect(positions[0].entryPrice).toBe(0); // Should not throw division by zero
+            });
+            it('should correctly calculate average price and PnL', async () => {
+                const mockResponse = {
+                    data: {
+                        market_positions: [
+                            {
+                                ticker: 'TEST-MARKET',
+                                position: 10,
+                                total_cost: 550, // 10 contracts at $0.55 each = $5.50 = 550 cents
+                                market_exposure: 100, // $1.00 unrealized PnL
+                                realized_pnl: 50 // $0.50 realized PnL
+                            }
+                        ]
+                    }
+                };
+                mockedAxios.get.mockResolvedValue(mockResponse);
+                const positions = await exchange.fetchPositions();
+                expect(positions).toHaveLength(1);
+                expect(positions[0].size).toBe(10);
+                expect(positions[0].entryPrice).toBe(0.55); // 550 / 10 / 100
+                expect(positions[0].unrealizedPnL).toBe(1.00); // 100 / 100
+                expect(positions[0].realizedPnL).toBe(0.50); // 50 / 100
+            });
+            it('should handle short positions', async () => {
+                const mockResponse = {
+                    data: {
+                        market_positions: [
+                            {
+                                ticker: 'TEST-MARKET',
+                                position: -5, // Short position
+                                total_cost: 250,
+                                market_exposure: -50,
+                                realized_pnl: 25
+                            }
+                        ]
+                    }
+                };
+                mockedAxios.get.mockResolvedValue(mockResponse);
+                const positions = await exchange.fetchPositions();
+                expect(positions[0].size).toBe(-5); // Negative for short
+                expect(Math.abs(positions[0].size)).toBe(5); // Absolute value
+            });
+        });
+        describe('fetchBalance', () => {
+            it('should correctly convert cents to dollars', async () => {
+                const mockResponse = {
+                    data: {
+                        balance: 10000, // $100.00 available
+                        portfolio_value: 15000 // $150.00 total
+                    }
+                };
+                mockedAxios.get.mockResolvedValue(mockResponse);
+                const balances = await exchange.fetchBalance();
+                expect(balances).toHaveLength(1);
+                expect(balances[0].currency).toBe('USD');
+                expect(balances[0].available).toBe(100.00);
+                expect(balances[0].total).toBe(150.00);
+                expect(balances[0].locked).toBe(50.00); // 150 - 100
+            });
+        });
+        describe('cancelOrder', () => {
+            it('should cancel order successfully', async () => {
+                const mockResponse = {
+                    data: {
+                        order: {
+                            order_id: 'order-123',
+                            ticker: 'TEST-MARKET',
+                            side: 'yes',
+                            count: 10,
+                            remaining_count: 5,
+                            created_time: '2026-01-13T12:00:00Z'
+                        }
+                    }
+                };
+                mockedAxios.delete.mockResolvedValue(mockResponse);
+                const order = await exchange.cancelOrder('order-123');
+                expect(order.status).toBe('cancelled');
+                expect(order.filled).toBe(5); // count - remaining_count
+                expect(order.remaining).toBe(0);
+            });
+        });
+    });
+    describe('Order Status Mapping', () => {
+        beforeEach(() => {
+            exchange = new kalshi_1.KalshiExchange(mockCredentials);
+        });
+        it('should map resting to open', async () => {
+            const mockResponse = {
+                data: {
+                    order: {
+                        order_id: 'order-123',
+                        ticker: 'TEST',
+                        status: 'resting',
+                        count: 10,
+                        created_time: '2026-01-13T12:00:00Z'
+                    }
+                }
+            };
+            mockedAxios.get.mockResolvedValue(mockResponse);
+            const order = await exchange.fetchOrder('order-123');
+            expect(order.status).toBe('open');
+        });
+        it('should map executed to filled', async () => {
+            const mockResponse = {
+                data: {
+                    order: {
+                        order_id: 'order-123',
+                        ticker: 'TEST',
+                        status: 'executed',
+                        count: 10,
+                        created_time: '2026-01-13T12:00:00Z'
+                    }
+                }
+            };
+            mockedAxios.get.mockResolvedValue(mockResponse);
+            const order = await exchange.fetchOrder('order-123');
+            expect(order.status).toBe('filled');
+        });
+    });
+});

package/dist/exchanges/kalshi/searchMarkets.d.ts

@@ -0,0 +1,3 @@
+import { MarketFilterParams } from '../../BaseExchange';
+import { UnifiedMarket } from '../../types';
+export declare function searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>;

package/dist/exchanges/kalshi/searchMarkets.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchMarkets = searchMarkets;
+const fetchMarkets_1 = require("./fetchMarkets");
+async function searchMarkets(query, params) {
+    // We must fetch ALL markets to search them locally since we don't have server-side search
+    const fetchLimit = 100000;
+    try {
+        const markets = await (0, fetchMarkets_1.fetchMarkets)({ ...params, limit: fetchLimit });
+        const lowerQuery = query.toLowerCase();
+        const searchIn = params?.searchIn || 'title'; // Default to title-only search
+        const filtered = markets.filter(market => {
+            const titleMatch = (market.title || '').toLowerCase().includes(lowerQuery);
+            const descMatch = (market.description || '').toLowerCase().includes(lowerQuery);
+            if (searchIn === 'title')
+                return titleMatch;
+            if (searchIn === 'description')
+                return descMatch;
+            return titleMatch || descMatch; // 'both'
+        });
+        const limit = params?.limit || 20;
+        return filtered.slice(0, limit);
+    }
+    catch (error) {
+        console.error("Error searching Kalshi data:", error);
+        return [];
+    }
+}

package/dist/exchanges/kalshi/utils.d.ts

@@ -0,0 +1,5 @@
+import { UnifiedMarket, CandleInterval } from '../../types';
+export declare const KALSHI_API_URL = "https://api.elections.kalshi.com/trade-api/v2/events";
+export declare const KALSHI_SERIES_URL = "https://api.elections.kalshi.com/trade-api/v2/series";
+export declare function mapMarketToUnified(event: any, market: any): UnifiedMarket | null;
+export declare function mapIntervalToKalshi(interval: CandleInterval): number;

package/dist/exchanges/kalshi/utils.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KALSHI_SERIES_URL = exports.KALSHI_API_URL = void 0;
+exports.mapMarketToUnified = mapMarketToUnified;
+exports.mapIntervalToKalshi = mapIntervalToKalshi;
+exports.KALSHI_API_URL = "https://api.elections.kalshi.com/trade-api/v2/events";
+exports.KALSHI_SERIES_URL = "https://api.elections.kalshi.com/trade-api/v2/series";
+function mapMarketToUnified(event, market) {
+    if (!market)
+        return null;
+    // Calculate price
+    let price = 0.5;
+    if (market.last_price) {
+        price = market.last_price / 100;
+    }
+    else if (market.yes_ask && market.yes_bid) {
+        price = (market.yes_ask + market.yes_bid) / 200;
+    }
+    else if (market.yes_ask) {
+        price = market.yes_ask / 100;
+    }
+    // Extract candidate name
+    let candidateName = null;
+    if (market.subtitle || market.yes_sub_title) {
+        candidateName = market.subtitle || market.yes_sub_title;
+    }
+    // Calculate 24h change
+    let priceChange = 0;
+    if (market.previous_price_dollars !== undefined && market.last_price_dollars !== undefined) {
+        priceChange = market.last_price_dollars - market.previous_price_dollars;
+    }
+    const outcomes = [
+        {
+            id: market.ticker, // The actual market ticker (primary tradeable)
+            label: candidateName || 'Yes',
+            price: price,
+            priceChange24h: priceChange
+        },
+        {
+            id: `${market.ticker}-NO`, // Virtual ID for the No outcome
+            label: candidateName ? `Not ${candidateName}` : 'No',
+            price: 1 - price,
+            priceChange24h: -priceChange // Inverse change for No? simplified assumption
+        }
+    ];
+    // Combine category and tags into a unified tags array
+    const unifiedTags = [];
+    // Add category first (if it exists)
+    if (event.category) {
+        unifiedTags.push(event.category);
+    }
+    // Add tags (if they exist and avoid duplicates)
+    if (event.tags && Array.isArray(event.tags)) {
+        for (const tag of event.tags) {
+            if (!unifiedTags.includes(tag)) {
+                unifiedTags.push(tag);
+            }
+        }
+    }
+    return {
+        id: market.ticker,
+        title: event.title,
+        description: event.sub_title || market.subtitle || "",
+        outcomes: outcomes,
+        resolutionDate: new Date(market.expiration_time),
+        volume24h: Number(market.volume_24h || market.volume || 0),
+        volume: Number(market.volume || 0),
+        liquidity: Number(market.liquidity || 0), // Kalshi 'liquidity' might need specific mapping if available, otherwise 0 to avoid conflation
+        openInterest: Number(market.open_interest || 0),
+        url: `https://kalshi.com/events/${event.event_ticker}`,
+        category: event.category,
+        tags: unifiedTags
+    };
+}
+function mapIntervalToKalshi(interval) {
+    const mapping = {
+        '1m': 1,
+        '5m': 1,
+        '15m': 1,
+        '1h': 60,
+        '6h': 60,
+        '1d': 1440
+    };
+    return mapping[interval];
+}

package/dist/exchanges/polymarket/auth.d.ts

@@ -0,0 +1,32 @@
+import { ClobClient } from '@polymarket/clob-client';
+import type { ApiKeyCreds } from '@polymarket/clob-client';
+import { ExchangeCredentials } from '../../BaseExchange';
+/**
+ * Manages Polymarket authentication and CLOB client initialization.
+ * Handles both L1 (wallet-based) and L2 (API credentials) authentication.
+ */
+export declare class PolymarketAuth {
+    private credentials;
+    private signer?;
+    private clobClient?;
+    private apiCreds?;
+    constructor(credentials: ExchangeCredentials);
+    /**
+     * Get or create API credentials using L1 authentication.
+     * This uses the private key to derive/create API credentials.
+     */
+    getApiCredentials(): Promise<ApiKeyCreds>;
+    /**
+     * Get an authenticated CLOB client for L2 operations (trading).
+     * This client can place orders, cancel orders, query positions, etc.
+     */
+    getClobClient(): Promise<ClobClient>;
+    /**
+     * Get the signer's address.
+     */
+    getAddress(): string;
+    /**
+     * Reset cached credentials and client (useful for testing or credential rotation).
+     */
+    reset(): void;
+}

package/dist/exchanges/polymarket/auth.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolymarketAuth = void 0;
+const clob_client_1 = require("@polymarket/clob-client");
+const ethers_1 = require("ethers");
+const POLYMARKET_HOST = 'https://clob.polymarket.com';
+const POLYGON_CHAIN_ID = 137;
+/**
+ * Manages Polymarket authentication and CLOB client initialization.
+ * Handles both L1 (wallet-based) and L2 (API credentials) authentication.
+ */
+class PolymarketAuth {
+    constructor(credentials) {
+        this.credentials = credentials;
+        if (!credentials.privateKey) {
+            throw new Error('Polymarket requires a privateKey for authentication');
+        }
+        // Initialize the signer
+        this.signer = new ethers_1.Wallet(credentials.privateKey);
+    }
+    /**
+     * Get or create API credentials using L1 authentication.
+     * This uses the private key to derive/create API credentials.
+     */
+    async getApiCredentials() {
+        // Return cached credentials if available
+        if (this.apiCreds) {
+            return this.apiCreds;
+        }
+        // If credentials were provided, use them
+        if (this.credentials.apiKey && this.credentials.apiSecret && this.credentials.passphrase) {
+            this.apiCreds = {
+                key: this.credentials.apiKey,
+                secret: this.credentials.apiSecret,
+                passphrase: this.credentials.passphrase,
+            };
+            return this.apiCreds;
+        }
+        // Otherwise, derive/create them using L1 auth
+        const l1Client = new clob_client_1.ClobClient(POLYMARKET_HOST, POLYGON_CHAIN_ID, this.signer);
+        // Robust derivation strategy:
+        // 1. Try to DERIVE existing credentials first (most common case).
+        // 2. If that fails (e.g. 404 or 400), try to CREATE new ones.
+        let creds;
+        try {
+            // console.log('Trying to derive existing API key...');
+            creds = await l1Client.deriveApiKey();
+        }
+        catch (deriveError) {
+            // console.log('Derivation failed, trying to create new API key...');
+            try {
+                creds = await l1Client.createApiKey();
+            }
+            catch (createError) {
+                console.error('Failed to both derive and create API key:', createError?.message || createError);
+                throw new Error('Authentication failed: Could not create or derive API key.');
+            }
+        }
+        if (!creds) {
+            throw new Error('Authentication failed: Credentials are empty.');
+        }
+        this.apiCreds = creds;
+        return creds;
+    }
+    /**
+     * Get an authenticated CLOB client for L2 operations (trading).
+     * This client can place orders, cancel orders, query positions, etc.
+     */
+    async getClobClient() {
+        // Return cached client if available
+        if (this.clobClient) {
+            return this.clobClient;
+        }
+        // Get API credentials (L1 auth)
+        const apiCreds = await this.getApiCredentials();
+        // Determine signature type (default to EOA = 0)
+        const signatureType = this.credentials.signatureType ?? 0;
+        // Determine funder address (defaults to signer's address)
+        const funderAddress = this.credentials.funderAddress ?? this.signer.address;
+        // Create L2-authenticated client
+        this.clobClient = new clob_client_1.ClobClient(POLYMARKET_HOST, POLYGON_CHAIN_ID, this.signer, apiCreds, signatureType, funderAddress);
+        return this.clobClient;
+    }
+    /**
+     * Get the signer's address.
+     */
+    getAddress() {
+        return this.signer.address;
+    }
+    /**
+     * Reset cached credentials and client (useful for testing or credential rotation).
+     */
+    reset() {
+        this.apiCreds = undefined;
+        this.clobClient = undefined;
+    }
+}
+exports.PolymarketAuth = PolymarketAuth;

package/dist/exchanges/polymarket/fetchMarkets.d.ts

@@ -0,0 +1,3 @@
+import { MarketFilterParams } from '../../BaseExchange';
+import { UnifiedMarket } from '../../types';
+export declare function fetchMarkets(params?: MarketFilterParams): Promise<UnifiedMarket[]>;

package/dist/exchanges/polymarket/fetchMarkets.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchMarkets = fetchMarkets;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("./utils");
+async function fetchMarkets(params) {
+    const limit = params?.limit || 200; // Higher default for better coverage
+    const offset = params?.offset || 0;
+    // Map generic sort params to Polymarket Gamma API params
+    let queryParams = {
+        active: 'true',
+        closed: 'false',
+        limit: limit,
+        offset: offset,
+    };
+    // Gamma API uses 'order' and 'ascending' for sorting
+    if (params?.sort === 'volume') {
+        queryParams.order = 'volume';
+        queryParams.ascending = 'false';
+    }
+    else if (params?.sort === 'newest') {
+        queryParams.order = 'startDate';
+        queryParams.ascending = 'false';
+    }
+    else if (params?.sort === 'liquidity') {
+        // queryParams.order = 'liquidity';
+    }
+    else {
+        // Default: do not send order param to avoid 422
+    }
+    try {
+        // Fetch active events from Gamma
+        const response = await axios_1.default.get(utils_1.GAMMA_API_URL, {
+            params: queryParams
+        });
+        const events = response.data;
+        const unifiedMarkets = [];
+        for (const event of events) {
+            // Each event is a container (e.g. "US Election"). 
+            // It contains specific "markets" (e.g. "Winner", "Pop Vote").
+            if (!event.markets)
+                continue;
+            for (const market of event.markets) {
+                const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market);
+                if (unifiedMarket) {
+                    unifiedMarkets.push(unifiedMarket);
+                }
+            }
+        }
+        // Client-side Sort capability to ensure contract fulfillment
+        // Often API filters are "good effort" or apply to the 'event' but not the 'market'
+        if (params?.sort === 'volume') {
+            unifiedMarkets.sort((a, b) => b.volume24h - a.volume24h);
+        }
+        else if (params?.sort === 'newest') {
+            // unifiedMarkets.sort((a, b) => b.resolutionDate.getTime() - a.resolutionDate.getTime()); // Not quite 'newest'
+        }
+        else if (params?.sort === 'liquidity') {
+            unifiedMarkets.sort((a, b) => b.liquidity - a.liquidity);
+        }
+        else {
+            // Default volume sort
+            unifiedMarkets.sort((a, b) => b.volume24h - a.volume24h);
+        }
+        // Respect limit strictly after flattening 
+        return unifiedMarkets.slice(0, limit);
+    }
+    catch (error) {
+        console.error("Error fetching Polymarket data:", error);
+        return [];
+    }
+}

package/dist/exchanges/polymarket/fetchOHLCV.d.ts

@@ -0,0 +1,7 @@
+import { HistoryFilterParams } from '../../BaseExchange';
+import { PriceCandle } from '../../types';
+/**
+ * Fetch historical price data (OHLCV candles) for a specific token.
+ * @param id - The CLOB token ID (e.g., outcome token ID)
+ */
+export declare function fetchOHLCV(id: string, params: HistoryFilterParams): Promise<PriceCandle[]>;