pmxt-core 2.23.0 → 2.25.0

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

@@ -0,0 +1,56 @@
+import { ExchangeCredentials } from '../../BaseExchange';
+/**
+ * Manages Smarkets session-based authentication.
+ *
+ * Authentication flow:
+ * 1. POST /v3/sessions/ with username (email) and password to obtain a session token.
+ * 2. If the response `factor` is 'totp', POST /v3/sessions/verify/ with the TOTP code.
+ * 3. Once complete, use the token in the Authorization header as `Session-Token <token>`.
+ *
+ * This class does NOT make HTTP calls directly. The exchange index.ts handles the
+ * async login flow via callApi and calls `setToken()` with the result.
+ * `getHeaders()` returns the session token header synchronously.
+ */
+export declare class SmarketsAuth {
+    private readonly credentials;
+    private sessionToken;
+    private tokenExpiry;
+    constructor(credentials: ExchangeCredentials);
+    private validateCredentials;
+    /**
+     * Returns the username (email) used for session creation.
+     */
+    getUsername(): string;
+    /**
+     * Returns the password used for session creation.
+     */
+    getPassword(): string;
+    /**
+     * Stores the session token and its expiry after a successful login.
+     *
+     * @param token  The session token returned by /v3/sessions/.
+     * @param expiry The `stop` datetime string from the API response (ISO 8601).
+     */
+    setToken(token: string, expiry: string): void;
+    /**
+     * Returns true if the session token is present and has not expired.
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Returns true if the token has expired or is about to expire.
+     */
+    isExpired(): boolean;
+    /**
+     * Generates the required headers for an authenticated request.
+     *
+     * @param _method The HTTP method (unused, kept for interface consistency with sign()).
+     * @param _path   The request path (unused, kept for interface consistency with sign()).
+     * @returns An object containing the Authorization header with the session token.
+     * @throws Error if no valid session token is available.
+     */
+    getHeaders(_method: string, _path: string): Record<string, string>;
+    /**
+     * Clears the stored session token (e.g. after logout or for testing).
+     */
+    reset(): void;
+}

package/dist/exchanges/smarkets/auth.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmarketsAuth = void 0;
+/** Default session TTL in milliseconds (30 minutes). */
+const SESSION_TTL_MS = 30 * 60 * 1000;
+/** Safety margin subtracted from TTL to avoid using an about-to-expire token. */
+const EXPIRY_MARGIN_MS = 60 * 1000;
+/**
+ * Manages Smarkets session-based authentication.
+ *
+ * Authentication flow:
+ * 1. POST /v3/sessions/ with username (email) and password to obtain a session token.
+ * 2. If the response `factor` is 'totp', POST /v3/sessions/verify/ with the TOTP code.
+ * 3. Once complete, use the token in the Authorization header as `Session-Token <token>`.
+ *
+ * This class does NOT make HTTP calls directly. The exchange index.ts handles the
+ * async login flow via callApi and calls `setToken()` with the result.
+ * `getHeaders()` returns the session token header synchronously.
+ */
+class SmarketsAuth {
+    credentials;
+    sessionToken = null;
+    tokenExpiry = 0;
+    constructor(credentials) {
+        this.credentials = credentials;
+        this.validateCredentials();
+    }
+    validateCredentials() {
+        if (!this.credentials.apiKey) {
+            throw new Error('Smarkets requires an apiKey (email address) for authentication');
+        }
+        if (!this.credentials.privateKey) {
+            throw new Error('Smarkets requires a privateKey (account password) for authentication');
+        }
+    }
+    /**
+     * Returns the username (email) used for session creation.
+     */
+    getUsername() {
+        return this.credentials.apiKey;
+    }
+    /**
+     * Returns the password used for session creation.
+     */
+    getPassword() {
+        return this.credentials.privateKey;
+    }
+    /**
+     * Stores the session token and its expiry after a successful login.
+     *
+     * @param token  The session token returned by /v3/sessions/.
+     * @param expiry The `stop` datetime string from the API response (ISO 8601).
+     */
+    setToken(token, expiry) {
+        this.sessionToken = token;
+        const expiryTime = new Date(expiry).getTime();
+        if (isNaN(expiryTime)) {
+            // Fall back to a 30-minute TTL from now if the expiry cannot be parsed.
+            this.tokenExpiry = Date.now() + SESSION_TTL_MS - EXPIRY_MARGIN_MS;
+        }
+        else {
+            this.tokenExpiry = expiryTime - EXPIRY_MARGIN_MS;
+        }
+    }
+    /**
+     * Returns true if the session token is present and has not expired.
+     */
+    isAuthenticated() {
+        return this.sessionToken !== null && Date.now() < this.tokenExpiry;
+    }
+    /**
+     * Returns true if the token has expired or is about to expire.
+     */
+    isExpired() {
+        if (this.sessionToken === null) {
+            return true;
+        }
+        return Date.now() >= this.tokenExpiry;
+    }
+    /**
+     * Generates the required headers for an authenticated request.
+     *
+     * @param _method The HTTP method (unused, kept for interface consistency with sign()).
+     * @param _path   The request path (unused, kept for interface consistency with sign()).
+     * @returns An object containing the Authorization header with the session token.
+     * @throws Error if no valid session token is available.
+     */
+    getHeaders(_method, _path) {
+        if (!this.sessionToken) {
+            throw new Error('Smarkets session token is not set. Call the login endpoint first.');
+        }
+        return {
+            'Authorization': `Session-Token ${this.sessionToken}`,
+            'Content-Type': 'application/json',
+        };
+    }
+    /**
+     * Clears the stored session token (e.g. after logout or for testing).
+     */
+    reset() {
+        this.sessionToken = null;
+        this.tokenExpiry = 0;
+    }
+}
+exports.SmarketsAuth = SmarketsAuth;

