pmxt-core 2.22.2 → 2.23.0

package/dist/exchanges/metaculus/fetchEvents.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchEvents = fetchEvents;
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+const BATCH_SIZE = 100;
+const MAX_PAGES = 200;
+/**
+ * Map pmxt status values to Metaculus `statuses` array param.
+ */
+function toApiStatuses(status) {
+    if (!status || status === "all")
+        return undefined;
+    if (status === "closed" || status === "inactive")
+        return ["closed", "resolved"];
+    return ["open"];
+}
+/**
+ * Fetch pages of posts with pagination.
+ */
+async function fetchPostPages(callApi, apiParams, targetCount) {
+    let all = [];
+    let offset = 0;
+    let page = 0;
+    do {
+        const data = await callApi("GetPosts", {
+            ...apiParams,
+            limit: BATCH_SIZE,
+            offset,
+        });
+        const results = data.results ?? [];
+        if (results.length === 0)
+            break;
+        all = all.concat(results);
+        offset += results.length;
+        page++;
+        if (targetCount && all.length >= targetCount)
+            break;
+        if (!data.next)
+            break;
+    } while (page < MAX_PAGES);
+    return all;
+}
+/**
+ * Wrap a single Metaculus Post as a UnifiedEvent.
+ *
+ * For single-question posts, the event contains one market.
+ * For group-of-questions posts, the event contains one market per sub-question
+ * (expanded via expandPost).
+ */
+function postToEvent(post) {
+    const markets = (0, utils_1.expandPost)(post);
+    if (markets.length === 0)
+        return null;
+    const id = String(post.id);
+    return {
+        id,
+        title: post.title ?? "",
+        description: post.question?.description
+            ?? post.group_of_questions?.description
+            ?? post.question?.resolution_criteria
+            ?? "",
+        slug: post.slug ?? post.url_title ?? id,
+        markets,
+        volume24h: 0,
+        volume: 0,
+        url: `https://www.metaculus.com/questions/${id}/`,
+        image: post.projects?.default_project?.header_image ?? undefined,
+        category: post?.projects?.category?.[0] != null
+            ? typeof post.projects.category[0] === "string"
+                ? post.projects.category[0]
+                : post.projects.category[0]?.name
+            : undefined,
+        tags: markets[0]?.tags ?? [],
+    };
+}
+/**
+ * Fetch a single post by numeric ID and return it as a UnifiedEvent.
+ */
+async function fetchEventByPostId(id, callApi) {
+    const numericId = parseInt(id, 10);
+    if (isNaN(numericId))
+        return [];
+    const data = await callApi("GetPost", { postId: numericId });
+    if (!data || !data.id)
+        return [];
+    const event = postToEvent(data);
+    return event ? [event] : [];
+}
+/**
+ * Look up an event by slug -- try numeric ID first, then tournament slug,
+ * then client-side slug match.
+ */
+async function fetchEventBySlug(slug, callApi) {
+    // Try as numeric post ID
+    const byId = await fetchEventByPostId(slug, callApi);
+    if (byId.length > 0)
+        return byId;
+    // Try as tournament-slug filter -- fetch posts belonging to that tournament
+    try {
+        const posts = await fetchPostPages(callApi, { tournaments: [slug], with_cp: true, order_by: "-forecasts_count" }, 100);
+        if (posts.length > 0) {
+            // Represent the whole tournament as a single event whose markets
+            // are the individual posts (and their sub-questions, expanded)
+            const markets = posts.flatMap((p) => (0, utils_1.expandPost)(p, slug));
+            return [
+                {
+                    id: slug,
+                    title: slug,
+                    description: "",
+                    slug,
+                    markets,
+                    volume24h: 0,
+                    volume: 0,
+                    url: `https://www.metaculus.com/tournament/${slug}/`,
+                    image: undefined,
+                    category: undefined,
+                    tags: [],
+                },
+            ];
+        }
+    }
+    catch {
+        // fall through
+    }
+    // Finally try slug match against post.slug / post.url_title
+    const posts = await fetchPostPages(callApi, { with_cp: true, order_by: "-forecasts_count" }, 500);
+    const lower = slug.toLowerCase();
+    for (const p of posts) {
+        if ((p.slug ?? "").toLowerCase() === lower ||
+            (p.url_title ?? "").toLowerCase() === lower) {
+            const event = postToEvent(p);
+            return event ? [event] : [];
+        }
+    }
+    return [];
+}
+async function fetchEvents(params, callApi) {
+    try {
+        // Direct lookup by slug (post ID, tournament slug, or url_title)
+        if (params.slug) {
+            return await fetchEventBySlug(params.slug, callApi);
+        }
+        // Direct lookup by eventId (post ID or tournament slug)
+        if (params.eventId) {
+            // Try as numeric post ID first
+            const byId = await fetchEventByPostId(params.eventId, callApi);
+            if (byId.length > 0)
+                return byId;
+            // Try as tournament slug
+            return await fetchEventBySlug(params.eventId, callApi);
+        }
+        // Default listing -- wrap posts as standalone events
+        const limit = params?.limit ?? 50;
+        const offset = params?.offset ?? 0;
+        const query = (params?.query ?? "").toLowerCase();
+        const statuses = toApiStatuses(params?.status);
+        const apiParams = {
+            with_cp: true,
+        };
+        if (statuses)
+            apiParams.statuses = statuses;
+        // Sort mapping
+        if (params?.sort === "newest") {
+            apiParams.order_by = "-published_at";
+        }
+        else {
+            apiParams.order_by = "-forecasts_count";
+        }
+        const posts = await fetchPostPages(callApi, apiParams, (offset + limit) * (query ? 5 : 1));
+        // Client-side keyword filter
+        const filtered = query
+            ? posts.filter((p) => (p.title ?? "").toLowerCase().includes(query) ||
+                (p.question?.description ?? "").toLowerCase().includes(query))
+            : posts;
+        const events = [];
+        for (const p of filtered.slice(offset, offset + limit)) {
+            const e = postToEvent(p);
+            if (e)
+                events.push(e);
+        }
+        return events;
+    }
+    catch (error) {
+        throw errors_1.metaculusErrorMapper.mapError(error);
+    }
+}

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

