pmxt-core 2.39.1 → 2.40.1

package/dist/exchanges/gemini-titan/index.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiTitanExchange = void 0;
+const BaseExchange_1 = require("../../BaseExchange");
+const errors_1 = require("../../errors");
+const config_1 = require("./config");
+const fetcher_1 = require("./fetcher");
+const normalizer_1 = require("./normalizer");
+const auth_1 = require("./auth");
+const errors_2 = require("./errors");
+const websocket_1 = require("./websocket");
+const utils_1 = require("./utils");
+class GeminiTitanExchange extends BaseExchange_1.PredictionMarketExchange {
+    config;
+    fetcher;
+    normalizer;
+    geminiAuth;
+    geminiWs;
+    constructor(credentials) {
+        const opts = credentials && 'credentials' in credentials
+            ? credentials
+            : { credentials: credentials };
+        super(opts.credentials);
+        this.rateLimit = 200;
+        const sandbox = 'sandbox' in opts ? opts.sandbox : false;
+        this.config = (0, config_1.getGeminiConfig)(opts.credentials?.baseUrl, sandbox);
+        // Initialize auth if apiKey + apiSecret provided (needed for trading)
+        if (opts.credentials?.apiKey && opts.credentials?.apiSecret) {
+            this.geminiAuth = new auth_1.GeminiAuth(opts.credentials);
+        }
+        const ctx = {
+            http: this.http,
+            callApi: this.callApi.bind(this),
+            getHeaders: () => ({}),
+        };
+        this.fetcher = new fetcher_1.GeminiFetcher(ctx, this.config.baseUrl, this.geminiAuth);
+        this.normalizer = new normalizer_1.GeminiNormalizer();
+    }
+    get name() {
+        return 'GeminiTitan';
+    }
+    // -------------------------------------------------------------------------
+    // Auth helpers
+    // -------------------------------------------------------------------------
+    requireAuth() {
+        if (!this.geminiAuth) {
+            throw new errors_1.AuthenticationError('This operation requires authentication. ' +
+                'Initialize GeminiTitanExchange with credentials including apiKey and apiSecret.', 'GeminiTitan');
+        }
+        return this.geminiAuth;
+    }
+    // -------------------------------------------------------------------------
+    // Market Data
+    // -------------------------------------------------------------------------
+    async fetchMarketsImpl(params) {
+        const rawEvents = await this.fetcher.fetchRawMarkets(params);
+        const markets = [];
+        for (const event of rawEvents) {
+            const eventMarkets = this.normalizer.normalizeMarketsFromEvent(event);
+            markets.push(...eventMarkets);
+        }
+        return markets;
+    }
+    async fetchEventsImpl(params) {
+        const rawEvents = await this.fetcher.fetchRawEvents(params);
+        return rawEvents
+            .map(e => this.normalizer.normalizeEventWithMarkets(e))
+            .filter((e) => e !== null);
+    }
+    async fetchOrderBook(outcomeId) {
+        const { instrumentSymbol } = (0, utils_1.fromOutcomeId)(outcomeId);
+        const raw = await this.fetcher.fetchRawOrderBook(instrumentSymbol);
+        if (!raw) {
+            return { bids: [], asks: [], timestamp: Date.now() };
+        }
+        return this.normalizer.normalizeOrderBook(raw, outcomeId);
+    }
+    // -------------------------------------------------------------------------
+    // Trading
+    // -------------------------------------------------------------------------
+    async buildOrder(params) {
+        this.requireAuth();
+        const { instrumentSymbol, side } = (0, utils_1.fromOutcomeId)(params.outcomeId);
+        const payload = {
+            symbol: instrumentSymbol,
+            orderType: 'limit',
+            side: params.side,
+            quantity: String(params.amount),
+            price: params.price !== undefined ? params.price.toFixed(2) : '0.50',
+            outcome: side,
+            timeInForce: params.type === 'market' ? 'immediate-or-cancel' : 'good-til-cancel',
+        };
+        return {
+            exchange: this.name,
+            params,
+            raw: payload,
+        };
+    }
+    async submitOrder(built) {
+        this.requireAuth();
+        const payload = built.raw;
+        try {
+            const rawOrder = await this.fetcher.submitRawOrder(payload);
+            return this.normalizer.normalizeOrder(rawOrder);
+        }
+        catch (error) {
+            throw errors_2.geminiErrorMapper.mapError(error);
+        }
+    }
+    async createOrder(params) {
+        const built = await this.buildOrder(params);
+        return this.submitOrder(built);
+    }
+    async cancelOrder(orderId) {
+        this.requireAuth();
+        try {
+            await this.fetcher.cancelRawOrder(parseInt(orderId, 10));
+            return {
+                id: orderId,
+                marketId: '',
+                outcomeId: '',
+                side: 'buy',
+                type: 'limit',
+                amount: 0,
+                status: 'cancelled',
+                filled: 0,
+                remaining: 0,
+                timestamp: Date.now(),
+            };
+        }
+        catch (error) {
+            throw errors_2.geminiErrorMapper.mapError(error);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // User Data
+    // -------------------------------------------------------------------------
+    async fetchOpenOrders(marketId) {
+        this.requireAuth();
+        const symbol = marketId ? (0, utils_1.fromMarketId)(marketId) : undefined;
+        const raw = await this.fetcher.fetchRawActiveOrders(symbol);
+        return raw.map(o => this.normalizer.normalizeOrder(o));
+    }
+    async fetchClosedOrders() {
+        this.requireAuth();
+        const raw = await this.fetcher.fetchRawOrderHistory();
+        return raw.map(o => this.normalizer.normalizeOrder(o));
+    }
+    async fetchAllOrders() {
+        this.requireAuth();
+        const [open, closed] = await Promise.all([
+            this.fetchOpenOrders(),
+            this.fetchClosedOrders(),
+        ]);
+        return [...open, ...closed].sort((a, b) => b.timestamp - a.timestamp);
+    }
+    async fetchPositions() {
+        this.requireAuth();
+        const raw = await this.fetcher.fetchRawPositions();
+        return raw.map(p => this.normalizer.normalizePosition(p));
+    }
+    // -------------------------------------------------------------------------
+    // WebSocket
+    // -------------------------------------------------------------------------
+    ensureWebSocket() {
+        if (!this.geminiWs) {
+            this.geminiWs = new websocket_1.GeminiWebSocket(this.geminiAuth, {
+                wsUrl: this.config.wsUrl,
+            });
+        }
+        return this.geminiWs;
+    }
+    async watchOrderBook(outcomeId) {
+        const { instrumentSymbol } = (0, utils_1.fromOutcomeId)(outcomeId);
+        return this.ensureWebSocket().watchOrderBook(instrumentSymbol);
+    }
+    async watchTrades(outcomeId) {
+        const { instrumentSymbol } = (0, utils_1.fromOutcomeId)(outcomeId);
+        return this.ensureWebSocket().watchTrades(instrumentSymbol);
+    }
+    async close() {
+        if (this.geminiWs) {
+            await this.geminiWs.close();
+            this.geminiWs = undefined;
+        }
+    }
+}
+exports.GeminiTitanExchange = GeminiTitanExchange;

package/dist/exchanges/gemini-titan/normalizer.d.ts

@@ -0,0 +1,13 @@
+import { UnifiedMarket, UnifiedEvent, OrderBook, Order, Position } from '../../types';
+import { IExchangeNormalizer } from '../interfaces';
+import { GeminiRawEvent, GeminiRawContract, GeminiRawOrder, GeminiRawPosition, GeminiRawOrderBook } from './types';
+export declare class GeminiNormalizer implements IExchangeNormalizer<GeminiRawEvent, GeminiRawEvent> {
+    normalizeMarket(raw: GeminiRawEvent): UnifiedMarket | null;
+    normalizeEvent(raw: GeminiRawEvent): UnifiedEvent | null;
+    normalizeEventWithMarkets(raw: GeminiRawEvent): UnifiedEvent | null;
+    normalizeMarketsFromEvent(raw: GeminiRawEvent): UnifiedMarket[];
+    normalizeContract(contract: GeminiRawContract, event: GeminiRawEvent): UnifiedMarket | null;
+    normalizeOrderBook(raw: GeminiRawOrderBook, _outcomeId: string): OrderBook;
+    normalizeOrder(raw: GeminiRawOrder): Order;
+    normalizePosition(raw: GeminiRawPosition): Position;
+}

package/dist/exchanges/gemini-titan/normalizer.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiNormalizer = void 0;
+const market_utils_1 = require("../../utils/market-utils");
+const utils_1 = require("./utils");
+const config_1 = require("./config");
+// ----------------------------------------------------------------------------
+// Helpers
+// ----------------------------------------------------------------------------
+function mapEventStatus(geminiStatus) {
+    switch (geminiStatus) {
+        case 'active': return 'active';
+        case 'approved': return 'active';
+        case 'closed': return 'closed';
+        case 'settled': return 'closed';
+        case 'under_review': return 'closed';
+        case 'invalid': return 'closed';
+        default: return 'active';
+    }
+}
+function mapOrderStatus(geminiStatus) {
+    switch (geminiStatus.toLowerCase()) {
+        case 'open': return 'open';
+        case 'accepted': return 'open';
+        case 'filled': return 'filled';
+        case 'cancelled': return 'cancelled';
+        case 'canceled': return 'cancelled';
+        case 'rejected': return 'rejected';
+        default: return 'open';
+    }
+}
+function buildExchangeUrl(eventTicker) {
+    return `https://exchange.gemini.com/prediction-markets/events/${encodeURIComponent(eventTicker)}`;
+}
+/**
+ * Extract plain text from a Gemini rich text description.
+ * Contract descriptions come as Contentful-style rich text objects,
+ * while event descriptions are plain strings.
+ */
+function extractDescription(desc) {
+    if (typeof desc === 'string')
+        return desc;
+    if (!desc || typeof desc !== 'object')
+        return '';
+    const obj = desc;
+    // Contentful rich text: { nodeType: "document", content: [{ value: "...", nodeType: "text" }] }
+    if (Array.isArray(obj.content)) {
+        return obj.content
+            .map((node) => {
+            if (typeof node.value === 'string')
+                return node.value;
+            if (Array.isArray(node.content)) {
+                return node.content
+                    .filter((n) => typeof n.value === 'string')
+                    .map((n) => n.value)
+                    .join('');
+            }
+            return '';
+        })
+            .join(' ')
+            .trim();
+    }
+    return '';
+}
+/**
+ * Round to 2 decimal places to avoid floating point noise.
+ */
+function roundPrice(n) {
+    return Math.round(n * 100) / 100;
+}
+// ----------------------------------------------------------------------------
+// Normalizer
+// ----------------------------------------------------------------------------
+class GeminiNormalizer {
+    normalizeMarket(raw) {
+        // Gemini events contain multiple contracts -- each event becomes
+        // multiple markets. This method is called per-event, so we return
+        // the first contract as a market. Use normalizeMarketsFromEvent
+        // for the full list.
+        if (!raw || !raw.contracts || raw.contracts.length === 0)
+            return null;
+        return this.normalizeContract(raw.contracts[0], raw);
+    }
+    normalizeEvent(raw) {
+        if (!raw)
+            return null;
+        return {
+            id: raw.ticker,
+            title: raw.title,
+            description: raw.description ?? '',
+            slug: raw.slug ?? raw.ticker.toLowerCase(),
+            markets: [],
+            volume24h: raw.volume ? parseFloat(raw.volume) : 0,
+            url: buildExchangeUrl(raw.ticker),
+            category: raw.category,
+            tags: raw.tags ?? [],
+            image: raw.imageUrl,
+        };
+    }
+    normalizeEventWithMarkets(raw) {
+        const event = this.normalizeEvent(raw);
+        if (!event)
+            return null;
+        const markets = [];
+        for (const contract of raw.contracts) {
+            if (contract.status === 'settled' || contract.marketState === 'closed')
+                continue;
+            const market = this.normalizeContract(contract, raw);
+            if (market)
+                markets.push(market);
+        }
+        return {
+            ...event,
+            markets,
+            volume24h: markets.reduce((sum, m) => sum + m.volume24h, 0),
+        };
+    }
+    normalizeMarketsFromEvent(raw) {
+        const markets = [];
+        for (const contract of raw.contracts) {
+            const market = this.normalizeContract(contract, raw);
+            if (market)
+                markets.push(market);
+        }
+        return markets;
+    }
+    normalizeContract(contract, event) {
+        if (!contract || !contract.instrumentSymbol)
+            return null;
+        const instrumentSymbol = contract.instrumentSymbol;
+        const marketId = (0, utils_1.toMarketId)(instrumentSymbol);
+        // Extract prices
+        const bestBid = contract.prices?.bestBid ? parseFloat(contract.prices.bestBid) : 0.5;
+        const bestAsk = contract.prices?.bestAsk ? parseFloat(contract.prices.bestAsk) : 0.5;
+        const lastPrice = contract.prices?.lastTradePrice
+            ? parseFloat(contract.prices.lastTradePrice)
+            : (bestBid + bestAsk) / 2;
+        const yesPrice = roundPrice(Math.max(0, Math.min(1, lastPrice)));
+        const noPrice = roundPrice(Math.max(0, Math.min(1, 1 - yesPrice)));
+        const outcomes = [
+            {
+                outcomeId: (0, utils_1.toOutcomeId)(instrumentSymbol, 'yes'),
+                marketId,
+                label: contract.label || 'Yes',
+                price: yesPrice,
+            },
+            {
+                outcomeId: (0, utils_1.toOutcomeId)(instrumentSymbol, 'no'),
+                marketId,
+                label: `${contract.label || 'Yes'} (No)`,
+                price: noPrice,
+            },
+        ];
+        // Resolution date
+        const expiryStr = contract.expiryDate ?? event.expiryDate;
+        const resolutionDate = expiryStr ? new Date(expiryStr) : new Date(0);
+        const tags = [...(event.tags ?? [])];
+        if (event.category && !tags.includes(event.category)) {
+            tags.push(event.category);
+        }
+        const um = {
+            marketId,
+            eventId: event.ticker,
+            title: contract.label || event.title,
+            description: extractDescription(contract.description) || extractDescription(event.description),
+            slug: instrumentSymbol.toLowerCase(),
+            outcomes,
+            resolutionDate,
+            volume24h: 0,
+            liquidity: event.liquidity ? parseFloat(event.liquidity) : 0,
+            url: buildExchangeUrl(event.ticker),
+            category: event.category,
+            tags,
+            tickSize: config_1.TICK_SIZE,
+            status: mapEventStatus(contract.status),
+        };
+        (0, market_utils_1.addBinaryOutcomes)(um);
+        return um;
+    }
+    normalizeOrderBook(raw, _outcomeId) {
+        const bids = (raw.bids ?? []).map(level => ({
+            price: parseFloat(level.price),
+            size: parseFloat(level.size),
+        }));
+        const asks = (raw.asks ?? []).map(level => ({
+            price: parseFloat(level.price),
+            size: parseFloat(level.size),
+        }));
+        return {
+            bids: [...bids].sort((a, b) => b.price - a.price),
+            asks: [...asks].sort((a, b) => a.price - b.price),
+            timestamp: raw.timestamp ?? Date.now(),
+        };
+    }
+    normalizeOrder(raw) {
+        const quantity = parseFloat(raw.quantity);
+        const filled = parseFloat(raw.filledQuantity);
+        return {
+            id: String(raw.orderId),
+            marketId: (0, utils_1.toMarketId)(raw.symbol),
+            outcomeId: (0, utils_1.toOutcomeId)(raw.symbol, raw.outcome),
+            side: raw.side,
+            type: 'limit',
+            price: parseFloat(raw.price),
+            amount: quantity,
+            status: mapOrderStatus(raw.status),
+            filled,
+            remaining: quantity - filled,
+            timestamp: new Date(raw.createdAt).getTime(),
+        };
+    }
+    normalizePosition(raw) {
+        const currentPrice = raw.prices?.bestBid
+            ? parseFloat(raw.prices.bestBid)
+            : 0;
+        const entryPrice = parseFloat(raw.avgPrice);
+        const size = parseFloat(raw.totalQuantity);
+        return {
+            marketId: (0, utils_1.toMarketId)(raw.symbol),
+            outcomeId: (0, utils_1.toOutcomeId)(raw.symbol, raw.outcome),
+            outcomeLabel: raw.outcome === 'yes' ? 'Yes' : 'No',
+            size,
+            entryPrice,
+            currentPrice,
+            unrealizedPnL: (currentPrice - entryPrice) * size,
+        };
+    }
+}
+exports.GeminiNormalizer = GeminiNormalizer;

package/dist/exchanges/gemini-titan/types.d.ts

@@ -0,0 +1,220 @@
+export interface GeminiRawPrices {
+    buy?: {
+        yes?: string;
+        no?: string;
+    };
+    sell?: {
+        yes?: string;
+        no?: string;
+    };
+    bestBid?: string;
+    bestAsk?: string;
+    lastTradePrice?: string;
+}
+export interface GeminiRawContract {
+    id: string;
+    label: string;
+    abbreviatedName?: string;
+    description?: string | Record<string, unknown>;
+    ticker: string;
+    instrumentSymbol: string;
+    status: string;
+    marketState: string;
+    prices: GeminiRawPrices;
+    totalShares?: string;
+    color?: string;
+    imageUrl?: string;
+    createdAt?: string;
+    expiryDate?: string;
+    effectiveDate?: string;
+    resolutionSide?: string | null;
+    resolvedAt?: string | null;
+    sortOrder?: number;
+    strike?: Record<string, unknown>;
+    source?: string;
+    settlementValue?: string;
+    termsAndConditionsUrl?: string;
+}
+export interface GeminiRawEvent {
+    id: string;
+    title: string;
+    slug?: string;
+    description?: string;
+    imageUrl?: string;
+    type: string;
+    category?: string;
+    series?: string;
+    ticker: string;
+    status: string;
+    resolvedAt?: string | null;
+    createdAt?: string;
+    effectiveDate?: string;
+    expiryDate?: string;
+    contracts: GeminiRawContract[];
+    volume?: string;
+    liquidity?: string;
+    tags?: string[];
+    subcategory?: Record<string, unknown>;
+    source?: string;
+    settlement?: {
+        value?: string;
+    };
+    contractOrderbooks?: Record<string, GeminiRawOrderBook>;
+}
+export interface GeminiRawEventsResponse {
+    data: GeminiRawEvent[];
+    pagination: {
+        limit: number;
+        offset: number;
+        total: number;
+    };
+}
+export interface GeminiRawOrderBookLevel {
+    price: string;
+    size: string;
+}
+export interface GeminiRawOrderBook {
+    bids: GeminiRawOrderBookLevel[];
+    asks: GeminiRawOrderBookLevel[];
+    timestamp?: number;
+}
+export interface GeminiRawContractMetadata {
+    contractId?: string;
+    contractName?: string;
+    contractTicker?: string;
+    eventTicker?: string;
+    eventName?: string;
+    category?: string;
+    contractStatus?: string;
+    imageUrl?: string;
+    eventImageUrl?: string;
+    eventType?: string;
+    expiryDate?: string;
+    resolvedAt?: string | null;
+    resolutionSide?: string | null;
+    description?: string;
+    sortOrder?: number;
+    parentEventTicker?: string;
+    template?: string;
+    color?: string;
+    startTime?: string;
+}
+export interface GeminiRawOrder {
+    orderId: number;
+    hashOrderId?: string;
+    clientOrderId?: string;
+    globalOrderId?: string;
+    status: string;
+    symbol: string;
+    side: string;
+    outcome: string;
+    orderType: string;
+    quantity: string;
+    filledQuantity: string;
+    remainingQuantity: string;
+    price: string;
+    stopPrice?: string | null;
+    avgExecutionPrice?: string | null;
+    createdAt: string;
+    updatedAt?: string;
+    cancelledAt?: string | null;
+    contractMetadata?: GeminiRawContractMetadata;
+    trades?: GeminiRawTradeFill[];
+}
+export interface GeminiRawTradeFill {
+    tradeId?: string;
+    price?: string;
+    quantity?: string;
+    timestamp?: string;
+}
+export interface GeminiRawPosition {
+    symbol: string;
+    instrumentId?: number;
+    totalQuantity: string;
+    quantityOnHold?: string;
+    avgPrice: string;
+    outcome: string;
+    contractMetadata?: GeminiRawContractMetadata;
+    prices?: GeminiRawPrices;
+    resolutionSide?: string | null;
+    isAboveAutoStartThreshold?: boolean;
+    isLive?: boolean;
+    realizedPl?: string;
+}
+export interface GeminiRawActiveOrdersResponse {
+    orders: GeminiRawOrder[];
+    pagination?: {
+        limit: number;
+        offset: number;
+        count: number;
+    };
+}
+export interface GeminiRawPositionsResponse {
+    positions: GeminiRawPosition[];
+    total?: number;
+}
+export interface GeminiRawCategoriesResponse {
+    categories: string[];
+}
+export interface GeminiWsBookTickerData {
+    u: number;
+    E: number;
+    s: string;
+    b: string;
+    B: string;
+    a: string;
+    A: string;
+}
+export interface GeminiWsDepthSnapshotData {
+    lastUpdateId: number;
+    bids: [string, string][];
+    asks: [string, string][];
+}
+export interface GeminiWsDepthUpdateData {
+    e: string;
+    E: number;
+    s: string;
+    U: number;
+    u: number;
+    b: [string, string][];
+    a: [string, string][];
+}
+export interface GeminiWsTradeData {
+    E: number;
+    s: string;
+    t: number;
+    p: string;
+    q: string;
+    m: boolean;
+}
+export interface GeminiWsOrderData {
+    E: number;
+    s: string;
+    i: string;
+    c: string;
+    S: string;
+    o: string;
+    X: string;
+    p: string;
+    q: string;
+    z: string;
+    Z: string;
+    L: string;
+    t: string;
+    r?: string;
+    T: number;
+    O: string;
+}
+export interface GeminiWsStreamMessage {
+    stream: string;
+    data: unknown;
+}
+export interface GeminiWsResponse {
+    id: string | number;
+    status: number;
+    result?: unknown;
+    error?: {
+        code: number;
+        msg: string;
+    };
+}

package/dist/exchanges/gemini-titan/types.js

@@ -0,0 +1,6 @@
+"use strict";
+// ----------------------------------------------------------------------------
+// Raw Gemini Titan API response types
+// These mirror exactly what the API returns -- no transformation.
+// ----------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/exchanges/gemini-titan/utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Build a unique market ID from a Gemini instrumentSymbol.
+ * Format: "gemi-{instrumentSymbol}"
+ *
+ * A market encompasses both YES and NO sides of a single contract.
+ */
+export declare function toMarketId(instrumentSymbol: string): string;
+/**
+ * Extract the instrumentSymbol from our market ID format.
+ */
+export declare function fromMarketId(marketId: string): string;
+/**
+ * Build an outcome ID that encodes both the instrumentSymbol and side.
+ * Format: "GEMI:{instrumentSymbol}:{side}"
+ *
+ * The side is needed because Gemini orders require an explicit
+ * "outcome" field ("yes" or "no").
+ */
+export declare function toOutcomeId(instrumentSymbol: string, side: 'yes' | 'no'): string;
+/**
+ * Decode an outcome ID back into instrumentSymbol and side.
+ */
+export declare function fromOutcomeId(outcomeId: string): {
+    instrumentSymbol: string;
+    side: 'yes' | 'no';
+};
+/**
+ * Check if a string looks like a Gemini prediction market instrument symbol.
+ */
+export declare function isGeminiInstrument(symbol: string): boolean;