package/dist/exchanges/smarkets/config.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Smarkets runtime configuration.
+ *
+ * This file is hand-authored and is the single source of truth for:
+ *  - Base URL constant
+ *  - API path constants (SMARKETS_PATHS)
+ *  - Config interface and factory
+ *
+ * The OpenAPI spec lives in core/specs/smarkets/Smarkets.yaml and is compiled
+ * into core/src/exchanges/smarkets/api.ts by `npm run fetch:openapi`.
+ * Do NOT put runtime config into api.ts -- it will be overwritten.
+ */
+export declare const SMARKETS_BASE_URL = "https://api.smarkets.com";
+export declare const SMARKETS_PATHS: {
+    SESSIONS: string;
+    SESSIONS_VERIFY: string;
+    ACCOUNTS: string;
+    ACCOUNTS_ACTIVITY: string;
+    ACCOUNT_ACTIVITY_CSV: string;
+    CURRENCIES: string;
+    EVENTS: string;
+    EVENTS_COMPETITORS: string;
+    EVENTS_MARKETS: string;
+    EVENTS_MARKETS_COUNT: string;
+    EVENTS_STATES: string;
+    MARKETS_CONTRACTS: string;
+    MARKETS_LAST_EXECUTED_PRICES: string;
+    MARKETS_QUOTES: string;
+    MARKETS_VOLUMES: string;
+    ORDERS: string;
+    ORDERS_FULLCOVER: string;
+    ORDERS_BY_ID: string;
+};
+export interface SmarketsApiConfig {
+    /** Base REST API URL */
+    apiUrl: string;
+}
+/**
+ * Return a typed config object for the Smarkets API.
+ */
+export declare function getSmarketsConfig(): SmarketsApiConfig;

