tardis-dev/dist/mappers/gateio.d.ts

Convenient access to tick-level historical and real-time cryptocurrency market data via Node.js

import { CircularBuffer } from '../handy';
import { BookChange, BookTicker, Exchange, Trade } from '../types';
import { Mapper } from './mapper';
export declare class GateIOV4BookChangeMapper implements Mapper<'gate-io', BookChange> {
    protected readonly exchange: Exchange;
    protected readonly ignoreBookSnapshotOverlapError: boolean;
    protected readonly symbolToDepthInfoMapping: {
        [key: string]: LocalDepthInfo;
    };
    constructor(exchange: Exchange, ignoreBookSnapshotOverlapError: boolean);
    canHandle(message: GateV4OrderBookUpdate | Gatev4OrderBookSnapshot): boolean;
    getFilters(symbols?: string[]): {
        readonly channel: "order_book_update";
        readonly symbols: string[] | undefined;
    }[];
    map(message: GateV4OrderBookUpdate | Gatev4OrderBookSnapshot, localTimestamp: Date): Generator<BookChange, void, unknown>;
    protected mapBookDepthUpdate(depthUpdateData: DepthData, localTimestamp: Date): BookChange | undefined;
    protected mapBookLevel(level: [string, string]): {
        price: number;
        amount: number;
    };
}
export declare class GateIOV4BookTickerMapper implements Mapper<'gate-io', BookTicker> {
    private readonly _exchange;
    constructor(_exchange: Exchange);
    canHandle(message: GateV4BookTicker): boolean;
    getFilters(symbols?: string[]): {
        readonly channel: "book_ticker";
        readonly symbols: string[] | undefined;
    }[];
    map(bookTickerResponse: GateV4BookTicker, localTimestamp: Date): Generator<BookTicker, void, unknown>;
}
export declare class GateIOV4TradesMapper implements Mapper<'gate-io', Trade> {
    private readonly _exchange;
    constructor(_exchange: Exchange);
    canHandle(message: GateV4Trade): boolean;
    getFilters(symbols?: string[]): {
        readonly channel: "trades";
        readonly symbols: string[] | undefined;
    }[];
    map(tradesMessage: GateV4Trade, localTimestamp: Date): IterableIterator<Trade>;
}
export declare class GateIOTradesMapper implements Mapper<'gate-io', Trade> {
    private readonly _exchange;
    private readonly _seenSymbols;
    constructor(_exchange: Exchange);
    canHandle(message: any): boolean;
    getFilters(symbols?: string[]): {
        readonly channel: "trades";
        readonly symbols: string[] | undefined;
    }[];
    map(tradesMessage: GateIOTrades, localTimestamp: Date): IterableIterator<Trade>;
}
export declare class GateIOBookChangeMapper implements Mapper<'gate-io', BookChange> {
    private readonly _exchange;
    constructor(_exchange: Exchange);
    canHandle(message: any): boolean;
    getFilters(symbols?: string[]): {
        readonly channel: "depth";
        readonly symbols: string[] | undefined;
    }[];
    map(depthMessage: GateIODepth, localTimestamp: Date): IterableIterator<BookChange>;
}
type GateIOTrade = {
    id: number;
    time: number;
    price: string;
    amount: string;
    type: 'sell' | 'buy';
};
type GateIOTrades = {
    method: 'trades.update';
    params: [string, GateIOTrade[]];
};
type GateIODepthLevel = [string, string];
type GateIODepth = {
    method: 'depth.update';
    params: [
        boolean,
        {
            bids?: GateIODepthLevel[];
            asks?: GateIODepthLevel[];
            current: 1669860180.632;
            update: 1669860180.632;
        },
        string
    ];
};
type GateV4Trade = {
    time: 1682689046;
    time_ms: 1682689046133;
    channel: 'spot.trades';
    event: 'update';
    result: {
        id: 5541729596;
        create_time: 1682689046;
        create_time_ms: '1682689046123.0';
        side: 'sell';
        currency_pair: 'SUSD_USDT';
        amount: '8.5234';
        price: '0.9782';
    };
};
type GateV4BookTicker = {
    time: 1682689046;
    time_ms: 1682689046142;
    channel: 'spot.book_ticker';
    event: 'update';
    result: {
        t: 1682689046131;
        u: 517377894;
        s: 'ETC_ETH';
        b: '0.010326';
        B: '0.001';
        a: '0.010366';
        A: '10';
    };
};
type Gatev4OrderBookSnapshot = {
    channel: 'spot.order_book_update';
    event: 'snapshot';
    generated: true;
    symbol: '1ART_USDT';
    result: {
        id: 154857784;
        current: 1682689045318;
        update: 1682689045056;
        asks: [string, string][];
        bids: [string, string][];
    };
};
type GateV4OrderBookUpdate = {
    time: 1682689045;
    time_ms: 1682689045532;
    channel: 'spot.order_book_update';
    event: 'update';
    result: {
        lastUpdateId: undefined;
        t: 1682689045424;
        e: 'depthUpdate';
        E: 1682689045;
        s: '1ART_USDT';
        U: 154857785;
        u: 154857785;
        b: [string, string][];
        a: [string, string][];
    };
};
type LocalDepthInfo = {
    bufferedUpdates: CircularBuffer<DepthData>;
    snapshotProcessed?: boolean;
    lastUpdateId?: number;
    validatedFirstUpdate?: boolean;
};
type DepthData = {
    lastUpdateId: undefined;
    t: number;
    s: string;
    U: number;
    u: number;
    b: [string, string][];
    a: [string, string][];
};
export {};
//# sourceMappingURL=gateio.d.ts.map