pmxt-core 2.23.0 → 2.25.0

package/dist/exchanges/smarkets/fetcher.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmarketsFetcher = void 0;
+const errors_1 = require("./errors");
+const errors_2 = require("../../errors");
+const validation_1 = require("../../utils/validation");
+// ----------------------------------------------------------------------------
+// Fetcher
+// ----------------------------------------------------------------------------
+const BATCH_SIZE = 200;
+const MAX_PAGES = 100;
+const EVENT_ID_BATCH_SIZE = 50;
+const MARKET_ID_BATCH_SIZE = 100;
+class SmarketsFetcher {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    // -- Markets (returns enriched events with nested markets/contracts) ------
+    async fetchRawMarkets(params) {
+        try {
+            if (params?.eventId) {
+                return this.fetchEnrichedEventById(params.eventId);
+            }
+            if (params?.marketId) {
+                return this.fetchEnrichedEventByMarketId(params.marketId);
+            }
+            return this.fetchAllEnrichedEvents(params);
+        }
+        catch (error) {
+            throw errors_1.smarketsErrorMapper.mapError(error);
+        }
+    }
+    // -- Events ---------------------------------------------------------------
+    async fetchRawEvents(params) {
+        try {
+            if (params.eventId) {
+                return this.fetchEnrichedEventById(params.eventId);
+            }
+            const stateFilter = this.mapEventStatus(params?.status || 'active');
+            const rawEvents = await this.fetchPaginatedEvents({
+                state: stateFilter,
+                type_scope: ['single_event'],
+                with_new_type: true,
+            });
+            return this.enrichEvents(rawEvents);
+        }
+        catch (error) {
+            throw errors_1.smarketsErrorMapper.mapError(error);
+        }
+    }
+    // -- OrderBook ------------------------------------------------------------
+    async fetchRawOrderBook(id) {
+        (0, validation_1.validateIdFormat)(id, 'OrderBook');
+        // get_quotes is marked as private in the spec but works without auth
+        // (returns delayed data). Use a direct HTTP call so it works without credentials.
+        const url = `https://api.smarkets.com/v3/markets/${encodeURIComponent(id)}/quotes/`;
+        const headers = {
+            ...this.ctx.getHeaders(),
+        };
+        const response = await this.ctx.http.get(url, { headers });
+        const data = response.data;
+        if (!data || Object.keys(data).length === 0) {
+            throw new errors_2.NotFound(`Order book not found: ${id}`, 'Smarkets');
+        }
+        return data;
+    }
+    // -- Trades (account activity) --------------------------------------------
+    async fetchRawTradeActivity(marketId, _params) {
+        const data = await this.ctx.callApi('get_activity', {
+            market_id: [marketId],
+            source: ['order.execute', 'order.execute.confirm'],
+            limit: 100,
+            sort: '-seq,-subseq',
+        });
+        return (data.account_activity || []);
+    }
+    async fetchRawMyTradeActivity(params = {}) {
+        const queryParams = {
+            source: ['order.execute', 'order.execute.confirm'],
+            limit: params.limit || 100,
+            sort: '-seq,-subseq',
+        };
+        if (params.marketId)
+            queryParams.market_id = [params.marketId];
+        if (params.since)
+            queryParams.timestamp_min = params.since;
+        if (params.until)
+            queryParams.timestamp_max = params.until;
+        const data = await this.ctx.callApi('get_activity', queryParams);
+        return (data.account_activity || []);
+    }
+    // -- User data ------------------------------------------------------------
+    async fetchRawBalance() {
+        const data = await this.ctx.callApi('get_account');
+        return data.account;
+    }
+    async fetchRawOrders(queryParams = {}) {
+        const data = await this.ctx.callApi('get_orders', {
+            limit: 100,
+            ...queryParams,
+        });
+        return data.orders || [];
+    }
+    async fetchRawOrderById(orderId) {
+        const data = await this.ctx.callApi('get_orders', {
+            id: [orderId],
+            limit: 1,
+        });
+        const orders = data.orders || [];
+        if (orders.length === 0) {
+            throw new errors_2.NotFound(`Order not found: ${orderId}`, 'Smarkets');
+        }
+        return orders[0];
+    }
+    async fetchRawPositions() {
+        // Smarkets does not have a dedicated positions endpoint.
+        // Derive positions from open/partial orders.
+        return this.fetchRawOrders({ state: ['created', 'partial'] });
+    }
+    async fetchRawClosedOrders(params = {}) {
+        const queryParams = {
+            state: ['filled', 'settled'],
+        };
+        if (params.marketId)
+            queryParams.market_id = [params.marketId];
+        if (params.limit)
+            queryParams.limit = params.limit;
+        if (params.since)
+            queryParams.created_datetime_min = params.since;
+        if (params.until)
+            queryParams.created_datetime_max = params.until;
+        return this.fetchRawOrders(queryParams);
+    }
+    // -- Private helpers ------------------------------------------------------
+    async fetchEnrichedEventById(eventId) {
+        const data = await this.ctx.callApi('get_events', { id: [eventId] });
+        const events = data.events || [];
+        if (events.length === 0)
+            return [];
+        return this.enrichEvents(events);
+    }
+    async fetchEnrichedEventByMarketId(marketId) {
+        // Step 1: Fetch contracts for this market to confirm it exists
+        const contractsData = await this.ctx.callApi('get_contracts_by_market_ids', {
+            market_ids: [marketId],
+        });
+        const contracts = contractsData.contracts || [];
+        if (contracts.length === 0)
+            return [];
+        // Step 2: Fetch volumes for this market
+        const volumeData = await this.ctx.callApi('get_volumes_by_market_ids', {
+            market_ids: [marketId],
+        });
+        const volumes = volumeData.volumes || [];
+        // Step 3: We need the event_id. The contracts have market_id but not event_id.
+        // Use the events/markets endpoint by searching for events that contain this market.
+        // The most reliable approach: fetch all active events and find the one that owns
+        // this market. But that's expensive. Instead, we can search events with the market
+        // contracts and use the get_events endpoint with filtering.
+        //
+        // Actually, the Smarkets API returns market_id on contracts but event_id on markets.
+        // We need to get the market object itself. The get_markets_by_event_ids endpoint
+        // requires event_ids. So we iterate: get events that are bettable and look for our market.
+        //
+        // Better approach: use get_events with no filter and check pagination.
+        // But the simplest correct approach is: get ALL bettable events, enrich them,
+        // and filter for the market. This is too expensive.
+        //
+        // Practical approach: The Smarkets API doesn't expose a direct market->event lookup.
+        // We paginate through recent events and check if any contain our market.
+        // For now, fetch a reasonable batch and search.
+        const rawEvents = await this.fetchPaginatedEvents({
+            state: ['new', 'upcoming', 'live'],
+            type_scope: ['single_event'],
+            with_new_type: true,
+            limit: BATCH_SIZE,
+        }, BATCH_SIZE * 3);
+        // Fetch markets for these events and find the one containing our marketId
+        const eventIds = rawEvents.map(e => e.id);
+        const allMarkets = await this.fetchMarketsByEventIds(eventIds);
+        const targetMarket = allMarkets.find(m => m.id === marketId);
+        if (!targetMarket) {
+            return [];
+        }
+        // Now we have the event_id
+        const eventData = await this.ctx.callApi('get_events', { id: [targetMarket.event_id] });
+        const events = eventData.events || [];
+        if (events.length === 0)
+            return [];
+        return [{
+                event: events[0],
+                markets: [targetMarket],
+                contracts,
+                volumes,
+            }];
+    }
+    async fetchAllEnrichedEvents(params) {
+        const stateFilter = this.mapEventStatus(params?.status || 'active');
+        const limit = params?.limit || 1000;
+        const rawEvents = await this.fetchPaginatedEvents({
+            state: stateFilter,
+            type_scope: ['single_event'],
+            with_new_type: true,
+            limit: Math.min(limit, BATCH_SIZE),
+        }, limit);
+        return this.enrichEvents(rawEvents);
+    }
+    async enrichEvents(events) {
+        if (events.length === 0)
+            return [];
+        const eventIds = events.map(e => e.id);
+        const allMarkets = await this.fetchMarketsByEventIds(eventIds);
+        const marketIds = allMarkets.map(m => m.id);
+        const [allContracts, fetchedVolumes] = await Promise.all([
+            this.fetchContractsByMarketIds(marketIds),
+            this.fetchVolumesByMarketIds(marketIds),
+        ]);
+        const marketsByEvent = new Map();
+        for (const market of allMarkets) {
+            const existing = marketsByEvent.get(market.event_id) || [];
+            marketsByEvent.set(market.event_id, [...existing, market]);
+        }
+        const contractsByMarket = new Map();
+        for (const contract of allContracts) {
+            const existing = contractsByMarket.get(contract.market_id) || [];
+            contractsByMarket.set(contract.market_id, [...existing, contract]);
+        }
+        const volumesByMarket = new Map();
+        for (const volume of fetchedVolumes) {
+            volumesByMarket.set(volume.market_id, volume);
+        }
+        return events.map(event => {
+            const eventMarkets = marketsByEvent.get(event.id) || [];
+            const eventContracts = [];
+            const eventVolumes = [];
+            for (const market of eventMarkets) {
+                const mc = contractsByMarket.get(market.id) || [];
+                eventContracts.push(...mc);
+                const vol = volumesByMarket.get(market.id);
+                if (vol)
+                    eventVolumes.push(vol);
+            }
+            return {
+                event,
+                markets: eventMarkets,
+                contracts: eventContracts,
+                volumes: eventVolumes,
+            };
+        });
+    }
+    async fetchPaginatedEvents(queryParams, targetCount) {
+        let allEvents = [];
+        let lastId;
+        let page = 0;
+        do {
+            const params = {
+                limit: BATCH_SIZE,
+                sort: 'id',
+                ...queryParams,
+            };
+            if (lastId) {
+                params.pagination_last_id = lastId;
+            }
+            const data = await this.ctx.callApi('get_events', params);
+            const events = data.events || [];
+            if (events.length === 0)
+                break;
+            allEvents = [...allEvents, ...events];
+            // Check pagination: next_page is null when there are no more results
+            const nextPage = data.pagination?.next_page;
+            if (!nextPage)
+                break;
+            lastId = events[events.length - 1].id;
+            page++;
+            if (targetCount && allEvents.length >= targetCount)
+                break;
+        } while (page < MAX_PAGES);
+        return allEvents;
+    }
+    async fetchMarketsByEventIds(eventIds) {
+        const batches = this.batchArray(eventIds, EVENT_ID_BATCH_SIZE);
+        const results = await Promise.all(batches.map(async (batch) => {
+            const data = await this.ctx.callApi('get_markets_by_event_ids', {
+                event_ids: batch,
+            });
+            return (data.markets || []);
+        }));
+        return results.flat();
+    }
+    async fetchContractsByMarketIds(marketIds) {
+        if (marketIds.length === 0)
+            return [];
+        const batches = this.batchArray(marketIds, MARKET_ID_BATCH_SIZE);
+        const results = await Promise.all(batches.map(async (batch) => {
+            const data = await this.ctx.callApi('get_contracts_by_market_ids', {
+                market_ids: batch,
+            });
+            return (data.contracts || []);
+        }));
+        return results.flat();
+    }
+    async fetchVolumesByMarketIds(marketIds) {
+        if (marketIds.length === 0)
+            return [];
+        const batches = this.batchArray(marketIds, MARKET_ID_BATCH_SIZE);
+        const results = await Promise.all(batches.map(async (batch) => {
+            try {
+                const data = await this.ctx.callApi('get_volumes_by_market_ids', {
+                    market_ids: batch,
+                });
+                return (data.volumes || []);
+            }
+            catch {
+                // Volumes are non-critical; return empty on failure
+                return [];
+            }
+        }));
+        return results.flat();
+    }
+    mapEventStatus(status) {
+        switch (status) {
+            case 'active':
+                return ['new', 'upcoming', 'live'];
+            case 'closed':
+            case 'inactive':
+                return ['ended', 'settled'];
+            case 'all':
+                return ['new', 'upcoming', 'live', 'ended', 'settled', 'cancelled', 'suspended'];
+            default:
+                return ['new', 'upcoming', 'live'];
+        }
+    }
+    batchArray(items, batchSize) {
+        const batches = [];
+        for (let i = 0; i < items.length; i += batchSize) {
+            batches.push(items.slice(i, i + batchSize));
+        }
+        return batches;
+    }
+}
+exports.SmarketsFetcher = SmarketsFetcher;

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