package/dist/exchanges/smarkets/config.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Smarkets runtime configuration.
+ *
+ * This file is hand-authored and is the single source of truth for:
+ *  - Base URL constant
+ *  - API path constants (SMARKETS_PATHS)
+ *  - Config interface and factory
+ *
+ * The OpenAPI spec lives in core/specs/smarkets/Smarkets.yaml and is compiled
+ * into core/src/exchanges/smarkets/api.ts by `npm run fetch:openapi`.
+ * Do NOT put runtime config into api.ts -- it will be overwritten.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMARKETS_PATHS = exports.SMARKETS_BASE_URL = void 0;
+exports.getSmarketsConfig = getSmarketsConfig;
+// -- Base URL constant --------------------------------------------------------
+exports.SMARKETS_BASE_URL = "https://api.smarkets.com";
+// -- Path constants -----------------------------------------------------------
+exports.SMARKETS_PATHS = {
+    SESSIONS: "/v3/sessions/",
+    SESSIONS_VERIFY: "/v3/sessions/verify/",
+    ACCOUNTS: "/v3/accounts/",
+    ACCOUNTS_ACTIVITY: "/v3/accounts/activity/",
+    ACCOUNT_ACTIVITY_CSV: "/v3/account_activity_csv/{start_datetime}/{end_datetime}/",
+    CURRENCIES: "/v3/currencies/{code}/",
+    EVENTS: "/v3/events/",
+    EVENTS_COMPETITORS: "/v3/events/{event_ids}/competitors/",
+    EVENTS_MARKETS: "/v3/events/{event_ids}/markets/",
+    EVENTS_MARKETS_COUNT: "/v3/events/{event_ids}/markets_count/",
+    EVENTS_STATES: "/v3/events/{event_ids}/states/",
+    MARKETS_CONTRACTS: "/v3/markets/{market_ids}/contracts/",
+    MARKETS_LAST_EXECUTED_PRICES: "/v3/markets/{market_ids}/last_executed_prices/",
+    MARKETS_QUOTES: "/v3/markets/{market_ids}/quotes/",
+    MARKETS_VOLUMES: "/v3/markets/{market_ids}/volumes/",
+    ORDERS: "/v3/orders/",
+    ORDERS_FULLCOVER: "/v3/orders/fullcover/",
+    ORDERS_BY_ID: "/v3/orders/{order_id}/",
+};
+/**
+ * Return a typed config object for the Smarkets API.
+ */
+function getSmarketsConfig() {
+    return {
+        apiUrl: exports.SMARKETS_BASE_URL,
+    };
+}

package/dist/exchanges/smarkets/errors.d.ts

@@ -0,0 +1,31 @@
+import { ErrorMapper } from '../../utils/error-mapper';
+import { BadRequest } from '../../errors';
+/**
+ * Smarkets-specific error mapper
+ *
+ * Handles Smarkets API error patterns where errors use an error_type
+ * field to identify the error category.
+ */
+export declare class SmarketsErrorMapper extends ErrorMapper {
+    constructor();
+    /**
+     * Override to handle the Smarkets { error_type, data } format
+     */
+    protected extractErrorMessage(error: any): string;
+    /**
+     * Override to map Smarkets error_type values before falling back
+     * to the default status-code-based mapping
+     */
+    mapError(error: any): ReturnType<ErrorMapper['mapError']>;
+    /**
+     * Override to detect order-specific errors within 400 responses
+     */
+    protected mapBadRequestError(message: string, data: any): BadRequest;
+    /**
+     * Maps a Smarkets error_type string to a PMXT error class.
+     * Returns undefined if the error_type is not recognized, allowing
+     * the base class to handle it via HTTP status code.
+     */
+    private mapByErrorType;
+}
+export declare const smarketsErrorMapper: SmarketsErrorMapper;

