pmxt-core 2.21.2 → 2.22.0

package/dist/exchanges/opinion/api.js

@@ -0,0 +1,477 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opinionApiSpec = void 0;
+/**
+ * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/opinion/opinion-openapi.yaml
+ * Generated at: 2026-03-22T18:41:21.666Z
+ * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
+ */
+exports.opinionApiSpec = {
+    "openapi": "3.0.3",
+    "info": {
+        "title": "OPINION Prediction Market OpenAPI",
+        "version": "1.0.0"
+    },
+    "servers": [
+        {
+            "url": "https://openapi.opinion.trade/openapi"
+        }
+    ],
+    "security": [
+        {
+            "ApiKeyAuth": []
+        }
+    ],
+    "tags": [
+        {
+            "name": "Market"
+        },
+        {
+            "name": "Token"
+        },
+        {
+            "name": "QuoteToken"
+        },
+        {
+            "name": "Trade"
+        },
+        {
+            "name": "Position"
+        },
+        {
+            "name": "Order"
+        }
+    ],
+    "components": {
+        "securitySchemes": {
+            "ApiKeyAuth": {
+                "type": "apiKey",
+                "in": "header",
+                "name": "apikey",
+                "description": "API key for authentication"
+            }
+        }
+    },
+    "paths": {
+        "/market": {
+            "get": {
+                "tags": [
+                    "Market"
+                ],
+                "summary": "Get market list",
+                "operationId": "getMarketList",
+                "parameters": [
+                    {
+                        "name": "page",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "default": 1,
+                            "minimum": 1
+                        }
+                    },
+                    {
+                        "name": "limit",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "default": 10,
+                            "maximum": 20
+                        }
+                    },
+                    {
+                        "name": "status",
+                        "in": "query",
+                        "schema": {
+                            "type": "string",
+                            "enum": [
+                                "activated",
+                                "resolved"
+                            ]
+                        }
+                    },
+                    {
+                        "name": "marketType",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "default": 0,
+                            "enum": [
+                                0,
+                                1,
+                                2
+                            ]
+                        }
+                    },
+                    {
+                        "name": "sortBy",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "enum": [
+                                1,
+                                2,
+                                3,
+                                4,
+                                5,
+                                6,
+                                7,
+                                8
+                            ]
+                        }
+                    },
+                    {
+                        "name": "chainId",
+                        "in": "query",
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ]
+            }
+        },
+        "/market/{marketId}": {
+            "get": {
+                "tags": [
+                    "Market"
+                ],
+                "summary": "Get binary market detail",
+                "operationId": "getBinaryMarketDetail",
+                "parameters": [
+                    {
+                        "name": "marketId",
+                        "in": "path",
+                        "required": true,
+                        "schema": {
+                            "type": "integer",
+                            "format": "int64"
+                        }
+                    }
+                ]
+            }
+        },
+        "/market/categorical/{marketId}": {
+            "get": {
+                "tags": [
+                    "Market"
+                ],
+                "summary": "Get categorical market detail",
+                "operationId": "getCategoricalMarketDetail",
+                "parameters": [
+                    {
+                        "name": "marketId",
+                        "in": "path",
+                        "required": true,
+                        "schema": {
+                            "type": "integer",
+                            "format": "int64"
+                        }
+                    }
+                ]
+            }
+        },
+        "/token/latest-price": {
+            "get": {
+                "tags": [
+                    "Token"
+                ],
+                "summary": "Get latest price",
+                "operationId": "getLatestPrice",
+                "parameters": [
+                    {
+                        "name": "token_id",
+                        "in": "query",
+                        "required": true,
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ]
+            }
+        },
+        "/token/orderbook": {
+            "get": {
+                "tags": [
+                    "Token"
+                ],
+                "summary": "Get orderbook",
+                "operationId": "getOrderbook",
+                "parameters": [
+                    {
+                        "name": "token_id",
+                        "in": "query",
+                        "required": true,
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ]
+            }
+        },
+        "/token/price-history": {
+            "get": {
+                "tags": [
+                    "Token"
+                ],
+                "summary": "Get price history",
+                "operationId": "getPriceHistory",
+                "parameters": [
+                    {
+                        "name": "token_id",
+                        "in": "query",
+                        "required": true,
+                        "schema": {
+                            "type": "string"
+                        }
+                    },
+                    {
+                        "name": "interval",
+                        "in": "query",
+                        "schema": {
+                            "type": "string",
+                            "default": "1d",
+                            "enum": [
+                                "1m",
+                                "1h",
+                                "1d",
+                                "1w",
+                                "max"
+                            ]
+                        }
+                    },
+                    {
+                        "name": "start_at",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "format": "int64"
+                        }
+                    },
+                    {
+                        "name": "end_at",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "format": "int64"
+                        }
+                    }
+                ]
+            }
+        },
+        "/quoteToken": {
+            "get": {
+                "tags": [
+                    "QuoteToken"
+                ],
+                "summary": "Get quote token list",
+                "operationId": "getQuoteTokenList",
+                "parameters": [
+                    {
+                        "name": "page",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "default": 1
+                        }
+                    },
+                    {
+                        "name": "limit",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "default": 10
+                        }
+                    },
+                    {
+                        "name": "quoteTokenName",
+                        "in": "query",
+                        "schema": {
+                            "type": "string"
+                        }
+                    },
+                    {
+                        "name": "chainId",
+                        "in": "query",
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ]
+            }
+        },
+        "/trade/user/{walletAddress}": {
+            "get": {
+                "tags": [
+                    "Trade"
+                ],
+                "summary": "Get user trades",
+                "operationId": "getUserTrades",
+                "parameters": [
+                    {
+                        "name": "walletAddress",
+                        "in": "path",
+                        "required": true,
+                        "schema": {
+                            "type": "string"
+                        }
+                    },
+                    {
+                        "name": "page",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "default": 1,
+                            "minimum": 1
+                        }
+                    },
+                    {
+                        "name": "limit",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "default": 10,
+                            "maximum": 20
+                        }
+                    },
+                    {
+                        "name": "marketId",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "format": "int64"
+                        }
+                    },
+                    {
+                        "name": "chainId",
+                        "in": "query",
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ]
+            }
+        },
+        "/positions/user/{walletAddress}": {
+            "get": {
+                "tags": [
+                    "Position"
+                ],
+                "summary": "Get user positions",
+                "operationId": "getUserPositions",
+                "parameters": [
+                    {
+                        "name": "walletAddress",
+                        "in": "path",
+                        "required": true,
+                        "schema": {
+                            "type": "string"
+                        }
+                    },
+                    {
+                        "name": "page",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "default": 1,
+                            "minimum": 1
+                        }
+                    },
+                    {
+                        "name": "limit",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "default": 10,
+                            "maximum": 20
+                        }
+                    },
+                    {
+                        "name": "marketId",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "format": "int64"
+                        }
+                    },
+                    {
+                        "name": "chainId",
+                        "in": "query",
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ]
+            }
+        },
+        "/order": {
+            "get": {
+                "tags": [
+                    "Order"
+                ],
+                "summary": "Get orders",
+                "operationId": "getOrderList",
+                "parameters": [
+                    {
+                        "name": "page",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "default": 1,
+                            "minimum": 1
+                        }
+                    },
+                    {
+                        "name": "limit",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "default": 10,
+                            "maximum": 20
+                        }
+                    },
+                    {
+                        "name": "marketId",
+                        "in": "query",
+                        "schema": {
+                            "type": "integer",
+                            "format": "int64"
+                        }
+                    },
+                    {
+                        "name": "chainId",
+                        "in": "query",
+                        "schema": {
+                            "type": "string"
+                        }
+                    },
+                    {
+                        "name": "status",
+                        "in": "query",
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ]
+            }
+        },
+        "/order/{orderId}": {
+            "get": {
+                "tags": [
+                    "Order"
+                ],
+                "summary": "Get order detail",
+                "operationId": "getOrderDetail",
+                "parameters": [
+                    {
+                        "name": "orderId",
+                        "in": "path",
+                        "required": true,
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                ]
+            }
+        }
+    }
+};

