pmxt-core 2.41.7 → 2.42.2

package/dist/feeds/chainlink/chainlink-feed.js

@@ -0,0 +1,241 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainlinkFeed = void 0;
+const ws_1 = __importDefault(require("ws"));
+const axios_1 = __importDefault(require("axios"));
+const base_feed_1 = require("../base-feed");
+const types_1 = require("./types");
+const normalizer_1 = require("./normalizer");
+class ChainlinkFeed extends base_feed_1.BaseDataFeed {
+    name = 'chainlink';
+    description = 'Chainlink price feeds (ETH, BTC, XRP, SOL) on Polygon via pmxt-ohlc';
+    client;
+    wsUrl;
+    wsApiKey;
+    reconnectIntervalMs;
+    ws = null;
+    subscriptions = [];
+    latestTickers = new Map();
+    isTerminated = false;
+    reconnectTimer = null;
+    connectionPromise = null;
+    constructor(config, options) {
+        super(options);
+        const baseURL = config.baseUrl ?? types_1.CHAINLINK_DEFAULTS.baseUrl;
+        this.client = axios_1.default.create({
+            baseURL,
+            headers: { 'X-API-Key': config.apiKey },
+            timeout: 10_000,
+        });
+        this.wsUrl = config.wsUrl ?? types_1.CHAINLINK_DEFAULTS.wsUrl;
+        this.wsApiKey = config.wsApiKey ?? config.apiKey;
+        this.reconnectIntervalMs = config.reconnectIntervalMs ?? types_1.CHAINLINK_DEFAULTS.reconnectIntervalMs;
+    }
+    // -- Lifecycle --
+    async connect() {
+        if (this.ws)
+            return;
+        if (this.connectionPromise)
+            return this.connectionPromise;
+        this.isTerminated = false;
+        this.connectionPromise = this.establishConnection();
+        return this.connectionPromise;
+    }
+    async close() {
+        this.isTerminated = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close(1000, 'client_close');
+            this.ws = null;
+        }
+        this.connectionPromise = null;
+        this.subscriptions = [];
+    }
+    // -- CCXT: loadMarkets --
+    async loadMarkets() {
+        const markets = {};
+        for (const t of types_1.SUPPORTED_TOKENS) {
+            markets[t.pair] = {
+                id: t.short,
+                symbol: t.pair,
+                base: t.base,
+                quote: t.quote,
+                active: true,
+                type: 'spot',
+                spot: true,
+                margin: false,
+                swap: false,
+                future: false,
+                option: false,
+                contract: false,
+                precision: { amount: undefined, price: t.decimals },
+                limits: {},
+                info: { proxyAddress: t.proxyAddress, decimals: t.decimals },
+            };
+        }
+        return markets;
+    }
+    // -- CCXT: fetchTicker --
+    async fetchTickerImpl(symbol) {
+        const cached = this.latestTickers.get(symbol.toUpperCase());
+        if (cached)
+            return cached;
+        const token = types_1.TOKEN_BY_PAIR.get(symbol.toUpperCase());
+        if (!token) {
+            throw new Error(`Unsupported Chainlink symbol: ${symbol}. Supported: ${types_1.SUPPORTED_TOKENS.map((t) => t.pair).join(', ')}`);
+        }
+        const { data } = await this.client.get('/v1/chainlink/latest-prices');
+        const now = Date.now();
+        const record = data.data.find((r) => r.token.toLowerCase() === token.short);
+        if (!record) {
+            throw new Error(`No price data returned for ${symbol}`);
+        }
+        return (0, normalizer_1.normalizeLatestToTicker)(record, now);
+    }
+    // -- CCXT: fetchTickers --
+    async fetchTickersImpl(symbols) {
+        const { data } = await this.client.get('/v1/chainlink/latest-prices');
+        const now = Date.now();
+        const requested = symbols
+            ? new Set(symbols.map((s) => s.toUpperCase()))
+            : undefined;
+        const result = {};
+        for (const record of data.data) {
+            const token = types_1.SUPPORTED_TOKENS.find((t) => t.short === record.token.toLowerCase());
+            if (!token)
+                continue;
+            if (requested && !requested.has(token.pair))
+                continue;
+            if (record.price === null || record.price === undefined)
+                continue;
+            const ticker = (0, normalizer_1.normalizeLatestToTicker)(record, now);
+            result[ticker.symbol] = ticker;
+        }
+        return result;
+    }
+    // -- CCXT: watchTicker --
+    watchTickerImpl(symbol, callback) {
+        const sub = { symbol: symbol.toUpperCase(), callback };
+        this.subscriptions = [...this.subscriptions, sub];
+        this.ensureConnected();
+        return () => {
+            this.subscriptions = this.subscriptions.filter((s) => s !== sub);
+        };
+    }
+    // -- CCXT: fetchOHLCV (not supported) --
+    async fetchOHLCVImpl(_symbol, _timeframe, _since, _limit) {
+        throw new Error('Chainlink feed does not provide OHLCV candles. ' +
+            'Use fetchOracleHistory() for raw AnswerUpdated records.');
+    }
+    // -- CCXT: fetchOrderBook (not applicable) --
+    async fetchOrderBookImpl(_symbol, _limit) {
+        throw new Error('Chainlink oracle feeds do not have order books.');
+    }
+    // -- pmxt extensions: Oracle --
+    async fetchOracleRound(params) {
+        const token = types_1.TOKEN_BY_PAIR.get(params.feed.toUpperCase());
+        if (!token) {
+            throw new Error(`Unsupported Chainlink feed: ${params.feed}. Supported: ${types_1.SUPPORTED_TOKENS.map((t) => t.pair).join(', ')}`);
+        }
+        const { data } = await this.client.get('/v1/chainlink/prices', { params: { token: token.short, max_size: 1, order: 'desc' } });
+        if (data.data.length === 0) {
+            throw new Error(`No oracle data returned for ${params.feed}`);
+        }
+        return (0, normalizer_1.normalizePriceRecordToOracleRound)(data.data[0]);
+    }
+    async fetchOracleHistory(params) {
+        const token = types_1.TOKEN_BY_PAIR.get(params.feed.toUpperCase());
+        if (!token) {
+            throw new Error(`Unsupported Chainlink feed: ${params.feed}. Supported: ${types_1.SUPPORTED_TOKENS.map((t) => t.pair).join(', ')}`);
+        }
+        const { data } = await this.client.get('/v1/chainlink/prices', { params: { token: token.short, max_size: params.limit ?? 500, order: 'desc' } });
+        return data.data.map(normalizer_1.normalizePriceRecordToOracleRound);
+    }
+    async fetchHistoricalPrices(symbol, opts) {
+        const token = types_1.TOKEN_BY_PAIR.get(symbol.toUpperCase());
+        if (!token) {
+            throw new Error(`Unsupported Chainlink symbol: ${symbol}. Supported: ${types_1.SUPPORTED_TOKENS.map((t) => t.pair).join(', ')}`);
+        }
+        const queryParams = { token: token.short };
+        if (opts?.fromTimestamp !== undefined)
+            queryParams.from_timestamp = opts.fromTimestamp;
+        if (opts?.untilTimestamp !== undefined)
+            queryParams.until_timestamp = opts.untilTimestamp;
+        if (opts?.maxSize !== undefined)
+            queryParams.max_size = opts.maxSize;
+        if (opts?.order !== undefined)
+            queryParams.order = opts.order;
+        const { data } = await this.client.get('/v1/chainlink/prices', { params: queryParams });
+        return data.data.map(normalizer_1.normalizePriceRecordToTicker);
+    }
+    // -- Internal WebSocket --
+    async ensureConnected() {
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN)
+            return;
+        await this.connect();
+    }
+    establishConnection() {
+        return new Promise((resolve, reject) => {
+            const url = `${this.wsUrl}?key=${this.wsApiKey}`;
+            const ws = new ws_1.default(url);
+            ws.on('open', () => {
+                this.ws = ws;
+                this.connectionPromise = null;
+                ws.send(JSON.stringify({ op: 'subscribe_all' }));
+                resolve();
+            });
+            ws.on('message', (data) => {
+                this.handleMessage(data);
+            });
+            ws.on('close', () => {
+                this.ws = null;
+                this.connectionPromise = null;
+                if (!this.isTerminated)
+                    this.scheduleReconnect();
+            });
+            ws.on('error', (err) => {
+                this.ws = null;
+                this.connectionPromise = null;
+                if (!this.isTerminated)
+                    this.scheduleReconnect();
+                reject(err);
+            });
+        });
+    }
+    handleMessage(data) {
+        const text = typeof data === 'string' ? data : data.toString();
+        let msg;
+        try {
+            msg = JSON.parse(text);
+        }
+        catch {
+            return;
+        }
+        if (msg.op !== 'event')
+            return;
+        const event = msg;
+        const ticker = (0, normalizer_1.normalizeWsEventToTicker)(event);
+        this.latestTickers = new Map(this.latestTickers).set(ticker.symbol, ticker);
+        for (const sub of this.subscriptions) {
+            if (sub.symbol === ticker.symbol) {
+                sub.callback(ticker);
+            }
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            if (!this.isTerminated)
+                this.connect();
+        }, this.reconnectIntervalMs);
+    }
+}
+exports.ChainlinkFeed = ChainlinkFeed;