package/dist/exchanges/smarkets/errors.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.smarketsErrorMapper = exports.SmarketsErrorMapper = void 0;
+const axios_1 = __importDefault(require("axios"));
+const error_mapper_1 = require("../../utils/error-mapper");
+const errors_1 = require("../../errors");
+/**
+ * Maps Smarkets error_type values to PMXT error classes.
+ *
+ * Smarkets errors follow the format:
+ *   { "error_type": "ERROR_CODE", "data": "message or object" }
+ */
+const AUTHENTICATION_ERRORS = new Set([
+    'INVALID_CREDENTIALS',
+    'PASSWORD_RESET_NEEDED',
+    'AUTH_REQUIRED',
+]);
+const RATE_LIMIT_ERRORS = new Set([
+    'RATE_LIMIT_EXCEEDED',
+    'EVENTS_API_RATE_LIMIT',
+]);
+const PERMISSION_DENIED_ERRORS = new Set([
+    'USER_EXCLUDED',
+    'USER_SUSPENDED',
+    'SOURCE_BLOCKED',
+    'IP_NOT_TRUSTED',
+    'CLIENT_JURISDICTION_MISMATCH',
+    'COUNTRY_BLOCKED',
+    'FORBIDDEN',
+    'ACCOUNT_UNVERIFIED',
+]);
+const INSUFFICIENT_FUNDS_ERRORS = new Set([
+    'ORDER_REJECTED_INSUFFICIENT_FUNDS',
+]);
+const INVALID_ORDER_ERRORS = new Set([
+    'ORDER_INVALID_INVALID_PRICE',
+    'ORDER_INVALID_INVALID_QUANTITY',
+    'ORDER_REJECTED_CROSSED_SELF',
+    'ORDER_REJECTED_LIMIT_EXCEEDED',
+    'ORDER_REJECTED_STAKE_LIMIT_EXCEEDED',
+    'ORDER_REJECTED_CAPACITY_REACHED',
+    'ORDER_REJECTED_CONTRACT_SETTLED',
+    'ORDER_REJECTED_MARKET_SETTLED',
+    'ORDER_REJECTED_MARKET_NOT_OPEN',
+    'ORDER_REJECTED_MARKET_HALTED',
+    'ORDER_CANCELLED_MARKET_HALTED',
+    'ORDER_REJECTED_TRADING_SUSPENDED',
+    'ORDER_CANCELLED_TRADING_SUSPENDED',
+    'ORDER_REJECTED_ACCOUNT_SUSPENDED',
+    'ORDER_REJECTED_THROTTLE_EXCEEDED',
+]);
+const MARKET_NOT_FOUND_ERRORS = new Set([
+    'ORDER_REJECTED_MARKET_NOT_FOUND',
+    'ORDER_REJECTED_CONTRACT_NOT_FOUND',
+]);
+const ORDER_NOT_FOUND_ERRORS = new Set([
+    'ORDER_CANCEL_REJECTED_NOT_FOUND',
+]);
+const UNAVAILABLE_ERRORS = new Set([
+    'INTERNAL_ERROR',
+    'FOREX_SERVICE_INTERNAL_ERROR',
+    'KYC_SERVICE_INTERNAL_ERROR',
+    'MDS_SERVICE_UNAVAILABLE',
+    'RECKONATOR_UNAVAILABLE',
+    'AUTH_UNAVAILABLE',
+    'ZEUS_CONNECTION_ERROR',
+    'ZEUS_TIMEOUT',
+    'ORDER_REJECTED_SERVICE_TEMPORARILY_UNAVAILABLE',
+]);
+/**
+ * Smarkets-specific error mapper
+ *
+ * Handles Smarkets API error patterns where errors use an error_type
+ * field to identify the error category.
+ */
+class SmarketsErrorMapper extends error_mapper_1.ErrorMapper {
+    constructor() {
+        super('Smarkets');
+    }
+    /**
+     * Override to handle the Smarkets { error_type, data } format
+     */
+    extractErrorMessage(error) {
+        if (axios_1.default.isAxiosError(error) && error.response?.data) {
+            const body = error.response.data;
+            const errorType = body.error_type;
+            const data = body.data;
+            if (errorType) {
+                const status = error.response.status;
+                const detail = typeof data === 'string'
+                    ? data
+                    : data != null
+                        ? JSON.stringify(data)
+                        : '';
+                return detail
+                    ? `[${status}] ${errorType}: ${detail}`
+                    : `[${status}] ${errorType}`;
+            }
+        }
+        return super.extractErrorMessage(error);
+    }
+    /**
+     * Override to map Smarkets error_type values before falling back
+     * to the default status-code-based mapping
+     */
+    mapError(error) {
+        if (axios_1.default.isAxiosError(error) && error.response?.data) {
+            const errorType = error.response.data.error_type;
+            if (errorType) {
+                const message = this.extractErrorMessage(error);
+                const mapped = this.mapByErrorType(errorType, message, error.response);
+                if (mapped) {
+                    return mapped;
+                }
+            }
+        }
+        return super.mapError(error);
+    }
+    /**
+     * Override to detect order-specific errors within 400 responses
+     */
+    mapBadRequestError(message, data) {
+        const errorType = data?.error_type;
+        if (errorType) {
+            if (INSUFFICIENT_FUNDS_ERRORS.has(errorType)) {
+                return new errors_1.InsufficientFunds(message, this.exchangeName);
+            }
+            if (INVALID_ORDER_ERRORS.has(errorType)) {
+                return new errors_1.InvalidOrder(message, this.exchangeName);
+            }
+            if (MARKET_NOT_FOUND_ERRORS.has(errorType)) {
+                return new errors_1.MarketNotFound(errorType, this.exchangeName);
+            }
+            if (ORDER_NOT_FOUND_ERRORS.has(errorType)) {
+                return new errors_1.OrderNotFound(errorType, this.exchangeName);
+            }
+        }
+        return super.mapBadRequestError(message, data);
+    }
+    /**
+     * Maps a Smarkets error_type string to a PMXT error class.
+     * Returns undefined if the error_type is not recognized, allowing
+     * the base class to handle it via HTTP status code.
+     */
+    mapByErrorType(errorType, message, response) {
+        if (AUTHENTICATION_ERRORS.has(errorType)) {
+            return new errors_1.AuthenticationError(message, this.exchangeName);
+        }
+        if (RATE_LIMIT_ERRORS.has(errorType)) {
+            const retryAfter = response?.headers?.['retry-after'];
+            const retryAfterSeconds = retryAfter
+                ? parseInt(retryAfter, 10)
+                : undefined;
+            return new errors_1.RateLimitExceeded(message, retryAfterSeconds, this.exchangeName);
+        }
+        if (PERMISSION_DENIED_ERRORS.has(errorType)) {
+            return new errors_1.PermissionDenied(message, this.exchangeName);
+        }
+        if (INSUFFICIENT_FUNDS_ERRORS.has(errorType)) {
+            return new errors_1.InsufficientFunds(message, this.exchangeName);
+        }
+        if (INVALID_ORDER_ERRORS.has(errorType)) {
+            return new errors_1.InvalidOrder(message, this.exchangeName);
+        }
+        if (MARKET_NOT_FOUND_ERRORS.has(errorType)) {
+            return new errors_1.MarketNotFound(errorType, this.exchangeName);
+        }
+        if (ORDER_NOT_FOUND_ERRORS.has(errorType)) {
+            return new errors_1.OrderNotFound(errorType, this.exchangeName);
+        }
+        if (UNAVAILABLE_ERRORS.has(errorType)) {
+            return new errors_1.ExchangeNotAvailable(message, this.exchangeName);
+        }
+        // Catch-all for any *_UNAVAILABLE or *_TIMEOUT patterns not in the set
+        if (errorType.endsWith('_UNAVAILABLE') || errorType.endsWith('_TIMEOUT')) {
+            return new errors_1.ExchangeNotAvailable(message, this.exchangeName);
+        }
+        return undefined;
+    }
+}
+exports.SmarketsErrorMapper = SmarketsErrorMapper;
+// Export singleton instance for convenience
+exports.smarketsErrorMapper = new SmarketsErrorMapper();