@@ -0,0 +1,6 @@
+import { MarketFetchParams } from "../../BaseExchange";
+import { UnifiedMarket } from "../../types";
+type CallApi = (operationId: string, params?: Record<string, any>) => Promise<any>;
+export declare function resetCache(): void;
+export declare function fetchMarkets(params: MarketFetchParams | undefined, callApi: CallApi): Promise<UnifiedMarket[]>;
+export {};

package/dist/exchanges/metaculus/fetchMarkets.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetCache = resetCache;
+exports.fetchMarkets = fetchMarkets;
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+const BATCH_SIZE = 100; // max per page
+const MAX_PAGES = 200; // safety cap (~20 000 posts)
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+// Module-level cache for the default active-posts listing
+let cachedPosts = null;
+let lastCacheTime = 0;
+function resetCache() {
+    cachedPosts = null;
+    lastCacheTime = 0;
+}
+/**
+ * Map pmxt status values to Metaculus `statuses` array param.
+ */
+function toApiStatuses(status) {
+    if (!status || status === "all")
+        return undefined;
+    if (status === "closed" || status === "inactive")
+        return ["closed", "resolved"];
+    return ["open"]; // "active" or anything else -> open
+}
+/**
+ * Fetch pages of posts from /api/posts/ using offset-based pagination.
+ *
+ * Note: group-of-questions posts expand into multiple markets, so the
+ * actual number of markets may exceed the number of raw posts fetched.
+ * The targetCount is a rough guide, not exact.
+ */
+async function fetchPostPages(callApi, apiParams, targetCount) {
+    let all = [];
+    let offset = 0;
+    let page = 0;
+    do {
+        const data = await callApi("GetPosts", {
+            ...apiParams,
+            limit: BATCH_SIZE,
+            offset,
+        });
+        const results = data.results ?? [];
+        if (results.length === 0)
+            break;
+        all = all.concat(results);
+        offset += results.length;
+        page++;
+        // Early-exit when we have enough results (with buffer for filtering)
+        if (targetCount && all.length >= targetCount * 1.5)
+            break;
+        if (!data.next)
+            break;
+    } while (page < MAX_PAGES);
+    return all;
+}
+/**
+ * Expand a list of raw posts into UnifiedMarket[], handling both
+ * single-question and group-of-questions posts.
+ */
+function expandPosts(posts, eventId) {
+    const markets = [];
+    for (const p of posts) {
+        markets.push(...(0, utils_1.expandPost)(p, eventId));
+    }
+    return markets;
+}
+/**
+ * Fetch a single post by numeric ID and expand it.
+ * A group post will return multiple markets (one per sub-question).
+ */
+async function fetchMarketById(id, callApi) {
+    const numericId = parseInt(id, 10);
+    if (isNaN(numericId))
+        return [];
+    const data = await callApi("GetPost", { postId: numericId });
+    if (!data || !data.id)
+        return [];
+    return (0, utils_1.expandPost)(data);
+}
+/**
+ * Search posts by keyword -- the Metaculus /api/posts/ has no server-side
+ * `search` param, so we fetch a batch of recent open posts and filter
+ * client-side by title/description match.
+ */
+async function searchMarkets(query, params, callApi) {
+    const limit = params?.limit ?? 200;
+    const statuses = toApiStatuses(params?.status);
+    const apiParams = {
+        order_by: "-forecasts_count",
+        with_cp: true,
+    };
+    if (statuses)
+        apiParams.statuses = statuses;
+    // Fetch enough posts to give the client-side filter something to work with
+    const posts = await fetchPostPages(callApi, apiParams, Math.max(limit * 5, 500));
+    const lower = query.toLowerCase();
+    const markets = [];
+    for (const p of posts) {
+        const title = (p.title ?? "").toLowerCase();
+        const desc = (p.question?.description ?? "").toLowerCase();
+        if (title.includes(lower) || desc.includes(lower)) {
+            markets.push(...(0, utils_1.expandPost)(p));
+        }
+        if (markets.length >= limit)
+            break;
+    }
+    return markets.slice(0, limit);
+}
+async function fetchMarketsDefault(params, callApi) {
+    const limit = params?.limit ?? 100;
+    const offset = params?.offset ?? 0;
+    const now = Date.now();
+    const statuses = toApiStatuses(params?.status ?? "active");
+    const useCache = (!params?.status || params.status === "active") && !params?.sort;
+    let posts;
+    if (useCache && cachedPosts && now - lastCacheTime < CACHE_TTL) {
+        posts = cachedPosts;
+    }
+    else {
+        const apiParams = {
+            with_cp: true,
+        };
+        if (statuses)
+            apiParams.statuses = statuses;
+        // Map sort to the new order_by enum values
+        if (params?.sort === "newest") {
+            apiParams.order_by = "-published_at";
+        }
+        else {
+            apiParams.order_by = "-forecasts_count";
+        }
+        const fetchLimit = params?.sort === "volume" || params?.sort === "liquidity"
+            ? 2000
+            : limit + offset;
+        posts = await fetchPostPages(callApi, apiParams, fetchLimit);
+        if (useCache && posts.length >= 100) {
+            cachedPosts = posts;
+            lastCacheTime = now;
+        }
+    }
+    const markets = expandPosts(posts);
+    if (params?.sort === "liquidity") {
+        markets.sort((a, b) => b.liquidity - a.liquidity);
+    }
+    return markets.slice(offset, offset + limit);
+}
+async function fetchMarkets(params, callApi) {
+    try {
+        // Direct lookup by numeric post/question ID
+        if (params?.marketId) {
+            return await fetchMarketById(params.marketId, callApi);
+        }
+        // outcomeId pattern: "<questionId>-YES" / "<questionId>-NO" / "<questionId>-<idx>"
+        if (params?.outcomeId) {
+            const id = params.outcomeId.split("-")[0];
+            return await fetchMarketById(id, callApi);
+        }
+        // slug: try as numeric ID first (Metaculus slugs are typically words,
+        // but callers may pass the numeric post ID as a slug)
+        if (params?.slug) {
+            const byId = await fetchMarketById(params.slug, callApi);
+            if (byId.length > 0)
+                return byId;
+            // Fall back to slug-string match against post.slug / post.url_title
+            const posts = await fetchPostPages(callApi, { with_cp: true, order_by: "-forecasts_count" }, 500);
+            const lower = params.slug.toLowerCase();
+            for (const p of posts) {
+                if ((p.slug ?? "").toLowerCase() === lower ||
+                    (p.url_title ?? "").toLowerCase() === lower) {
+                    return (0, utils_1.expandPost)(p);
+                }
+            }
+            return [];
+        }
+        // eventId is a tournament slug -- filter posts by that tournament
+        if (params?.eventId) {
+            const apiParams = {
+                tournaments: [params.eventId],
+                with_cp: true,
+                order_by: "-forecasts_count",
+            };
+            const posts = await fetchPostPages(callApi, apiParams, params?.limit ?? 1000);
+            const markets = expandPosts(posts);
+            return markets.slice(0, params?.limit ?? markets.length);
+        }
+        // Keyword search -- client-side filter (no server-side search param)
+        if (params?.query) {
+            return await searchMarkets(params.query, params, callApi);
+        }
+        // Default: recent active posts ordered by forecast count
+        return await fetchMarketsDefault(params, callApi);
+    }
+    catch (error) {
+        throw errors_1.metaculusErrorMapper.mapError(error);
+    }
+}

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