package/dist/exchanges/opinion/auth.d.ts

@@ -0,0 +1,15 @@
+import { ExchangeCredentials } from '../../BaseExchange';
+export declare class OpinionAuth {
+    private readonly apiKey;
+    private readonly privateKey?;
+    private readonly rpcUrl;
+    private readonly multiSigAddress?;
+    private clobClient?;
+    private tradingEnabled;
+    constructor(credentials: ExchangeCredentials);
+    getHeaders(): Record<string, string>;
+    getWsUrl(): string;
+    hasTradeCredentials(): boolean;
+    getClobClient(): Promise<any>;
+    ensureTradingEnabled(): Promise<void>;
+}

package/dist/exchanges/opinion/auth.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpinionAuth = void 0;
+const config_1 = require("./config");
+let sdkPromise;
+function loadSdk() {
+    if (!sdkPromise) {
+        sdkPromise = Promise.resolve().then(() => __importStar(require('@opinion-labs/opinion-clob-sdk')));
+    }
+    return sdkPromise;
+}
+class OpinionAuth {
+    apiKey;
+    privateKey;
+    rpcUrl;
+    multiSigAddress;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    clobClient;
+    tradingEnabled = false;
+    constructor(credentials) {
+        if (!credentials.apiKey) {
+            throw new Error('Opinion Trade requires an apiKey for authentication');
+        }
+        this.apiKey = credentials.apiKey;
+        this.privateKey = credentials.privateKey;
+        this.rpcUrl = config_1.OPINION_DEFAULT_RPC_URL;
+        this.multiSigAddress = credentials.funderAddress;
+    }
+    getHeaders() {
+        return {
+            'apikey': this.apiKey,
+            'Content-Type': 'application/json',
+        };
+    }
+    getWsUrl() {
+        return `wss://ws.opinion.trade?apikey=${encodeURIComponent(this.apiKey)}`;
+    }
+    hasTradeCredentials() {
+        return !!this.privateKey;
+    }
+    async getClobClient() {
+        if (this.clobClient) {
+            return this.clobClient;
+        }
+        if (!this.privateKey) {
+            throw new Error('Trading requires a privateKey. ' +
+                'Initialize OpinionExchange with credentials including privateKey.');
+        }
+        if (!this.multiSigAddress) {
+            throw new Error('Trading requires a funderAddress (multiSigAddress). ' +
+                'Initialize OpinionExchange with credentials including funderAddress.');
+        }
+        const sdk = await loadSdk();
+        const config = {
+            host: sdk.DEFAULT_API_HOST,
+            apiKey: this.apiKey,
+            chainId: config_1.OPINION_CHAIN_ID,
+            rpcUrl: this.rpcUrl,
+            privateKey: this.privateKey,
+            multiSigAddress: this.multiSigAddress,
+        };
+        this.clobClient = new sdk.Client(config);
+        return this.clobClient;
+    }
+    async ensureTradingEnabled() {
+        if (this.tradingEnabled) {
+            return;
+        }
+        const client = await this.getClobClient();
+        await client.enableTrading();
+        this.tradingEnabled = true;
+    }
+}
+exports.OpinionAuth = OpinionAuth;