package/dist/exchanges/smarkets/fetcher.d.ts

@@ -0,0 +1,177 @@
+import { MarketFilterParams, EventFetchParams, TradesParams } from '../../BaseExchange';
+import { IExchangeFetcher, FetcherContext } from '../interfaces';
+export interface SmarketsRawEvent {
+    id: string;
+    name: string;
+    description: string | null;
+    slug: string;
+    full_slug: string;
+    state: string;
+    type: string | {
+        domain: string;
+        scope: string;
+    };
+    parent_id: string | null;
+    start_datetime: string | null;
+    start_date: string | null;
+    end_date: string | null;
+    created: string;
+    modified: string;
+    bettable?: boolean;
+    hidden?: boolean;
+    inplay_enabled?: boolean;
+    short_name?: string | null;
+    seo_description?: string | null;
+    special_rules?: string | null;
+    chart_time_period?: string | null;
+    [key: string]: unknown;
+}
+export interface SmarketsRawMarket {
+    id: string;
+    event_id: string;
+    name: string;
+    slug: string;
+    state: string;
+    description: string | null;
+    bet_delay: number;
+    complete: boolean;
+    winner_count: number;
+    hidden: boolean;
+    display_type: string;
+    display_order: number | null;
+    cashout_enabled: boolean;
+    inplay_enabled?: boolean;
+    created: string;
+    modified: string;
+    market_type: {
+        name: string;
+        param?: string;
+        params?: Record<string, string>;
+    } | null;
+    category?: string;
+    categories?: string[];
+    info?: Record<string, unknown> | null;
+    [key: string]: unknown;
+}
+export interface SmarketsRawContract {
+    id: string;
+    market_id: string;
+    name: string;
+    slug: string;
+    state_or_outcome: string;
+    created: string;
+    modified: string;
+    outcome_timestamp: string | null;
+    display_order: number | null;
+    hidden?: boolean;
+    competitor_id?: number | null;
+    contract_type?: {
+        name: string;
+        param?: string;
+    } | null;
+    reduction_factor?: string;
+    info?: {
+        color_primary?: string;
+        color_secondary?: string;
+        primary?: boolean;
+    } | null;
+    [key: string]: unknown;
+}
+export interface SmarketsRawQuote {
+    bids: Array<{
+        price: number;
+        quantity: number;
+    }>;
+    offers: Array<{
+        price: number;
+        quantity: number;
+    }>;
+}
+export interface SmarketsRawOrder {
+    id: string;
+    market_id: string;
+    contract_id: string;
+    side: string;
+    state: string;
+    type: string;
+    price: number;
+    quantity: number;
+    quantity_filled: number;
+    quantity_unfilled: number;
+    created_datetime: string;
+    last_modified_datetime: string;
+    average_price_matched?: number;
+    label?: string | null;
+    [key: string]: unknown;
+}
+export interface SmarketsRawVolume {
+    market_id: string;
+    volume: number;
+    double_stake_volume: number;
+}
+export interface SmarketsRawLastExecutedPrice {
+    contract_id: string;
+    last_executed_price: string | null;
+    timestamp: string | null;
+}
+export interface SmarketsRawBalance {
+    account_id: string;
+    balance: string;
+    available_balance: string;
+    exposure: string;
+    currency: string;
+    bonus_balance?: string;
+    commission_type?: string;
+    signup_date?: string;
+}
+export interface SmarketsRawActivityRow {
+    amount: string | null;
+    commission: string | null;
+    contract_id: string | null;
+    event_id: string | null;
+    market_id: string | null;
+    order_id: string | null;
+    price: number | null;
+    quantity: number | null;
+    quantity_change: number | null;
+    side: string | null;
+    source: string;
+    timestamp: string;
+    seq: number;
+    subseq: number;
+    money: string | null;
+    money_change: string | null;
+    exposure: string | null;
+    label: string | null;
+    [key: string]: unknown;
+}
+export interface SmarketsRawEventWithMarkets {
+    event: SmarketsRawEvent;
+    markets: SmarketsRawMarket[];
+    contracts: SmarketsRawContract[];
+    volumes: SmarketsRawVolume[];
+}
+export declare class SmarketsFetcher implements IExchangeFetcher<SmarketsRawEventWithMarkets, SmarketsRawEventWithMarkets> {
+    private readonly ctx;
+    constructor(ctx: FetcherContext);
+    fetchRawMarkets(params?: MarketFilterParams): Promise<SmarketsRawEventWithMarkets[]>;
+    fetchRawEvents(params: EventFetchParams): Promise<SmarketsRawEventWithMarkets[]>;
+    fetchRawOrderBook(id: string): Promise<Record<string, SmarketsRawQuote>>;
+    fetchRawTradeActivity(marketId: string, _params: TradesParams): Promise<SmarketsRawActivityRow[]>;
+    fetchRawMyTradeActivity(params?: Record<string, any>): Promise<SmarketsRawActivityRow[]>;
+    fetchRawBalance(): Promise<SmarketsRawBalance>;
+    fetchRawOrders(queryParams?: Record<string, any>): Promise<SmarketsRawOrder[]>;
+    fetchRawOrderById(orderId: string): Promise<SmarketsRawOrder>;
+    fetchRawPositions(): Promise<SmarketsRawOrder[]>;
+    fetchRawClosedOrders(params?: Record<string, any>): Promise<SmarketsRawOrder[]>;
+    private fetchEnrichedEventById;
+    private fetchEnrichedEventByMarketId;
+    private fetchAllEnrichedEvents;
+    private enrichEvents;
+    private fetchPaginatedEvents;
+    private fetchMarketsByEventIds;
+    private fetchContractsByMarketIds;
+    private fetchVolumesByMarketIds;
+    private mapEventStatus;
+    private batchArray;
+}