@@ -0,0 +1,54 @@
+import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, TradesParams, ExchangeCredentials, EventFetchParams, MyTradesParams, OrderHistoryParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, OrderBook, Trade, UserTrade, Balance, Order, Position, CreateOrderParams, BuiltOrder } from '../../types';
+export declare class SmarketsExchange extends PredictionMarketExchange {
+    readonly has: {
+        fetchMarkets: true;
+        fetchEvents: true;
+        fetchOHLCV: false;
+        fetchOrderBook: true;
+        fetchTrades: true;
+        createOrder: true;
+        cancelOrder: true;
+        fetchOrder: true;
+        fetchOpenOrders: true;
+        fetchPositions: "emulated";
+        fetchBalance: true;
+        watchAddress: false;
+        unwatchAddress: false;
+        watchOrderBook: false;
+        watchTrades: false;
+        fetchMyTrades: true;
+        fetchClosedOrders: true;
+        fetchAllOrders: true;
+        buildOrder: true;
+        submitOrder: true;
+    };
+    private auth?;
+    private loginPromise;
+    private readonly config;
+    private readonly fetcher;
+    private readonly normalizer;
+    constructor(credentials?: ExchangeCredentials);
+    get name(): string;
+    private ensureSession;
+    private performLogin;
+    protected sign(_method: string, _path: string, _params: Record<string, any>): Record<string, string>;
+    protected mapImplicitApiError(error: any): any;
+    private requireAuth;
+    protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    fetchOrderBook(id: string): Promise<OrderBook>;
+    fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+    fetchBalance(): Promise<Balance[]>;
+    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
+    fetchPositions(): Promise<Position[]>;
+    fetchClosedOrders(params?: OrderHistoryParams): Promise<Order[]>;
+    fetchAllOrders(params?: OrderHistoryParams): Promise<Order[]>;
+    buildOrder(params: CreateOrderParams): Promise<BuiltOrder>;
+    submitOrder(built: BuiltOrder): Promise<Order>;
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    cancelOrder(orderId: string): Promise<Order>;
+    fetchOrder(orderId: string): Promise<Order>;
+    fetchOpenOrders(marketId?: string): Promise<Order[]>;
+    close(): Promise<void>;
+}

