pmxt-core 2.5.0 → 2.7.0

package/dist/BaseExchange.d.ts

@@ -1,5 +1,6 @@
 import { UnifiedMarket, UnifiedEvent, PriceCandle, CandleInterval, OrderBook, Trade, Order, Position, Balance, CreateOrderParams } from './types';
 import { ExecutionPriceResult } from './utils/math';
+import { AxiosInstance } from 'axios';
 export interface MarketFilterParams {
     limit?: number;
     offset?: number;
@@ -94,6 +95,22 @@ export type EventFilterCriteria = {
     };
 };
 export type EventFilterFunction = (event: UnifiedEvent) => boolean;
+export type ExchangeCapability = true | false | 'emulated';
+export interface ExchangeHas {
+    fetchMarkets: ExchangeCapability;
+    fetchEvents: ExchangeCapability;
+    fetchOHLCV: ExchangeCapability;
+    fetchOrderBook: ExchangeCapability;
+    fetchTrades: ExchangeCapability;
+    createOrder: ExchangeCapability;
+    cancelOrder: ExchangeCapability;
+    fetchOrder: ExchangeCapability;
+    fetchOpenOrders: ExchangeCapability;
+    fetchPositions: ExchangeCapability;
+    fetchBalance: ExchangeCapability;
+    watchOrderBook: ExchangeCapability;
+    watchTrades: ExchangeCapability;
+}
 export interface ExchangeCredentials {
     apiKey?: string;
     apiSecret?: string;
@@ -104,6 +121,9 @@ export interface ExchangeCredentials {
 }
 export declare abstract class PredictionMarketExchange {
     protected credentials?: ExchangeCredentials;
+    verbose: boolean;
+    http: AxiosInstance;
+    readonly has: ExchangeHas;
     constructor(credentials?: ExchangeCredentials);
     abstract get name(): string;
     /**

package/dist/BaseExchange.js

@@ -1,15 +1,67 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PredictionMarketExchange = void 0;
 const math_1 = require("./utils/math");
 const errors_1 = require("./errors");
+const axios_1 = __importDefault(require("axios"));
 // ----------------------------------------------------------------------------
 // Base Exchange Class
 // ----------------------------------------------------------------------------
 class PredictionMarketExchange {
     credentials;
+    verbose = false;
+    http;
+    has = {
+        fetchMarkets: false,
+        fetchEvents: false,
+        fetchOHLCV: false,
+        fetchOrderBook: false,
+        fetchTrades: false,
+        createOrder: false,
+        cancelOrder: false,
+        fetchOrder: false,
+        fetchOpenOrders: false,
+        fetchPositions: false,
+        fetchBalance: false,
+        watchOrderBook: false,
+        watchTrades: false,
+    };
     constructor(credentials) {
         this.credentials = credentials;
+        this.http = axios_1.default.create();
+        // Request Interceptor
+        this.http.interceptors.request.use((config) => {
+            if (this.verbose) {
+                console.log(`\n[pmxt] → ${config.method?.toUpperCase()} ${config.url}`);
+                if (config.params)
+                    console.log('[pmxt] params:', config.params);
+                if (config.data)
+                    console.log('[pmxt] body:', JSON.stringify(config.data, null, 2));
+            }
+            return config;
+        });
+        // Response Interceptor
+        this.http.interceptors.response.use((response) => {
+            if (this.verbose) {
+                console.log(`\n[pmxt] ← ${response.status} ${response.statusText} ${response.config.url}`);
+                // console.log('[pmxt] response:', JSON.stringify(response.data, null, 2)); 
+                // Commented out full body log to avoid spam, but headers might be useful
+            }
+            return response;
+        }, (error) => {
+            if (this.verbose) {
+                console.log(`\n[pmxt] ✖ REQUEST FAILED: ${error.config?.url}`);
+                console.log('[pmxt] error:', error.message);
+                if (error.response) {
+                    console.log('[pmxt] status:', error.response.status);
+                    console.log('[pmxt] data:', JSON.stringify(error.response.data, null, 2));
+                }
+            }
+            return Promise.reject(error);
+        });
     }
     /**
      * Fetch markets with optional filtering, search, or slug lookup.

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

@@ -5,6 +5,21 @@ export interface BaoziExchangeOptions {
     rpcUrl?: string;
 }
 export declare class BaoziExchange extends PredictionMarketExchange {
+    readonly has: {
+        fetchMarkets: true;
+        fetchEvents: true;
+        fetchOHLCV: "emulated";
+        fetchOrderBook: "emulated";
+        fetchTrades: "emulated";
+        createOrder: true;
+        cancelOrder: false;
+        fetchOrder: true;
+        fetchOpenOrders: "emulated";
+        fetchPositions: true;
+        fetchBalance: true;
+        watchOrderBook: true;
+        watchTrades: false;
+    };
     private auth?;
     private connection;
     private ws?;

package/dist/exchanges/baozi/index.js

@@ -14,6 +14,21 @@ const websocket_1 = require("./websocket");
 const errors_2 = require("./errors");
 const utils_1 = require("./utils");
 class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
+    has = {
+        fetchMarkets: true,
+        fetchEvents: true,
+        fetchOHLCV: 'emulated',
+        fetchOrderBook: 'emulated',
+        fetchTrades: 'emulated',
+        createOrder: true,
+        cancelOrder: false,
+        fetchOrder: true,
+        fetchOpenOrders: 'emulated',
+        fetchPositions: true,
+        fetchBalance: true,
+        watchOrderBook: true,
+        watchTrades: false,
+    };
     auth;
     connection;
     ws;

package/dist/exchanges/kalshi/fetchEvents.d.ts

@@ -1,3 +1,4 @@
 import { EventFetchParams } from '../../BaseExchange';
 import { UnifiedEvent } from '../../types';
-export declare function fetchEvents(params: EventFetchParams): Promise<UnifiedEvent[]>;
+import { AxiosInstance } from 'axios';
+export declare function fetchEvents(params: EventFetchParams, http?: AxiosInstance): Promise<UnifiedEvent[]>;

package/dist/exchanges/kalshi/fetchEvents.js

@@ -7,10 +7,10 @@ exports.fetchEvents = fetchEvents;
 const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchEventByTicker(eventTicker) {
+async function fetchEventByTicker(eventTicker, http) {
     const normalizedTicker = eventTicker.toUpperCase();
     const url = `https://api.elections.kalshi.com/trade-api/v2/events/${normalizedTicker}`;
-    const response = await axios_1.default.get(url, {
+    const response = await http.get(url, {
         params: { with_nested_markets: true }
     });
     const event = response.data.event;
@@ -38,15 +38,15 @@ async function fetchEventByTicker(eventTicker) {
     };
     return [unifiedEvent];
 }
-async function fetchEvents(params) {
+async function fetchEvents(params, http = axios_1.default) {
     try {
         // Handle eventId lookup (direct API call)
         if (params.eventId) {
-            return await fetchEventByTicker(params.eventId);
+            return await fetchEventByTicker(params.eventId, http);
         }
         // Handle slug lookup (slug IS the event ticker on Kalshi)
         if (params.slug) {
-            return await fetchEventByTicker(params.slug);
+            return await fetchEventByTicker(params.slug, http);
         }
         const status = params?.status || 'active';
         const limit = params?.limit || 10000;
@@ -65,7 +65,7 @@ async function fetchEvents(params) {
                 };
                 if (cursor)
                     queryParams.cursor = cursor;
-                const response = await axios_1.default.get(utils_1.KALSHI_API_URL, { params: queryParams });
+                const response = await http.get(utils_1.KALSHI_API_URL, { params: queryParams });
                 const events = response.data.events || [];
                 if (events.length === 0)
                     break;

package/dist/exchanges/kalshi/fetchMarkets.d.ts

@@ -1,4 +1,5 @@
+import { AxiosInstance } from 'axios';
 import { MarketFetchParams } from '../../BaseExchange';
 import { UnifiedMarket } from '../../types';
 export declare function resetCache(): void;
-export declare function fetchMarkets(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
+export declare function fetchMarkets(params?: MarketFetchParams, http?: AxiosInstance): Promise<UnifiedMarket[]>;

package/dist/exchanges/kalshi/fetchMarkets.js

@@ -8,7 +8,7 @@ exports.fetchMarkets = fetchMarkets;
 const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchActiveEvents(targetMarketCount, status = 'open') {
+async function fetchActiveEvents(http, targetMarketCount, status = 'open') {
     let allEvents = [];
     let totalMarketCount = 0;
     let cursor = null;
@@ -27,7 +27,7 @@ async function fetchActiveEvents(targetMarketCount, status = 'open') {
             };
             if (cursor)
                 queryParams.cursor = cursor;
-            const response = await axios_1.default.get(utils_1.KALSHI_API_URL, { params: queryParams });
+            const response = await http.get(utils_1.KALSHI_API_URL, { params: queryParams });
             const events = response.data.events || [];
             if (events.length === 0)
                 break;
@@ -56,9 +56,9 @@ async function fetchActiveEvents(targetMarketCount, status = 'open') {
     } while (cursor && page < MAX_PAGES);
     return allEvents;
 }
-async function fetchSeriesMap() {
+async function fetchSeriesMap(http) {
     try {
-        const response = await axios_1.default.get(utils_1.KALSHI_SERIES_URL);
+        const response = await http.get(utils_1.KALSHI_SERIES_URL);
         const seriesList = response.data.series || [];
         const map = new Map();
         for (const series of seriesList) {
@@ -83,41 +83,41 @@ function resetCache() {
     cachedSeriesMap = null;
     lastCacheTime = 0;
 }
-async function fetchMarkets(params) {
+async function fetchMarkets(params, http = axios_1.default) {
     try {
         // Handle marketId lookup (Kalshi marketId is the ticker)
         if (params?.marketId) {
-            return await fetchMarketsBySlug(params.marketId);
+            return await fetchMarketsBySlug(params.marketId, http);
         }
         // Handle slug-based lookup (event ticker)
         if (params?.slug) {
-            return await fetchMarketsBySlug(params.slug);
+            return await fetchMarketsBySlug(params.slug, http);
         }
         // Handle outcomeId lookup (strip -NO suffix, use as ticker)
         if (params?.outcomeId) {
             const ticker = params.outcomeId.replace(/-NO$/, '');
-            return await fetchMarketsBySlug(ticker);
+            return await fetchMarketsBySlug(ticker, http);
         }
         // Handle eventId lookup (event ticker works the same way)
         if (params?.eventId) {
-            return await fetchMarketsBySlug(params.eventId);
+            return await fetchMarketsBySlug(params.eventId, http);
         }
         // Handle query-based search
         if (params?.query) {
-            return await searchMarkets(params.query, params);
+            return await searchMarkets(params.query, params, http);
         }
         // Default: fetch markets
-        return await fetchMarketsDefault(params);
+        return await fetchMarketsDefault(params, http);
     }
     catch (error) {
         throw errors_1.kalshiErrorMapper.mapError(error);
     }
 }
-async function fetchMarketsBySlug(eventTicker) {
+async function fetchMarketsBySlug(eventTicker, http) {
     // Kalshi API expects uppercase tickers, but URLs use lowercase
     const normalizedTicker = eventTicker.toUpperCase();
     const url = `https://api.elections.kalshi.com/trade-api/v2/events/${normalizedTicker}`;
-    const response = await axios_1.default.get(url, {
+    const response = await http.get(url, {
         params: { with_nested_markets: true }
     });
     const event = response.data.event;
@@ -127,7 +127,7 @@ async function fetchMarketsBySlug(eventTicker) {
     if (event.series_ticker) {
         try {
             const seriesUrl = `${utils_1.KALSHI_SERIES_URL}/${event.series_ticker}`;
-            const seriesResponse = await axios_1.default.get(seriesUrl);
+            const seriesResponse = await http.get(seriesUrl);
             const series = seriesResponse.data.series;
             if (series && series.tags && series.tags.length > 0) {
                 if (!event.tags || event.tags.length === 0) {
@@ -149,10 +149,10 @@ async function fetchMarketsBySlug(eventTicker) {
     }
     return unifiedMarkets;
 }
-async function searchMarkets(query, params) {
+async function searchMarkets(query, params, http) {
     // We must fetch ALL markets to search them locally since we don't have server-side search
     const searchLimit = 10000;
-    const markets = await fetchMarketsDefault({ ...params, limit: searchLimit });
+    const markets = await fetchMarketsDefault({ ...params, limit: searchLimit }, http);
     const lowerQuery = query.toLowerCase();
     const searchIn = params?.searchIn || 'title'; // Default to title-only search
     const filtered = markets.filter(market => {
@@ -167,7 +167,7 @@ async function searchMarkets(query, params) {
     const limit = params?.limit || 10000;
     return filtered.slice(0, limit);
 }
-async function fetchMarketsDefault(params) {
+async function fetchMarketsDefault(params, http) {
     const limit = params?.limit || 10000;
     const offset = params?.offset || 0;
     const now = Date.now();
@@ -196,13 +196,11 @@ async function fetchMarketsDefault(params) {
             const isSorted = params?.sort && (params.sort === 'volume' || params.sort === 'liquidity');
             const fetchLimit = isSorted ? 1000 : limit;
             const [allEvents, fetchedSeriesMap] = await Promise.all([
-                fetchActiveEvents(fetchLimit, apiStatus),
-                fetchSeriesMap()
+                fetchActiveEvents(http, fetchLimit, apiStatus),
+                fetchSeriesMap(http)
             ]);
             events = allEvents;
             seriesMap = fetchedSeriesMap;
-            events = allEvents;
-            seriesMap = fetchedSeriesMap;
             // Cache the dataset ONLY if:
             // 1. We fetched a comprehensive set (>= 1000)
             // 2. It's the standard 'open' status query

package/dist/exchanges/kalshi/fetchOHLCV.d.ts

@@ -1,3 +1,4 @@
+import { AxiosInstance } from 'axios';
 import { HistoryFilterParams, OHLCVParams } from '../../BaseExchange';
 import { PriceCandle } from '../../types';
-export declare function fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams): Promise<PriceCandle[]>;
+export declare function fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams, http?: AxiosInstance): Promise<PriceCandle[]>;

package/dist/exchanges/kalshi/fetchOHLCV.js

@@ -8,7 +8,7 @@ const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const validation_1 = require("../../utils/validation");
 const errors_1 = require("./errors");
-async function fetchOHLCV(id, params) {
+async function fetchOHLCV(id, params, http = axios_1.default) {
     (0, validation_1.validateIdFormat)(id, 'OHLCV');
     // Validate resolution is provided
     if (!params.resolution) {
@@ -57,7 +57,7 @@ async function fetchOHLCV(id, params) {
         }
         queryParams.start_ts = startTs;
         queryParams.end_ts = endTs;
-        const response = await axios_1.default.get(url, { params: queryParams });
+        const response = await http.get(url, { params: queryParams });
         const candles = response.data.candlesticks || [];
         const mappedCandles = candles.map((c) => {
             // Priority:

package/dist/exchanges/kalshi/fetchOrderBook.d.ts

@@ -1,2 +1,3 @@
+import { AxiosInstance } from 'axios';
 import { OrderBook } from '../../types';
-export declare function fetchOrderBook(id: string): Promise<OrderBook>;
+export declare function fetchOrderBook(id: string, http?: AxiosInstance): Promise<OrderBook>;

package/dist/exchanges/kalshi/fetchOrderBook.js

@@ -7,14 +7,14 @@ exports.fetchOrderBook = fetchOrderBook;
 const axios_1 = __importDefault(require("axios"));
 const validation_1 = require("../../utils/validation");
 const errors_1 = require("./errors");
-async function fetchOrderBook(id) {
+async function fetchOrderBook(id, http = axios_1.default) {
     (0, validation_1.validateIdFormat)(id, 'OrderBook');
     try {
         // Check if this is a NO outcome request
         const isNoOutcome = id.endsWith('-NO');
         const ticker = id.replace(/-NO$/, '');
         const url = `https://api.elections.kalshi.com/trade-api/v2/markets/${ticker}/orderbook`;
-        const response = await axios_1.default.get(url);
+        const response = await http.get(url);
         const data = response.data.orderbook;
         // Structure: { yes: [[price, qty], ...], no: [[price, qty], ...] }
         // Kalshi returns bids at their actual prices (not inverted)

package/dist/exchanges/kalshi/fetchTrades.d.ts

@@ -1,3 +1,4 @@
+import { AxiosInstance } from 'axios';
 import { HistoryFilterParams, TradesParams } from '../../BaseExchange';
 import { Trade } from '../../types';
-export declare function fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+export declare function fetchTrades(id: string, params: TradesParams | HistoryFilterParams, http?: AxiosInstance): Promise<Trade[]>;

package/dist/exchanges/kalshi/fetchTrades.js

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchTrades = fetchTrades;
 const axios_1 = __importDefault(require("axios"));
 const errors_1 = require("./errors");
-async function fetchTrades(id, params) {
+async function fetchTrades(id, params, http = axios_1.default) {
     try {
         const ticker = id.replace(/-NO$/, '');
         const url = `https://api.elections.kalshi.com/trade-api/v2/markets/trades`;
-        const response = await axios_1.default.get(url, {
+        const response = await http.get(url, {
             params: {
                 ticker: ticker,
                 limit: params.limit || 100

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

@@ -7,6 +7,21 @@ export interface KalshiExchangeOptions {
     websocket?: KalshiWebSocketConfig;
 }
 export declare class KalshiExchange extends PredictionMarketExchange {
+    readonly has: {
+        fetchMarkets: true;
+        fetchEvents: true;
+        fetchOHLCV: true;
+        fetchOrderBook: true;
+        fetchTrades: true;
+        createOrder: true;
+        cancelOrder: true;
+        fetchOrder: true;
+        fetchOpenOrders: true;
+        fetchPositions: true;
+        fetchBalance: true;
+        watchOrderBook: true;
+        watchTrades: true;
+    };
     private auth?;
     private wsConfig?;
     constructor(options?: ExchangeCredentials | KalshiExchangeOptions);

package/dist/exchanges/kalshi/index.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KalshiExchange = void 0;
-const axios_1 = __importDefault(require("axios"));
 const BaseExchange_1 = require("../../BaseExchange");
 const fetchMarkets_1 = require("./fetchMarkets");
 const fetchEvents_1 = require("./fetchEvents");
@@ -16,6 +12,21 @@ const websocket_1 = require("./websocket");
 const errors_1 = require("./errors");
 const errors_2 = require("../../errors");
 class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
+    has = {
+        fetchMarkets: true,
+        fetchEvents: true,
+        fetchOHLCV: true,
+        fetchOrderBook: true,
+        fetchTrades: true,
+        createOrder: true,
+        cancelOrder: true,
+        fetchOrder: true,
+        fetchOpenOrders: true,
+        fetchPositions: true,
+        fetchBalance: true,
+        watchOrderBook: true,
+        watchTrades: true,
+    };
     auth;
     wsConfig;
     constructor(options) {
@@ -57,16 +68,16 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     // Market Data Methods - Implementation for CCXT-style API
     // ----------------------------------------------------------------------------
     async fetchMarketsImpl(params) {
-        return (0, fetchMarkets_1.fetchMarkets)(params);
+        return (0, fetchMarkets_1.fetchMarkets)(params, this.http);
     }
     async fetchEventsImpl(params) {
-        return (0, fetchEvents_1.fetchEvents)(params);
+        return (0, fetchEvents_1.fetchEvents)(params, this.http);
     }
     async fetchOHLCV(id, params) {
-        return (0, fetchOHLCV_1.fetchOHLCV)(id, params);
+        return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.http);
     }
     async fetchOrderBook(id) {
-        return (0, fetchOrderBook_1.fetchOrderBook)(id);
+        return (0, fetchOrderBook_1.fetchOrderBook)(id, this.http);
     }
     async fetchTrades(id, params) {
         // Deprecation warning
@@ -74,7 +85,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             console.warn('[pmxt] Warning: The "resolution" parameter is deprecated for fetchTrades() and will be ignored. ' +
                 'It will be removed in v3.0.0. Please remove it from your code.');
         }
-        return (0, fetchTrades_1.fetchTrades)(id, params);
+        return (0, fetchTrades_1.fetchTrades)(id, params, this.http);
     }
     // ----------------------------------------------------------------------------
     // User Data Methods
@@ -88,7 +99,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             // TODO: Make base URL configurable in credentials
             const baseUrl = this.getBaseUrl();
             const headers = auth.getHeaders('GET', path);
-            const response = await axios_1.default.get(`${baseUrl}${path}`, { headers });
+            const response = await this.http.get(`${baseUrl}${path}`, { headers });
             // Kalshi response structure:
             // - balance: Available balance in cents (for trading)
             // - portfolio_value: Total portfolio value in cents (includes positions)
@@ -139,7 +150,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
                     kalshiOrder.no_price = priceInCents;
                 }
             }
-            const response = await axios_1.default.post(`${baseUrl}${path}`, kalshiOrder, { headers });
+            const response = await this.http.post(`${baseUrl}${path}`, kalshiOrder, { headers });
             const order = response.data.order;
             return {
                 id: order.order_id,
@@ -165,7 +176,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             const path = `/trade-api/v2/portfolio/orders/${orderId}`;
             const baseUrl = this.getBaseUrl();
             const headers = auth.getHeaders('DELETE', path);
-            const response = await axios_1.default.delete(`${baseUrl}${path}`, { headers });
+            const response = await this.http.delete(`${baseUrl}${path}`, { headers });
             const order = response.data.order;
             return {
                 id: order.order_id,
@@ -190,7 +201,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             const path = `/trade-api/v2/portfolio/orders/${orderId}`;
             const baseUrl = this.getBaseUrl();
             const headers = auth.getHeaders('GET', path);
-            const response = await axios_1.default.get(`${baseUrl}${path}`, { headers });
+            const response = await this.http.get(`${baseUrl}${path}`, { headers });
             const order = response.data.order;
             return {
                 id: order.order_id,
@@ -222,7 +233,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             const baseUrl = this.getBaseUrl();
             // Sign only the base path, not the query parameters
             const headers = auth.getHeaders('GET', basePath);
-            const response = await axios_1.default.get(`${baseUrl}${basePath}${queryParams}`, { headers });
+            const response = await this.http.get(`${baseUrl}${basePath}${queryParams}`, { headers });
             const orders = response.data.orders || [];
             return orders.map((order) => ({
                 id: order.order_id,
@@ -248,7 +259,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             const path = '/trade-api/v2/portfolio/positions';
             const baseUrl = this.getBaseUrl();
             const headers = auth.getHeaders('GET', path);
-            const response = await axios_1.default.get(`${baseUrl}${path}`, { headers });
+            const response = await this.http.get(`${baseUrl}${path}`, { headers });
             const positions = response.data.market_positions || [];
             return positions.map((pos) => {
                 const absPosition = Math.abs(pos.position);