pmxt-core 2.20.1 → 2.20.2

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

@@ -0,0 +1,40 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { MarketFetchParams, EventFetchParams } from '../../BaseExchange';
+import { IExchangeFetcher } from '../interfaces';
+import { BaoziMarket, BaoziRaceMarket, BaoziUserPosition, BaoziRacePosition } from './utils';
+export interface BaoziRawBooleanMarket {
+    pubkey: string;
+    parsed: BaoziMarket;
+}
+export interface BaoziRawRaceMarket {
+    pubkey: string;
+    parsed: BaoziRaceMarket;
+}
+export type BaoziRawMarket = BaoziRawBooleanMarket | BaoziRawRaceMarket;
+export interface BaoziRawBooleanPosition {
+    pubkey: string;
+    parsed: BaoziUserPosition;
+}
+export interface BaoziRawRacePosition {
+    pubkey: string;
+    parsed: BaoziRacePosition;
+}
+export interface BaoziRawBalance {
+    lamports: number;
+}
+export declare function isRawBooleanMarket(raw: BaoziRawMarket): raw is BaoziRawBooleanMarket;
+export declare function isRawRaceMarket(raw: BaoziRawMarket): raw is BaoziRawRaceMarket;
+export declare class BaoziFetcher implements IExchangeFetcher<BaoziRawMarket, BaoziRawMarket> {
+    private readonly connection;
+    constructor(connection: Connection);
+    fetchRawMarkets(_params?: MarketFetchParams): Promise<BaoziRawMarket[]>;
+    fetchRawEvents(params: EventFetchParams): Promise<BaoziRawMarket[]>;
+    fetchRawSingleMarket(pubkey: string): Promise<BaoziRawMarket | null>;
+    fetchRawOrderBook(id: string): Promise<BaoziRawMarket | null>;
+    fetchRawUserPositions(walletAddress: PublicKey): Promise<{
+        booleanPositions: BaoziRawBooleanPosition[];
+        racePositions: BaoziRawRacePosition[];
+    }>;
+    fetchRawUserBalance(walletAddress: PublicKey): Promise<BaoziRawBalance>;
+    fetchRawMarketAccount(pubkey: PublicKey): Promise<BaoziRawMarket | null>;
+}