package/dist/exchanges/smarkets/index.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmarketsExchange = void 0;
+const BaseExchange_1 = require("../../BaseExchange");
+const auth_1 = require("./auth");
+const errors_1 = require("./errors");
+const errors_2 = require("../../errors");
+const openapi_1 = require("../../utils/openapi");
+const api_1 = require("./api");
+const config_1 = require("./config");
+const fetcher_1 = require("./fetcher");
+const normalizer_1 = require("./normalizer");
+const price_1 = require("./price");
+class SmarketsExchange extends BaseExchange_1.PredictionMarketExchange {
+    has = {
+        fetchMarkets: true,
+        fetchEvents: true,
+        fetchOHLCV: false,
+        fetchOrderBook: true,
+        fetchTrades: true,
+        createOrder: true,
+        cancelOrder: true,
+        fetchOrder: true,
+        fetchOpenOrders: true,
+        fetchPositions: 'emulated',
+        fetchBalance: true,
+        watchAddress: false,
+        unwatchAddress: false,
+        watchOrderBook: false,
+        watchTrades: false,
+        fetchMyTrades: true,
+        fetchClosedOrders: true,
+        fetchAllOrders: true,
+        buildOrder: true,
+        submitOrder: true,
+    };
+    auth;
+    loginPromise = null;
+    config;
+    fetcher;
+    normalizer;
+    constructor(credentials) {
+        super(credentials);
+        this.rateLimit = 100;
+        this.config = (0, config_1.getSmarketsConfig)();
+        // Smarkets API expects repeated keys for arrays (e.g. state=new&state=live)
+        // rather than the axios default bracket format (state[]=new&state[]=live)
+        this.http.defaults.paramsSerializer = (params) => {
+            const parts = [];
+            for (const [key, value] of Object.entries(params)) {
+                if (value === undefined || value === null)
+                    continue;
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`);
+                    }
+                }
+                else {
+                    parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+                }
+            }
+            return parts.join('&');
+        };
+        if (credentials?.apiKey && credentials?.privateKey) {
+            this.auth = new auth_1.SmarketsAuth(credentials);
+        }
+        const descriptor = (0, openapi_1.parseOpenApiSpec)(api_1.smarketsApiSpec, this.config.apiUrl);
+        this.defineImplicitApi(descriptor);
+        const ctx = {
+            http: this.http,
+            callApi: this.callApi.bind(this),
+            getHeaders: () => this.auth?.getHeaders('', '') ?? {},
+        };
+        this.fetcher = new fetcher_1.SmarketsFetcher(ctx);
+        this.normalizer = new normalizer_1.SmarketsNormalizer();
+    }
+    get name() {
+        return 'Smarkets';
+    }
+    // -------------------------------------------------------------------------
+    // Session Management
+    // -------------------------------------------------------------------------
+    async ensureSession() {
+        const auth = this.requireAuth();
+        if (auth.isAuthenticated()) {
+            return;
+        }
+        // Deduplicate concurrent login attempts
+        if (this.loginPromise) {
+            return this.loginPromise;
+        }
+        this.loginPromise = this.performLogin(auth);
+        try {
+            await this.loginPromise;
+        }
+        finally {
+            this.loginPromise = null;
+        }
+    }
+    async performLogin(auth) {
+        const response = await this.http.post(`${this.config.apiUrl}/v3/sessions/`, {
+            username: auth.getUsername(),
+            password: auth.getPassword(),
+        }, { headers: { 'Content-Type': 'application/json' } });
+        const data = response.data;
+        if (data.factor && data.factor !== 'complete') {
+            throw new errors_2.AuthenticationError(`Smarkets requires additional authentication factor: ${data.factor}. ` +
+                'MFA (TOTP/NemID) is not yet supported by pmxt.', 'Smarkets');
+        }
+        if (!data.token) {
+            throw new errors_2.AuthenticationError('Smarkets login succeeded but no session token was returned.', 'Smarkets');
+        }
+        auth.setToken(data.token, data.stop || '');
+    }
+    // -------------------------------------------------------------------------
+    // Implicit API Auth & Error Mapping
+    // -------------------------------------------------------------------------
+    sign(_method, _path, _params) {
+        const auth = this.requireAuth();
+        return auth.getHeaders(_method, _path);
+    }
+    mapImplicitApiError(error) {
+        throw errors_1.smarketsErrorMapper.mapError(error);
+    }
+    requireAuth() {
+        if (!this.auth) {
+            throw new errors_2.AuthenticationError('This operation requires authentication. ' +
+                'Initialize SmarketsExchange with credentials (apiKey and privateKey).', 'Smarkets');
+        }
+        return this.auth;
+    }
+    // -------------------------------------------------------------------------
+    // Market Data (fetcher -> normalizer)
+    // -------------------------------------------------------------------------
+    async fetchMarketsImpl(params) {
+        const rawEvents = await this.fetcher.fetchRawMarkets(params);
+        const allMarkets = [];
+        for (const event of rawEvents) {
+            const markets = this.normalizer.normalizeMarketsFromEvent(event);
+            allMarkets.push(...markets);
+        }
+        // Query-based search (client-side filtering)
+        if (params?.query) {
+            const lowerQuery = params.query.toLowerCase();
+            const searchIn = params?.searchIn || 'title';
+            const filtered = allMarkets.filter((market) => {
+                const titleMatch = (market.title || '').toLowerCase().includes(lowerQuery);
+                const descMatch = (market.description || '').toLowerCase().includes(lowerQuery);
+                if (searchIn === 'title')
+                    return titleMatch;
+                if (searchIn === 'description')
+                    return descMatch;
+                return titleMatch || descMatch;
+            });
+            return filtered.slice(0, params?.limit || 250000);
+        }
+        // Client-side sort
+        if (params?.sort === 'volume') {
+            allMarkets.sort((a, b) => b.volume24h - a.volume24h);
+        }
+        else if (params?.sort === 'liquidity') {
+            allMarkets.sort((a, b) => b.liquidity - a.liquidity);
+        }
+        const offset = params?.offset || 0;
+        const limit = params?.limit || 250000;
+        return allMarkets.slice(offset, offset + limit);
+    }
+    async fetchEventsImpl(params) {
+        const rawEvents = await this.fetcher.fetchRawEvents(params);
+        const limit = params?.limit || 10000;
+        const query = (params?.query || '').toLowerCase();
+        const filtered = query
+            ? rawEvents.filter((event) => (event.event.name || '').toLowerCase().includes(query))
+            : rawEvents;
+        return filtered
+            .map((raw) => this.normalizer.normalizeEvent(raw))
+            .filter((e) => e !== null)
+            .slice(0, limit);
+    }
+    async fetchOrderBook(id) {
+        const raw = await this.fetcher.fetchRawOrderBook(id);
+        return this.normalizer.normalizeOrderBook(raw, id);
+    }
+    async fetchTrades(id, params) {
+        if ('resolution' in params && params.resolution !== undefined) {
+            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.');
+        }
+        const rawActivity = await this.fetcher.fetchRawTradeActivity(id, params);
+        return rawActivity.map((raw, i) => this.normalizer.normalizeActivityTrade(raw, i));
+    }
+    // -------------------------------------------------------------------------
+    // User Data (fetcher -> normalizer)
+    // -------------------------------------------------------------------------
+    async fetchBalance() {
+        await this.ensureSession();
+        const raw = await this.fetcher.fetchRawBalance();
+        return this.normalizer.normalizeBalance(raw);
+    }
+    async fetchMyTrades(params) {
+        await this.ensureSession();
+        const rawActivity = await this.fetcher.fetchRawMyTradeActivity(params || {});
+        return rawActivity.map((raw, i) => this.normalizer.normalizeActivityUserTrade(raw, i));
+    }
+    async fetchPositions() {
+        await this.ensureSession();
+        const rawPositions = await this.fetcher.fetchRawPositions();
+        return rawPositions.map((raw) => this.normalizer.normalizePosition(raw));
+    }
+    async fetchClosedOrders(params) {
+        await this.ensureSession();
+        const rawOrders = await this.fetcher.fetchRawClosedOrders(params || {});
+        return rawOrders.map((o) => this.normalizer.normalizeOrder(o));
+    }
+    async fetchAllOrders(params) {
+        await this.ensureSession();
+        const [openOrders, closedOrders] = await Promise.all([
+            this.fetcher.fetchRawOrders({}),
+            this.fetcher.fetchRawClosedOrders(params || {}),
+        ]);
+        const seen = new Set();
+        const all = [];
+        for (const o of [...openOrders, ...closedOrders]) {
+            const id = String(o.id || o.order_id);
+            if (!seen.has(id)) {
+                seen.add(id);
+                all.push(this.normalizer.normalizeOrder(o));
+            }
+        }
+        return all.sort((a, b) => b.timestamp - a.timestamp);
+    }
+    // -------------------------------------------------------------------------
+    // Trading
+    // -------------------------------------------------------------------------
+    async buildOrder(params) {
+        const smarketsType = params.type === 'market'
+            ? 'immediate_or_cancel'
+            : 'good_til_halted';
+        const body = {
+            market_id: params.marketId,
+            contract_id: params.outcomeId,
+            side: params.side === 'buy' ? 'buy' : 'sell',
+            quantity: (0, price_1.toQuantityUnits)(params.amount),
+            type: smarketsType,
+        };
+        if (params.price !== undefined) {
+            body.price = (0, price_1.toBasisPoints)(params.price);
+        }
+        return { exchange: this.name, params, raw: body };
+    }
+    async submitOrder(built) {
+        await this.ensureSession();
+        const data = await this.callApi('create_order', built.raw);
+        return this.normalizer.normalizeCreateOrderResponse(data);
+    }
+    async createOrder(params) {
+        const built = await this.buildOrder(params);
+        return this.submitOrder(built);
+    }
+    async cancelOrder(orderId) {
+        await this.ensureSession();
+        await this.callApi('cancel_order', { order_id: orderId });
+        // cancel_order returns empty {} on success; fetch the order to get its state
+        return this.fetchOrder(orderId);
+    }
+    async fetchOrder(orderId) {
+        await this.ensureSession();
+        const data = await this.fetcher.fetchRawOrderById(orderId);
+        return this.normalizer.normalizeOrder(data);
+    }
+    async fetchOpenOrders(marketId) {
+        await this.ensureSession();
+        const queryParams = {
+            state: ['created', 'partial'],
+        };
+        if (marketId)
+            queryParams.market_id = [marketId];
+        const rawOrders = await this.fetcher.fetchRawOrders(queryParams);
+        return rawOrders.map((o) => this.normalizer.normalizeOrder(o));
+    }
+    async close() {
+        // No WebSocket or persistent connections to clean up
+    }
+}
+exports.SmarketsExchange = SmarketsExchange;