@@ -0,0 +1,105 @@
+import { PredictionMarketExchange, MarketFetchParams, EventFetchParams, ExchangeCredentials } from "../../BaseExchange";
+import { UnifiedMarket, UnifiedEvent, CreateOrderParams, Order } from "../../types";
+/**
+ * Metaculus exchange integration.
+ *
+ * Metaculus is a reputation-based forecasting platform. Unlike CLOB exchanges
+ * (Polymarket, Kalshi), there are no financial stakes -- users submit
+ * probability forecasts and earn reputation points scored on accuracy.
+ *
+ * ## Supported operations
+ *
+ * - **fetchMarkets / fetchEvents**: Browse questions, community predictions,
+ *   and tournament structures. Group-of-questions posts are automatically
+ *   expanded into individual sub-question markets.
+ *
+ * - **createOrder**: Submit a probability forecast on a question.
+ *   Maps `price` (0-1 exclusive) to `probability_yes`. The `side`, `type`,
+ *   and `amount` params are ignored since Metaculus forecasts are not
+ *   buy/sell orders. See {@link createOrder} for details.
+ *
+ * - **cancelOrder**: Withdraw a forecast from a question. Pass the Metaculus
+ *   question ID as the orderId.
+ *
+ * ## Authentication
+ *
+ * Pass `{ apiToken: "..." }` from your Metaculus account settings.
+ * All API operations require a token -- Metaculus no longer allows
+ * unauthenticated access to any endpoint.
+ *
+ * ## Question types
+ *
+ * | Type | fetchMarkets | createOrder |
+ * |------|-------------|-------------|
+ * | Binary | Yes (YES/NO outcomes) | Yes (`price` = probability_yes) |
+ * | Multiple-choice | Yes (one outcome per option) | Yes (redistributes other categories) |
+ * | Group-of-questions | Yes (expanded to sub-question markets) | Yes (per sub-question) |
+ * | Continuous/numeric/date | Yes (read-only HIGHER/LOWER) | No (requires 201-point CDF) |
+ */
+export declare class MetaculusExchange extends PredictionMarketExchange {
+    readonly has: {
+        fetchMarkets: true;
+        fetchEvents: true;
+        createOrder: true;
+        cancelOrder: true;
+        fetchOHLCV: false;
+        fetchOrderBook: false;
+        fetchTrades: false;
+        fetchOrder: false;
+        fetchOpenOrders: false;
+        fetchPositions: false;
+        fetchBalance: false;
+        watchAddress: false;
+        unwatchAddress: false;
+        watchOrderBook: false;
+        watchTrades: false;
+        fetchMyTrades: false;
+        fetchClosedOrders: false;
+        fetchAllOrders: false;
+        buildOrder: false;
+        submitOrder: false;
+    };
+    private readonly apiToken?;
+    constructor(credentials?: ExchangeCredentials);
+    get name(): string;
+    protected mapImplicitApiError(error: any): any;
+    /**
+     * Sign requests with an API token when one is provided.
+     * Metaculus uses token-based auth: `Authorization: Token <token>`.
+     */
+    protected sign(_method: string, _path: string, _params: Record<string, any>): Record<string, string>;
+    /**
+     * Get auth headers, throwing if no token is configured.
+     * Used by trading methods that require authentication.
+     */
+    private getAuthHeaders;
+    protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    /**
+     * Submit a probability forecast on a Metaculus question.
+     *
+     * Maps from the unified `createOrder` interface:
+     * - `price` -> the probability to forecast (0-1 exclusive)
+     * - `outcomeId` -> encodes the question ID and type
+     * - `side`, `type`, `amount` -> ignored (Metaculus forecasts are not orders)
+     *
+     * For binary questions, sets `probability_yes` directly.
+     * For multiple-choice, redistributes other categories proportionally.
+     * Continuous questions are not supported (throws InvalidOrder).
+     *
+     * @throws {AuthenticationError} If no API token is configured.
+     * @throws {InvalidOrder} If the question type is continuous or price is invalid.
+     */
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    /**
+     * Withdraw a forecast from a Metaculus question.
+     *
+     * The `orderId` should be the Metaculus question ID (numeric).
+     * If you used createOrder, extract the question ID from the
+     * outcomeId (the part before the hyphen).
+     *
+     * @throws {AuthenticationError} If no API token is configured.
+     * @throws {ValidationError} If orderId is not a valid question ID.
+     */
+    cancelOrder(orderId: string): Promise<Order>;
+}