package/dist/exchanges/opinion/config.d.ts

@@ -0,0 +1,5 @@
+export declare const OPINION_API_URL = "https://openapi.opinion.trade/openapi";
+export declare const OPINION_WS_URL = "wss://ws.opinion.trade";
+export declare const OPINION_MAX_PAGE_SIZE = 20;
+export declare const OPINION_CHAIN_ID = 56;
+export declare const OPINION_DEFAULT_RPC_URL = "https://bsc-dataseed.binance.org";

package/dist/exchanges/opinion/config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPINION_DEFAULT_RPC_URL = exports.OPINION_CHAIN_ID = exports.OPINION_MAX_PAGE_SIZE = exports.OPINION_WS_URL = exports.OPINION_API_URL = void 0;
+exports.OPINION_API_URL = "https://openapi.opinion.trade/openapi";
+exports.OPINION_WS_URL = "wss://ws.opinion.trade";
+exports.OPINION_MAX_PAGE_SIZE = 20;
+// CLOB SDK chain constants
+exports.OPINION_CHAIN_ID = 56;
+exports.OPINION_DEFAULT_RPC_URL = 'https://bsc-dataseed.binance.org';

package/dist/exchanges/opinion/errors.d.ts

@@ -0,0 +1,8 @@
+import { ErrorMapper } from '../../utils/error-mapper';
+import { BadRequest } from '../../errors';
+export declare class OpinionErrorMapper extends ErrorMapper {
+    constructor();
+    protected extractErrorMessage(error: any): string;
+    protected mapBadRequestError(message: string, data: any): BadRequest;
+}
+export declare const opinionErrorMapper: OpinionErrorMapper;

package/dist/exchanges/opinion/errors.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opinionErrorMapper = exports.OpinionErrorMapper = void 0;
+const axios_1 = __importDefault(require("axios"));
+const error_mapper_1 = require("../../utils/error-mapper");
+const errors_1 = require("../../errors");
+class OpinionErrorMapper extends error_mapper_1.ErrorMapper {
+    constructor() {
+        super('Opinion');
+    }
+    extractErrorMessage(error) {
+        if (axios_1.default.isAxiosError(error) && error.response?.data) {
+            const data = error.response.data;
+            // OpenAPI format uses "msg", SDK format uses "errmsg"
+            const message = data.msg || data.errmsg;
+            if (message) {
+                return `[${error.response.status}] ${message}`;
+            }
+        }
+        return super.extractErrorMessage(error);
+    }
+    mapBadRequestError(message, data) {
+        if (data && typeof data === 'object') {
+            // OpenAPI format: { code: number, msg: string }
+            // SDK format: { errno: number, errmsg: string }
+            const errorCode = data.code ?? data.errno;
+            const errorMsg = data.msg || data.errmsg || message;
+            if (errorCode !== undefined && errorCode !== 0) {
+                return new errors_1.BadRequest(`Opinion API error (code ${errorCode}): ${errorMsg}`, this.exchangeName);
+            }
+        }
+        return super.mapBadRequestError(message, data);
+    }
+}
+exports.OpinionErrorMapper = OpinionErrorMapper;
+exports.opinionErrorMapper = new OpinionErrorMapper();