package/dist/exchanges/baozi/fetcher.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaoziFetcher = void 0;
+exports.isRawBooleanMarket = isRawBooleanMarket;
+exports.isRawRaceMarket = isRawRaceMarket;
+const web3_js_1 = require("@solana/web3.js");
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+function isRawBooleanMarket(raw) {
+    return 'parsed' in raw && 'yesPool' in raw.parsed;
+}
+function isRawRaceMarket(raw) {
+    return 'parsed' in raw && 'outcomeCount' in raw.parsed;
+}
+// ---------------------------------------------------------------------------
+// Fetcher
+// ---------------------------------------------------------------------------
+const marketsCache = new utils_1.Cache(30_000); // 30s TTL
+class BaoziFetcher {
+    connection;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    async fetchRawMarkets(_params) {
+        try {
+            const cached = marketsCache.get();
+            if (cached) {
+                return cached;
+            }
+            const [booleanAccounts, raceAccounts] = await Promise.all([
+                this.connection.getProgramAccounts(utils_1.PROGRAM_ID, {
+                    filters: [{ memcmp: { offset: 0, bytes: utils_1.MARKET_DISCRIMINATOR_BS58 } }],
+                }),
+                this.connection.getProgramAccounts(utils_1.PROGRAM_ID, {
+                    filters: [{ memcmp: { offset: 0, bytes: utils_1.RACE_MARKET_DISCRIMINATOR_BS58 } }],
+                }),
+            ]);
+            const markets = [];
+            for (const account of booleanAccounts) {
+                try {
+                    const parsed = (0, utils_1.parseMarket)(account.account.data);
+                    markets.push({ pubkey: account.pubkey.toString(), parsed });
+                }
+                catch {
+                    // Skip malformed accounts
+                }
+            }
+            for (const account of raceAccounts) {
+                try {
+                    const parsed = (0, utils_1.parseRaceMarket)(account.account.data);
+                    markets.push({ pubkey: account.pubkey.toString(), parsed });
+                }
+                catch {
+                    // Skip malformed accounts
+                }
+            }
+            marketsCache.set(markets);
+            return markets;
+        }
+        catch (error) {
+            throw errors_1.baoziErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawEvents(params) {
+        // Baozi markets are 1:1 with events
+        return this.fetchRawMarkets({
+            query: params.query,
+            limit: params.limit,
+            offset: params.offset,
+            status: params.status,
+            searchIn: params.searchIn,
+        });
+    }
+    async fetchRawSingleMarket(pubkey) {
+        try {
+            const pk = new web3_js_1.PublicKey(pubkey);
+            const accountInfo = await this.connection.getAccountInfo(pk);
+            if (!accountInfo)
+                return null;
+            const data = accountInfo.data;
+            const discriminator = data.subarray(0, 8);
+            if (Buffer.from(discriminator).equals(utils_1.MARKET_DISCRIMINATOR)) {
+                const parsed = (0, utils_1.parseMarket)(data);
+                return { pubkey, parsed };
+            }
+            if (Buffer.from(discriminator).equals(utils_1.RACE_MARKET_DISCRIMINATOR)) {
+                const parsed = (0, utils_1.parseRaceMarket)(data);
+                return { pubkey, parsed };
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async fetchRawOrderBook(id) {
+        const marketPubkey = id.replace(/-YES$|-NO$|-\d+$/, '');
+        return this.fetchRawSingleMarket(marketPubkey);
+    }
+    async fetchRawUserPositions(walletAddress) {
+        try {
+            const [booleanAccounts, raceAccounts] = await Promise.all([
+                this.connection.getProgramAccounts(utils_1.PROGRAM_ID, {
+                    filters: [
+                        { memcmp: { offset: 0, bytes: utils_1.USER_POSITION_DISCRIMINATOR_BS58 } },
+                        { memcmp: { offset: 8, bytes: walletAddress.toBase58() } },
+                    ],
+                }),
+                this.connection.getProgramAccounts(utils_1.PROGRAM_ID, {
+                    filters: [
+                        { memcmp: { offset: 0, bytes: utils_1.RACE_POSITION_DISCRIMINATOR_BS58 } },
+                        { memcmp: { offset: 8, bytes: walletAddress.toBase58() } },
+                    ],
+                }),
+            ]);
+            const booleanPositions = [];
+            for (const account of booleanAccounts) {
+                try {
+                    const parsed = (0, utils_1.parseUserPosition)(account.account.data);
+                    booleanPositions.push({ pubkey: account.pubkey.toString(), parsed });
+                }
+                catch {
+                    // Skip malformed
+                }
+            }
+            const racePositions = [];
+            for (const account of raceAccounts) {
+                try {
+                    const parsed = (0, utils_1.parseRacePosition)(account.account.data);
+                    racePositions.push({ pubkey: account.pubkey.toString(), parsed });
+                }
+                catch {
+                    // Skip malformed
+                }
+            }
+            return { booleanPositions, racePositions };
+        }
+        catch (error) {
+            throw errors_1.baoziErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawUserBalance(walletAddress) {
+        try {
+            const lamports = await this.connection.getBalance(walletAddress);
+            return { lamports };
+        }
+        catch (error) {
+            throw errors_1.baoziErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawMarketAccount(pubkey) {
+        return this.fetchRawSingleMarket(pubkey.toString());
+    }
+}
+exports.BaoziFetcher = BaoziFetcher;

package/dist/exchanges/baozi/index.d.ts

@@ -30,6 +30,8 @@ export declare class BaoziExchange extends PredictionMarketExchange {
     private auth?;
     private connection;
     private ws?;
+    private readonly fetcher;
+    private readonly normalizer;
     constructor(options?: ExchangeCredentials | BaoziExchangeOptions);
     get name(): string;
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;

package/dist/exchanges/baozi/index.js

@@ -4,14 +4,11 @@ exports.BaoziExchange = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const BaseExchange_1 = require("../../BaseExchange");
 const errors_1 = require("../../errors");
-const fetchMarkets_1 = require("./fetchMarkets");
-const fetchEvents_1 = require("./fetchEvents");
-const fetchOHLCV_1 = require("./fetchOHLCV");
-const fetchOrderBook_1 = require("./fetchOrderBook");
-const fetchTrades_1 = require("./fetchTrades");
 const auth_1 = require("./auth");
 const websocket_1 = require("./websocket");
 const errors_2 = require("./errors");
+const fetcher_1 = require("./fetcher");
+const normalizer_1 = require("./normalizer");
 const utils_1 = require("./utils");
 class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
     has = {
@@ -39,6 +36,8 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
     auth;
     connection;
     ws;
+    fetcher;
+    normalizer;
     constructor(options) {
         let credentials;
         let rpcUrl;
@@ -59,163 +58,97 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         if (credentials?.privateKey) {
             this.auth = new auth_1.BaoziAuth(credentials);
         }
+        this.fetcher = new fetcher_1.BaoziFetcher(this.connection);
+        this.normalizer = new normalizer_1.BaoziNormalizer();
     }
     get name() {
         return 'Baozi';
     }
     // -----------------------------------------------------------------------
-    // Market Data
+    // Market Data (fetcher -> normalizer)
     // -----------------------------------------------------------------------
     async fetchMarketsImpl(params) {
-        return (0, fetchMarkets_1.fetchMarkets)(this.connection, params);
+        const rawMarkets = await this.fetcher.fetchRawMarkets(params);
+        return this.normalizer.normalizeMarkets(rawMarkets, params);
     }
     async fetchEventsImpl(params) {
-        return (0, fetchEvents_1.fetchEvents)(this.connection, params);
+        const rawMarkets = await this.fetcher.fetchRawEvents(params);
+        return this.normalizer.normalizeEvents(rawMarkets, {
+            query: params.query,
+            limit: params.limit,
+            offset: params.offset,
+            status: params.status,
+            searchIn: params.searchIn,
+        });
     }
     async fetchOHLCV() {
-        return (0, fetchOHLCV_1.fetchOHLCV)();
+        // Baozi has no historical price/trade API without a custom indexer
+        return [];
     }
     async fetchOrderBook(id) {
-        return (0, fetchOrderBook_1.fetchOrderBook)(this.connection, id);
+        const rawMarket = await this.fetcher.fetchRawOrderBook(id);
+        return this.normalizer.normalizeOrderBook(rawMarket, id);
     }
     async fetchTrades() {
-        return (0, fetchTrades_1.fetchTrades)();
+        // Baozi has no trade history API without a custom indexer
+        return [];
     }
     // -----------------------------------------------------------------------
-    // User Data
+    // User Data (fetcher -> normalizer)
     // -----------------------------------------------------------------------
     async fetchBalance() {
-        try {
-            const auth = this.ensureAuth();
-            const lamports = await this.connection.getBalance(auth.getPublicKey());
-            const solBalance = lamports / utils_1.LAMPORTS_PER_SOL;
-            return [{
-                    currency: 'SOL',
-                    total: solBalance,
-                    available: solBalance,
-                    locked: 0,
-                }];
-        }
-        catch (error) {
-            throw errors_2.baoziErrorMapper.mapError(error);
-        }
+        const auth = this.ensureAuth();
+        const rawBalance = await this.fetcher.fetchRawUserBalance(auth.getPublicKey());
+        return this.normalizer.normalizeBalance(rawBalance);
     }
     async fetchPositions() {
         try {
             const auth = this.ensureAuth();
             const userPubkey = auth.getPublicKey();
-            // Fetch boolean and race positions in parallel
-            const [booleanPositions, racePositions] = await Promise.all([
-                this.connection.getProgramAccounts(utils_1.PROGRAM_ID, {
-                    filters: [
-                        { memcmp: { offset: 0, bytes: utils_1.USER_POSITION_DISCRIMINATOR_BS58 } },
-                        { memcmp: { offset: 8, bytes: userPubkey.toBase58() } },
-                    ],
-                }),
-                this.connection.getProgramAccounts(utils_1.PROGRAM_ID, {
-                    filters: [
-                        { memcmp: { offset: 0, bytes: utils_1.RACE_POSITION_DISCRIMINATOR_BS58 } },
-                        { memcmp: { offset: 8, bytes: userPubkey.toBase58() } },
-                    ],
-                }),
-            ]);
-            const positions = [];
-            // Process boolean positions
-            for (const account of booleanPositions) {
-                try {
-                    const pos = (0, utils_1.parseUserPosition)(account.account.data);
-                    if (pos.claimed)
-                        continue;
-                    // Try to fetch the market to get current prices
-                    const marketPda = (0, utils_1.deriveMarketPda)(pos.marketId);
-                    let currentYesPrice = 0;
-                    let currentNoPrice = 0;
-                    let marketTitle = `Market #${pos.marketId}`;
+            const { booleanPositions, racePositions } = await this.fetcher.fetchRawUserPositions(userPubkey);
+            // Build market lookup for current prices
+            const marketLookup = new Map();
+            for (const { parsed: pos } of booleanPositions) {
+                if (pos.claimed)
+                    continue;
+                const marketPda = (0, utils_1.deriveMarketPda)(pos.marketId);
+                const marketPdaStr = marketPda.toString();
+                if (!marketLookup.has(marketPdaStr)) {
                     try {
-                        const marketInfo = await this.connection.getAccountInfo(marketPda);
-                        if (marketInfo) {
-                            const market = (0, utils_1.parseMarket)(marketInfo.data);
-                            const unified = (0, utils_1.mapBooleanToUnified)(market, marketPda.toString());
-                            currentYesPrice = unified.yes?.price ?? 0;
-                            currentNoPrice = unified.no?.price ?? 0;
-                            marketTitle = market.question;
+                        const rawMarket = await this.fetcher.fetchRawMarketAccount(marketPda);
+                        if (rawMarket) {
+                            const unified = this.normalizer.normalizeMarket(rawMarket);
+                            if (unified)
+                                marketLookup.set(marketPdaStr, unified);
                         }
                     }
                     catch {
                         // Use defaults if market fetch fails
                     }
-                    const yesSOL = Number(pos.yesAmount) / utils_1.LAMPORTS_PER_SOL;
-                    const noSOL = Number(pos.noAmount) / utils_1.LAMPORTS_PER_SOL;
-                    if (yesSOL > 0) {
-                        positions.push({
-                            marketId: marketPda.toString(),
-                            outcomeId: `${marketPda.toString()}-YES`,
-                            outcomeLabel: 'Yes',
-                            size: yesSOL,
-                            entryPrice: 0, // Not tracked on-chain for pari-mutuel
-                            currentPrice: currentYesPrice,
-                            unrealizedPnL: 0, // Pari-mutuel doesn't have fixed unrealized P&L
-                        });
-                    }
-                    if (noSOL > 0) {
-                        positions.push({
-                            marketId: marketPda.toString(),
-                            outcomeId: `${marketPda.toString()}-NO`,
-                            outcomeLabel: 'No',
-                            size: noSOL,
-                            entryPrice: 0,
-                            currentPrice: currentNoPrice,
-                            unrealizedPnL: 0,
-                        });
-                    }
-                }
-                catch {
-                    // Skip malformed position accounts
                 }
             }
-            // Process race positions
-            for (const account of racePositions) {
-                try {
-                    const pos = (0, utils_1.parseRacePosition)(account.account.data);
-                    if (pos.claimed)
-                        continue;
-                    const racePda = (0, utils_1.deriveRaceMarketPda)(pos.marketId);
-                    const racePdaStr = racePda.toString();
-                    // Try to fetch the race market to get current prices and labels
-                    let outcomePrices = [];
-                    let outcomeLabels = [];
+            for (const { parsed: pos } of racePositions) {
+                if (pos.claimed)
+                    continue;
+                const racePda = (0, utils_1.deriveRaceMarketPda)(pos.marketId);
+                const racePdaStr = racePda.toString();
+                if (!marketLookup.has(racePdaStr)) {
                     try {
-                        const marketInfo = await this.connection.getAccountInfo(racePda);
-                        if (marketInfo) {
-                            const raceMarket = (0, utils_1.parseRaceMarket)(marketInfo.data);
-                            const unified = (0, utils_1.mapRaceToUnified)(raceMarket, racePdaStr);
-                            outcomePrices = unified.outcomes.map(o => o.price);
-                            outcomeLabels = unified.outcomes.map(o => o.label);
+                        const rawMarket = await this.fetcher.fetchRawMarketAccount(racePda);
+                        if (rawMarket) {
+                            const unified = this.normalizer.normalizeMarket(rawMarket);
+                            if (unified)
+                                marketLookup.set(racePdaStr, unified);
                         }
                     }
                     catch {
                         // Use defaults if market fetch fails
                     }
-                    for (let i = 0; i < pos.bets.length; i++) {
-                        const betSOL = Number(pos.bets[i]) / utils_1.LAMPORTS_PER_SOL;
-                        if (betSOL <= 0)
-                            continue;
-                        positions.push({
-                            marketId: racePdaStr,
-                            outcomeId: `${racePdaStr}-${i}`,
-                            outcomeLabel: outcomeLabels[i] || `Outcome ${i}`,
-                            size: betSOL,
-                            entryPrice: 0,
-                            currentPrice: outcomePrices[i] ?? 0,
-                            unrealizedPnL: 0,
-                        });
-                    }
-                }
-                catch {
-                    // Skip malformed position accounts
                 }
             }
-            return positions;
+            const boolPos = this.normalizer.normalizeBooleanPositions(booleanPositions, marketLookup);
+            const racePos = this.normalizer.normalizeRacePositions(racePositions, marketLookup);
+            return [...boolPos, ...racePos];
         }
         catch (error) {
             throw errors_2.baoziErrorMapper.mapError(error);
@@ -257,7 +190,7 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
                         { pubkey: configPda, isSigner: false, isWritable: false },
                         { pubkey: marketPubkey, isSigner: false, isWritable: true },
                         { pubkey: positionPda, isSigner: false, isWritable: true },
-                        { pubkey: utils_1.PROGRAM_ID, isSigner: false, isWritable: false }, // whitelist (optional → pass program ID)
+                        { pubkey: utils_1.PROGRAM_ID, isSigner: false, isWritable: false },
                         { pubkey: keypair.publicKey, isSigner: true, isWritable: true },
                         { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
                     ],
@@ -293,7 +226,7 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
                         { pubkey: configPda, isSigner: false, isWritable: false },
                         { pubkey: marketPubkey, isSigner: false, isWritable: true },
                         { pubkey: racePositionPda, isSigner: false, isWritable: true },
-                        { pubkey: utils_1.PROGRAM_ID, isSigner: false, isWritable: false }, // whitelist (optional)
+                        { pubkey: utils_1.PROGRAM_ID, isSigner: false, isWritable: false },
                         { pubkey: keypair.publicKey, isSigner: true, isWritable: true },
                         { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
                     ],
@@ -313,10 +246,10 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
                 marketId: params.marketId,
                 outcomeId: params.outcomeId,
                 side: 'buy',
-                type: 'market', // Pari-mutuel bets are always instant
+                type: 'market',
                 price: undefined,
                 amount: params.amount,
-                status: 'filled', // Pari-mutuel bets fill instantly
+                status: 'filled',
                 filled: params.amount,
                 remaining: 0,
                 timestamp: Date.now(),
@@ -330,8 +263,6 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         throw new errors_1.InvalidOrder('Pari-mutuel bets are irrevocable and cannot be cancelled', 'Baozi');
     }
     async fetchOrder(orderId) {
-        // In pari-mutuel, there are no pending orders. The "order" is the tx signature.
-        // We can verify the transaction was confirmed and extract market info.
         try {
             const tx = await this.connection.getTransaction(orderId, {
                 maxSupportedTransactionVersion: 0,
@@ -339,7 +270,6 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
             if (!tx) {
                 throw new Error(`Transaction not found: ${orderId}`);
             }
-            // Try to extract market/outcome from the transaction instruction
             let marketId = '';
             let outcomeId = '';
             let amount = 0;
@@ -357,7 +287,6 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
                     const isRaceBet = discriminator.equals(utils_1.BET_ON_RACE_OUTCOME_SOL_DISCRIMINATOR);
                     if (!isBooleanBet && !isRaceBet)
                         continue;
-                    // Account keys[1] is the market PDA for both instruction types
                     const marketKeyIndex = ix.accountKeyIndexes[1];
                     const marketKey = message.staticAccountKeys[marketKeyIndex];
                     marketId = marketKey.toString();
@@ -392,7 +321,7 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         }
     }
     async fetchOpenOrders() {
-        // Pari-mutuel bets execute instantly — there are never open orders
+        // Pari-mutuel bets execute instantly -- there are never open orders
         return [];
     }
     // -----------------------------------------------------------------------

package/dist/exchanges/baozi/normalizer.d.ts

@@ -0,0 +1,14 @@
+import { MarketFetchParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, OrderBook, Position, Balance } from '../../types';
+import { IExchangeNormalizer } from '../interfaces';
+import { BaoziRawMarket, BaoziRawBooleanPosition, BaoziRawRacePosition, BaoziRawBalance } from './fetcher';
+export declare class BaoziNormalizer implements IExchangeNormalizer<BaoziRawMarket, BaoziRawMarket> {
+    normalizeMarket(raw: BaoziRawMarket): UnifiedMarket | null;
+    normalizeEvent(raw: BaoziRawMarket): UnifiedEvent | null;
+    normalizeMarkets(rawMarkets: BaoziRawMarket[], params?: MarketFetchParams): UnifiedMarket[];
+    normalizeEvents(rawMarkets: BaoziRawMarket[], params?: MarketFetchParams): UnifiedEvent[];
+    normalizeOrderBook(raw: BaoziRawMarket | null, outcomeId: string): OrderBook;
+    normalizeBooleanPositions(positions: BaoziRawBooleanPosition[], marketLookup: Map<string, UnifiedMarket>): Position[];
+    normalizeRacePositions(positions: BaoziRawRacePosition[], marketLookup: Map<string, UnifiedMarket>): Position[];
+    normalizeBalance(raw: BaoziRawBalance): Balance[];
+}