package/dist/exchanges/metaculus/index.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetaculusExchange = void 0;
+const BaseExchange_1 = require("../../BaseExchange");
+const errors_1 = require("../../errors");
+const openapi_1 = require("../../utils/openapi");
+const api_1 = require("./api");
+const errors_2 = require("./errors");
+const utils_1 = require("./utils");
+const fetchMarkets_1 = require("./fetchMarkets");
+const fetchEvents_1 = require("./fetchEvents");
+const createOrder_1 = require("./createOrder");
+const cancelOrder_1 = require("./cancelOrder");
+/**
+ * Metaculus exchange integration.
+ *
+ * Metaculus is a reputation-based forecasting platform. Unlike CLOB exchanges
+ * (Polymarket, Kalshi), there are no financial stakes -- users submit
+ * probability forecasts and earn reputation points scored on accuracy.
+ *
+ * ## Supported operations
+ *
+ * - **fetchMarkets / fetchEvents**: Browse questions, community predictions,
+ *   and tournament structures. Group-of-questions posts are automatically
+ *   expanded into individual sub-question markets.
+ *
+ * - **createOrder**: Submit a probability forecast on a question.
+ *   Maps `price` (0-1 exclusive) to `probability_yes`. The `side`, `type`,
+ *   and `amount` params are ignored since Metaculus forecasts are not
+ *   buy/sell orders. See {@link createOrder} for details.
+ *
+ * - **cancelOrder**: Withdraw a forecast from a question. Pass the Metaculus
+ *   question ID as the orderId.
+ *
+ * ## Authentication
+ *
+ * Pass `{ apiToken: "..." }` from your Metaculus account settings.
+ * All API operations require a token -- Metaculus no longer allows
+ * unauthenticated access to any endpoint.
+ *
+ * ## Question types
+ *
+ * | Type | fetchMarkets | createOrder |
+ * |------|-------------|-------------|
+ * | Binary | Yes (YES/NO outcomes) | Yes (`price` = probability_yes) |
+ * | Multiple-choice | Yes (one outcome per option) | Yes (redistributes other categories) |
+ * | Group-of-questions | Yes (expanded to sub-question markets) | Yes (per sub-question) |
+ * | Continuous/numeric/date | Yes (read-only HIGHER/LOWER) | No (requires 201-point CDF) |
+ */
+class MetaculusExchange extends BaseExchange_1.PredictionMarketExchange {
+    has = {
+        fetchMarkets: true,
+        fetchEvents: true,
+        createOrder: true,
+        cancelOrder: true,
+        // Metaculus is a forecasting platform -- no order book, no trading history
+        fetchOHLCV: false,
+        fetchOrderBook: false,
+        fetchTrades: false,
+        fetchOrder: false,
+        fetchOpenOrders: false,
+        fetchPositions: false,
+        fetchBalance: false,
+        watchAddress: false,
+        unwatchAddress: false,
+        watchOrderBook: false,
+        watchTrades: false,
+        fetchMyTrades: false,
+        fetchClosedOrders: false,
+        fetchAllOrders: false,
+        buildOrder: false,
+        submitOrder: false,
+    };
+    apiToken;
+    constructor(credentials) {
+        super(credentials);
+        this.apiToken = credentials?.apiToken;
+        // Rate-limit conservatively; authenticated users get higher Metaculus quotas
+        this.rateLimit = 500;
+        const descriptor = (0, openapi_1.parseOpenApiSpec)(api_1.metaculusApiSpec, utils_1.BASE_URL);
+        this.defineImplicitApi(descriptor);
+    }
+    get name() {
+        return "Metaculus";
+    }
+    mapImplicitApiError(error) {
+        throw errors_2.metaculusErrorMapper.mapError(error);
+    }
+    /**
+     * Sign requests with an API token when one is provided.
+     * Metaculus uses token-based auth: `Authorization: Token <token>`.
+     */
+    sign(_method, _path, _params) {
+        if (this.apiToken) {
+            return { Authorization: `Token ${this.apiToken}` };
+        }
+        return {};
+    }
+    /**
+     * Get auth headers, throwing if no token is configured.
+     * Used by trading methods that require authentication.
+     */
+    getAuthHeaders() {
+        if (!this.apiToken) {
+            throw new errors_1.AuthenticationError('Metaculus API token required for this operation. '
+                + 'Pass { apiToken: "..." } when constructing MetaculusExchange.', "Metaculus");
+        }
+        return { Authorization: `Token ${this.apiToken}` };
+    }
+    // -------------------------------------------------------------------------
+    // Market Data
+    // -------------------------------------------------------------------------
+    async fetchMarketsImpl(params) {
+        return (0, fetchMarkets_1.fetchMarkets)(params, this.callApi.bind(this));
+    }
+    async fetchEventsImpl(params) {
+        return (0, fetchEvents_1.fetchEvents)(params, this.callApi.bind(this));
+    }
+    // -------------------------------------------------------------------------
+    // Trading (Forecasting)
+    // -------------------------------------------------------------------------
+    /**
+     * Submit a probability forecast on a Metaculus question.
+     *
+     * Maps from the unified `createOrder` interface:
+     * - `price` -> the probability to forecast (0-1 exclusive)
+     * - `outcomeId` -> encodes the question ID and type
+     * - `side`, `type`, `amount` -> ignored (Metaculus forecasts are not orders)
+     *
+     * For binary questions, sets `probability_yes` directly.
+     * For multiple-choice, redistributes other categories proportionally.
+     * Continuous questions are not supported (throws InvalidOrder).
+     *
+     * @throws {AuthenticationError} If no API token is configured.
+     * @throws {InvalidOrder} If the question type is continuous or price is invalid.
+     */
+    async createOrder(params) {
+        const ctx = {
+            http: this.http,
+            getAuthHeaders: () => this.getAuthHeaders(),
+            fetchOutcomes: async (marketId) => {
+                const markets = await this.fetchMarkets({ marketId });
+                return markets.length > 0 ? markets[0].outcomes : [];
+            },
+        };
+        return (0, createOrder_1.createOrder)(params, ctx);
+    }
+    /**
+     * Withdraw a forecast from a Metaculus question.
+     *
+     * The `orderId` should be the Metaculus question ID (numeric).
+     * If you used createOrder, extract the question ID from the
+     * outcomeId (the part before the hyphen).
+     *
+     * @throws {AuthenticationError} If no API token is configured.
+     * @throws {ValidationError} If orderId is not a valid question ID.
+     */
+    async cancelOrder(orderId) {
+        const ctx = {
+            http: this.http,
+            getAuthHeaders: () => this.getAuthHeaders(),
+        };
+        return (0, cancelOrder_1.cancelOrder)(orderId, ctx);
+    }
+}
+exports.MetaculusExchange = MetaculusExchange;