package/dist/feeds/chainlink/index.d.ts

@@ -0,0 +1,4 @@
+export { ChainlinkFeed } from './chainlink-feed';
+export { chainlinkNormalizer, normalizeLatestToTicker, normalizePriceRecordToTicker, normalizePriceRecordToOracleRound, normalizeWsEventToTicker, normalizeWsEventToOracleRound, } from './normalizer';
+export type { ChainlinkFeedConfig, ChainlinkLatestPriceRecord, ChainlinkPriceRecord, ChainlinkWsEvent, ChainlinkWsMessage, } from './types';
+export { CHAINLINK_DEFAULTS, SUPPORTED_TOKENS, TOKEN_BY_SHORT, TOKEN_BY_PAIR } from './types';

package/dist/feeds/chainlink/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_BY_PAIR = exports.TOKEN_BY_SHORT = exports.SUPPORTED_TOKENS = exports.CHAINLINK_DEFAULTS = exports.normalizeWsEventToOracleRound = exports.normalizeWsEventToTicker = exports.normalizePriceRecordToOracleRound = exports.normalizePriceRecordToTicker = exports.normalizeLatestToTicker = exports.chainlinkNormalizer = exports.ChainlinkFeed = void 0;
+var chainlink_feed_1 = require("./chainlink-feed");
+Object.defineProperty(exports, "ChainlinkFeed", { enumerable: true, get: function () { return chainlink_feed_1.ChainlinkFeed; } });
+var normalizer_1 = require("./normalizer");
+Object.defineProperty(exports, "chainlinkNormalizer", { enumerable: true, get: function () { return normalizer_1.chainlinkNormalizer; } });
+Object.defineProperty(exports, "normalizeLatestToTicker", { enumerable: true, get: function () { return normalizer_1.normalizeLatestToTicker; } });
+Object.defineProperty(exports, "normalizePriceRecordToTicker", { enumerable: true, get: function () { return normalizer_1.normalizePriceRecordToTicker; } });
+Object.defineProperty(exports, "normalizePriceRecordToOracleRound", { enumerable: true, get: function () { return normalizer_1.normalizePriceRecordToOracleRound; } });
+Object.defineProperty(exports, "normalizeWsEventToTicker", { enumerable: true, get: function () { return normalizer_1.normalizeWsEventToTicker; } });
+Object.defineProperty(exports, "normalizeWsEventToOracleRound", { enumerable: true, get: function () { return normalizer_1.normalizeWsEventToOracleRound; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "CHAINLINK_DEFAULTS", { enumerable: true, get: function () { return types_1.CHAINLINK_DEFAULTS; } });
+Object.defineProperty(exports, "SUPPORTED_TOKENS", { enumerable: true, get: function () { return types_1.SUPPORTED_TOKENS; } });
+Object.defineProperty(exports, "TOKEN_BY_SHORT", { enumerable: true, get: function () { return types_1.TOKEN_BY_SHORT; } });
+Object.defineProperty(exports, "TOKEN_BY_PAIR", { enumerable: true, get: function () { return types_1.TOKEN_BY_PAIR; } });

package/dist/feeds/chainlink/normalizer.d.ts

@@ -0,0 +1,9 @@
+import { Ticker, OracleRound } from '../types';
+import { IFeedNormalizer } from '../interfaces';
+import { ChainlinkLatestPriceRecord, ChainlinkPriceRecord, ChainlinkWsEvent } from './types';
+export declare const chainlinkNormalizer: IFeedNormalizer<ChainlinkLatestPriceRecord, ChainlinkPriceRecord>;
+export declare function normalizeLatestToTicker(raw: ChainlinkLatestPriceRecord, now: number): Ticker;
+export declare function normalizePriceRecordToTicker(raw: ChainlinkPriceRecord): Ticker;
+export declare function normalizePriceRecordToOracleRound(raw: ChainlinkPriceRecord): OracleRound;
+export declare function normalizeWsEventToTicker(event: ChainlinkWsEvent): Ticker;
+export declare function normalizeWsEventToOracleRound(event: ChainlinkWsEvent): OracleRound;

package/dist/feeds/chainlink/normalizer.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainlinkNormalizer = void 0;
+exports.normalizeLatestToTicker = normalizeLatestToTicker;
+exports.normalizePriceRecordToTicker = normalizePriceRecordToTicker;
+exports.normalizePriceRecordToOracleRound = normalizePriceRecordToOracleRound;
+exports.normalizeWsEventToTicker = normalizeWsEventToTicker;
+exports.normalizeWsEventToOracleRound = normalizeWsEventToOracleRound;
+const types_1 = require("./types");
+// ----------------------------------------------------------------------------
+// Chainlink normalizer — produces CCXT-compatible Ticker and OracleRound.
+// ----------------------------------------------------------------------------
+function makeTicker(symbol, price, timestamp, info) {
+    return {
+        symbol,
+        info,
+        timestamp,
+        datetime: new Date(timestamp).toISOString(),
+        high: undefined,
+        low: undefined,
+        bid: undefined,
+        bidVolume: undefined,
+        ask: undefined,
+        askVolume: undefined,
+        vwap: undefined,
+        open: undefined,
+        close: undefined,
+        last: price,
+        previousClose: undefined,
+        change: undefined,
+        percentage: undefined,
+        average: undefined,
+        quoteVolume: undefined,
+        baseVolume: undefined,
+        indexPrice: undefined,
+        markPrice: undefined,
+    };
+}
+exports.chainlinkNormalizer = {
+    normalizeTicker(raw) {
+        if (raw.price === null || raw.price === undefined) {
+            throw new Error(`Chainlink returned null price for token=${raw.token}`);
+        }
+        const token = types_1.TOKEN_BY_SHORT.get(raw.token.toLowerCase());
+        return makeTicker(token?.pair ?? `${raw.token.toUpperCase()}/USD`, raw.price, Date.now(), raw);
+    },
+};
+function normalizeLatestToTicker(raw, now) {
+    if (raw.price === null || raw.price === undefined) {
+        throw new Error(`Chainlink returned null price for token=${raw.token}`);
+    }
+    const token = types_1.TOKEN_BY_SHORT.get(raw.token.toLowerCase());
+    return makeTicker(token?.pair ?? `${raw.token.toUpperCase()}/USD`, raw.price, now, raw);
+}
+function normalizePriceRecordToTicker(raw) {
+    if (raw.price === null || raw.price === undefined) {
+        throw new Error(`Chainlink returned null price for token=${raw.token} at timestamp=${raw.timestamp}`);
+    }
+    const token = types_1.TOKEN_BY_SHORT.get(raw.token.toLowerCase());
+    return makeTicker(token?.pair ?? `${raw.token.toUpperCase()}/USD`, raw.price, raw.timestamp * 1000, raw);
+}
+function normalizePriceRecordToOracleRound(raw) {
+    if (raw.price === null || raw.price === undefined) {
+        throw new Error(`Chainlink returned null price for token=${raw.token} at timestamp=${raw.timestamp}`);
+    }
+    const token = types_1.TOKEN_BY_SHORT.get(raw.token.toLowerCase());
+    const decimals = token?.decimals ?? 8;
+    return {
+        feed: token?.pair ?? `${raw.token.toUpperCase()}/USD`,
+        roundId: String(raw.timestamp),
+        answer: raw.price,
+        startedAt: raw.timestamp,
+        updatedAt: raw.timestamp,
+        answeredInRound: String(raw.timestamp),
+        decimals,
+        description: token
+            ? `${token.base} / ${token.quote} on Polygon`
+            : undefined,
+    };
+}
+function normalizeWsEventToTicker(event) {
+    return makeTicker(event.symbol, event.price, event.updated_at * 1000, event);
+}
+function normalizeWsEventToOracleRound(event) {
+    const token = types_1.TOKEN_BY_PAIR.get(event.symbol);
+    const decimals = token?.decimals ?? 8;
+    return {
+        feed: event.symbol,
+        roundId: String(event.round_id),
+        answer: event.price,
+        startedAt: event.updated_at,
+        updatedAt: event.updated_at,
+        answeredInRound: String(event.round_id),
+        decimals,
+        description: token
+            ? `${token.base} / ${token.quote} on Polygon`
+            : undefined,
+    };
+}

package/dist/feeds/chainlink/types.d.ts

@@ -0,0 +1,75 @@
+export interface ChainlinkLatestPriceRecord {
+    readonly token: string;
+    readonly price: number | null;
+}
+export interface ChainlinkLatestPricesResponse {
+    readonly data: readonly ChainlinkLatestPriceRecord[];
+}
+export interface ChainlinkPriceRecord {
+    readonly timestamp: number;
+    readonly date: string;
+    readonly token: string;
+    readonly price: number | null;
+}
+export interface ChainlinkPricesResponse {
+    readonly data: readonly ChainlinkPriceRecord[];
+}
+export interface ChainlinkFeedConfig {
+    /** Base URL for the Chainlink REST API. */
+    readonly baseUrl?: string;
+    /** API key for REST authentication (X-API-Key header). */
+    readonly apiKey: string;
+    /** WebSocket URL for live Chainlink events. */
+    readonly wsUrl?: string;
+    /** API key for WebSocket authentication (may differ from REST key). */
+    readonly wsApiKey?: string;
+    /** Reconnect interval in ms (default: 5000). */
+    readonly reconnectIntervalMs?: number;
+}
+export declare const CHAINLINK_DEFAULTS: {
+    readonly baseUrl: string;
+    readonly wsUrl: string;
+    readonly reconnectIntervalMs: 5000;
+};
+export interface ChainlinkToken {
+    readonly short: string;
+    readonly pair: string;
+    readonly base: string;
+    readonly quote: string;
+    readonly proxyAddress: string;
+    readonly decimals: number;
+}
+export declare const SUPPORTED_TOKENS: readonly ChainlinkToken[];
+/** Map short token name -> token metadata. */
+export declare const TOKEN_BY_SHORT: Map<string, ChainlinkToken>;
+/** Map pair string (e.g. "ETH/USD") -> token metadata. */
+export declare const TOKEN_BY_PAIR: Map<string, ChainlinkToken>;
+export interface ChainlinkWsEvent {
+    readonly op: 'event';
+    readonly source: 'chainlink';
+    readonly chain: string;
+    readonly symbol: string;
+    readonly aggregator: string;
+    readonly round_id: number;
+    readonly price: number;
+    readonly updated_at: number;
+    readonly block_number: number;
+    readonly log_index: number;
+    readonly tx_hash: string;
+}
+export interface ChainlinkWsAck {
+    readonly op: 'ack';
+    readonly subscribed_all?: boolean;
+    readonly subscribed?: readonly string[];
+    readonly unsubscribed_all?: boolean;
+    readonly unsubscribed?: readonly string[];
+}
+export interface ChainlinkWsError {
+    readonly op: 'error';
+    readonly code: string;
+    readonly reason: string;
+}
+export interface ChainlinkWsPong {
+    readonly op: 'pong';
+}
+export type ChainlinkWsMessage = ChainlinkWsEvent | ChainlinkWsAck | ChainlinkWsError | ChainlinkWsPong;

package/dist/feeds/chainlink/types.js

@@ -0,0 +1,51 @@
+"use strict";
+// ----------------------------------------------------------------------------
+// Chainlink Price Feed — raw API types and configuration
+// REST: https://github.com/pmxt-dev/pmxt-ohlc/blob/main/docs/CHAINLINK_API.md
+// WS:   https://github.com/pmxt-dev/pmxt-ohlc/blob/main/docs/CHAINLINK_WS.md
+// ----------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_BY_PAIR = exports.TOKEN_BY_SHORT = exports.SUPPORTED_TOKENS = exports.CHAINLINK_DEFAULTS = void 0;
+exports.CHAINLINK_DEFAULTS = {
+    baseUrl: process.env.CHAINLINK_API_URL || '',
+    wsUrl: process.env.CHAINLINK_WS_URL || '',
+    reconnectIntervalMs: 5000,
+};
+exports.SUPPORTED_TOKENS = [
+    {
+        short: 'eth',
+        pair: 'ETH/USD',
+        base: 'ETH',
+        quote: 'USD',
+        proxyAddress: '0xF9680D99D6C9589e2a93a78A04A279e509205945',
+        decimals: 8,
+    },
+    {
+        short: 'btc',
+        pair: 'BTC/USD',
+        base: 'BTC',
+        quote: 'USD',
+        proxyAddress: '0xc907E116054Ad103354f2D350FD2514433D57F6f',
+        decimals: 8,
+    },
+    {
+        short: 'xrp',
+        pair: 'XRP/USD',
+        base: 'XRP',
+        quote: 'USD',
+        proxyAddress: '0x785ba89291f676b5386652eB12b30cF361020694',
+        decimals: 8,
+    },
+    {
+        short: 'sol',
+        pair: 'SOL/USD',
+        base: 'SOL',
+        quote: 'USD',
+        proxyAddress: '0x10C8264C0935b3B9870013e057f330Ff3e9C56dC',
+        decimals: 8,
+    },
+];
+/** Map short token name -> token metadata. */
+exports.TOKEN_BY_SHORT = new Map(exports.SUPPORTED_TOKENS.map((t) => [t.short, t]));
+/** Map pair string (e.g. "ETH/USD") -> token metadata. */
+exports.TOKEN_BY_PAIR = new Map(exports.SUPPORTED_TOKENS.map((t) => [t.pair, t]));

package/dist/feeds/index.d.ts

@@ -0,0 +1,6 @@
+export type { IDataFeed, IFeedNormalizer } from './interfaces';
+export { BaseDataFeed } from './base-feed';
+export type { DataFeedOptions } from './base-feed';
+export type { Dictionary, Ticker, Tickers, OHLCV, OrderBook as FeedOrderBook, Market as FeedMarket, FundingRate, FundingRates, OracleRound, OracleParams, } from './types';
+export * from './binance';
+export * from './chainlink';

package/dist/feeds/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseDataFeed = void 0;
+var base_feed_1 = require("./base-feed");
+Object.defineProperty(exports, "BaseDataFeed", { enumerable: true, get: function () { return base_feed_1.BaseDataFeed; } });
+__exportStar(require("./binance"), exports);
+__exportStar(require("./chainlink"), exports);

package/dist/feeds/interfaces.d.ts

@@ -0,0 +1,23 @@
+import { Ticker, Tickers, OHLCV, OrderBook, Market, FundingRate, FundingRates, OracleRound, OracleParams, Dictionary } from './types';
+export interface IDataFeed {
+    readonly name: string;
+    readonly description: string;
+    loadMarkets(reload?: boolean): Promise<Dictionary<Market>>;
+    fetchTicker(symbol: string): Promise<Ticker>;
+    fetchTickers(symbols?: string[]): Promise<Tickers>;
+    watchTicker(symbol: string, callback: (ticker: Ticker) => void): () => void;
+    fetchOHLCV(symbol: string, timeframe?: string, since?: number, limit?: number): Promise<OHLCV[]>;
+    fetchOrderBook?(symbol: string, limit?: number): Promise<OrderBook>;
+    watchOrderBook?(symbol: string, callback: (book: OrderBook) => void): () => void;
+    fetchFundingRate?(symbol: string): Promise<FundingRate>;
+    fetchFundingRates?(symbols?: string[]): Promise<FundingRates>;
+    fetchOracleRound?(params: OracleParams): Promise<OracleRound>;
+    fetchOracleHistory?(params: OracleParams): Promise<OracleRound[]>;
+    connect?(): Promise<void>;
+    close?(): Promise<void>;
+}
+export interface IFeedNormalizer<TRawTick = unknown, TRawCandle = unknown, TRawBook = unknown> {
+    normalizeTicker(raw: TRawTick): Ticker;
+    normalizeOHLCV?(raw: TRawCandle): OHLCV;
+    normalizeOrderBook?(raw: TRawBook): OrderBook;
+}

package/dist/feeds/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/feeds/types.d.ts

@@ -0,0 +1,123 @@
+export interface Dictionary<T> {
+    [key: string]: T;
+}
+/**
+ * CCXT-compatible Ticker structure.
+ * Fields that a feed cannot populate are left undefined.
+ */
+export interface Ticker {
+    symbol: string;
+    info: any;
+    timestamp: number | undefined;
+    datetime: string | undefined;
+    high: number | undefined;
+    low: number | undefined;
+    bid: number | undefined;
+    bidVolume: number | undefined;
+    ask: number | undefined;
+    askVolume: number | undefined;
+    vwap: number | undefined;
+    open: number | undefined;
+    close: number | undefined;
+    last: number | undefined;
+    previousClose: number | undefined;
+    change: number | undefined;
+    percentage: number | undefined;
+    average: number | undefined;
+    quoteVolume: number | undefined;
+    baseVolume: number | undefined;
+    indexPrice: number | undefined;
+    markPrice: number | undefined;
+}
+export type Tickers = Dictionary<Ticker>;
+/**
+ * CCXT-compatible OHLCV tuple.
+ * [timestamp, open, high, low, close, volume]
+ */
+export type OHLCV = [number, number, number, number, number, number];
+/**
+ * CCXT-compatible OrderBook structure.
+ */
+export interface OrderBook {
+    asks: [number, number][];
+    bids: [number, number][];
+    datetime: string | undefined;
+    timestamp: number | undefined;
+    nonce: number | undefined;
+    symbol: string | undefined;
+}
+/**
+ * CCXT-compatible Market structure (simplified for feeds).
+ */
+export interface Market {
+    id: string;
+    symbol: string;
+    base: string;
+    quote: string;
+    active: boolean;
+    type: string;
+    spot: boolean;
+    margin: boolean;
+    swap: boolean;
+    future: boolean;
+    option: boolean;
+    contract: boolean;
+    precision: {
+        amount: number | undefined;
+        price: number | undefined;
+    };
+    limits: {
+        amount?: {
+            min: number | undefined;
+            max: number | undefined;
+        };
+        cost?: {
+            min: number | undefined;
+            max: number | undefined;
+        };
+        price?: {
+            min: number | undefined;
+            max: number | undefined;
+        };
+    };
+    info: any;
+}
+/**
+ * CCXT-compatible FundingRate structure.
+ */
+export interface FundingRate {
+    symbol: string;
+    info: any;
+    timestamp?: number;
+    datetime?: string;
+    fundingRate?: number;
+    markPrice?: number;
+    indexPrice?: number;
+    interestRate?: number;
+    fundingTimestamp?: number;
+    fundingDatetime?: string;
+    nextFundingTimestamp?: number;
+    nextFundingDatetime?: string;
+    nextFundingRate?: number;
+    previousFundingRate?: number;
+    interval?: string;
+}
+export type FundingRates = Dictionary<FundingRate>;
+/**
+ * ChainLink oracle price round (pmxt-specific).
+ */
+export interface OracleRound {
+    feed: string;
+    roundId: string;
+    answer: number;
+    startedAt: number;
+    updatedAt: number;
+    answeredInRound: string;
+    decimals: number;
+    description?: string;
+}
+export interface OracleParams {
+    feed: string;
+    roundId?: string;
+    limit?: number;
+}