pmxt-core 2.22.2 → 2.24.0

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

@@ -0,0 +1,40 @@
+import { UnifiedMarket } from "../../types";
+/**
+ * Base URL passed to parseOpenApiSpec to override the spec's servers[0].url.
+ * The generated api.ts already has "https://www.metaculus.com/api" as its server URL,
+ * so this constant must match exactly -- do NOT add a trailing slash or path suffix.
+ * Paths in the spec (/posts/, /posts/{postId}/) are appended directly by BaseExchange.
+ */
+export declare const BASE_URL = "https://www.metaculus.com/api";
+/**
+ * Map a Metaculus post `status` to pmxt unified status.
+ *
+ * Metaculus post statuses: "open", "closed", "resolved", "upcoming"
+ */
+export declare function mapStatus(status: string): "active" | "closed";
+/**
+ * Convert a raw Metaculus Post (v3 /api/posts/ response item) into a
+ * `UnifiedMarket`.
+ *
+ * Returns `null` for group-of-questions posts -- callers should use
+ * {@link expandPost} instead, which handles both single and group posts.
+ *
+ * @param post      Raw post object from the Metaculus API.
+ * @param eventId   Optional parent event ID (tournament slug) to override
+ *                  the value derived from post.projects.tournament.
+ */
+export declare function mapMarketToUnified(post: any, eventId?: string): UnifiedMarket | null;
+/**
+ * Convert a raw Metaculus post into one or more `UnifiedMarket` objects.
+ *
+ * Handles all post types:
+ * - Single-question posts (binary, multiple-choice, continuous) -> 1 market
+ * - Group-of-questions posts -> N markets (one per sub-question)
+ *
+ * Use this instead of calling `mapMarketToUnified` directly when processing
+ * feed results, since a single API post can yield multiple tradeable markets.
+ *
+ * @param post     Raw post object from the Metaculus API.
+ * @param eventId  Optional parent event ID (tournament slug).
+ */
+export declare function expandPost(post: any, eventId?: string): UnifiedMarket[];

package/dist/exchanges/metaculus/utils.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_URL = void 0;
+exports.mapStatus = mapStatus;
+exports.mapMarketToUnified = mapMarketToUnified;
+exports.expandPost = expandPost;
+const market_utils_1 = require("../../utils/market-utils");
+/**
+ * Base URL passed to parseOpenApiSpec to override the spec's servers[0].url.
+ * The generated api.ts already has "https://www.metaculus.com/api" as its server URL,
+ * so this constant must match exactly -- do NOT add a trailing slash or path suffix.
+ * Paths in the spec (/posts/, /posts/{postId}/) are appended directly by BaseExchange.
+ */
+exports.BASE_URL = "https://www.metaculus.com/api";
+/**
+ * Map a Metaculus post `status` to pmxt unified status.
+ *
+ * Metaculus post statuses: "open", "closed", "resolved", "upcoming"
+ */
+function mapStatus(status) {
+    switch ((status ?? "").toLowerCase()) {
+        case "open":
+        case "upcoming":
+            return "active";
+        default:
+            return "closed";
+    }
+}
+/**
+ * Extract the community prediction probability from a question object.
+ *
+ * For all question types the recency-weighted aggregation exposes a `centers`
+ * array where `centers[0]` is the median / central estimate, already normalised
+ * to [0, 1] by the API.
+ *
+ * Accepts either a Post (reads from post.question) or a bare Question object.
+ *
+ * @returns A number in [0, 1], or 0.5 if no prediction is available.
+ */
+function extractCommunityProbability(questionOrPost) {
+    // Support both post.question and bare question objects
+    const question = questionOrPost?.question ?? questionOrPost;
+    const latest = question?.aggregations?.recency_weighted?.latest;
+    if (!latest)
+        return 0.5;
+    const centers = latest.centers;
+    if (Array.isArray(centers) && centers.length > 0 && typeof centers[0] === "number") {
+        return Math.max(0, Math.min(1, centers[0]));
+    }
+    // Fallback: some binary posts expose forecast_values[0] as the Yes probability
+    const fv = latest.forecast_values;
+    if (Array.isArray(fv) && fv.length > 0 && typeof fv[0] === "number") {
+        return Math.max(0, Math.min(1, fv[0]));
+    }
+    return 0.5;
+}
+/**
+ * Build the tag list from a Post's project associations.
+ * Combines taxonomy tags and categories so consumers can filter by either.
+ */
+function buildTags(post) {
+    const tags = [];
+    const projects = post?.projects ?? {};
+    // Explicit tags
+    const tagList = projects.tag ?? [];
+    for (const t of tagList) {
+        const label = typeof t === "string" ? t : t?.name;
+        if (label && !tags.includes(label))
+            tags.push(label);
+    }
+    // Categories (useful for broad filtering)
+    const catList = projects.category ?? [];
+    for (const c of catList) {
+        const label = typeof c === "string" ? c : c?.name;
+        if (label && !tags.includes(label))
+            tags.push(label);
+    }
+    // Question type as a tag for easy filtering
+    const qType = post?.question?.type;
+    if (qType && !tags.includes(qType))
+        tags.push(qType);
+    return tags;
+}
+/**
+ * Build outcomes for a Metaculus question.
+ *
+ * OutcomeId format uses the **question ID** (not the post ID) so that
+ * `createOrder` can extract the correct ID for the forecast API.
+ *
+ * - Binary:          `<questionId>-YES` / `<questionId>-NO`
+ * - Multiple-choice: `<questionId>-<categoryIndex>`
+ * - Continuous:      `<questionId>-HIGHER` / `<questionId>-LOWER` (read-only, not tradeable)
+ *
+ * Raw aggregation data is exposed in each outcome's `metadata` so consumers
+ * can use it directly.
+ *
+ * @param question  The Metaculus Question object (not the Post wrapper).
+ * @param postId    The parent post ID, used as the marketId on each outcome.
+ */
+function buildOutcomes(question, postId, medianProb) {
+    const questionId = String(question?.id ?? postId);
+    const type = (question?.type || "binary").toLowerCase();
+    const latest = question?.aggregations?.recency_weighted?.latest ?? null;
+    const sharedMeta = {
+        question_type: type,
+        question_id: Number(questionId),
+        aggregations: latest,
+        resolution: question?.resolution ?? null,
+        scaling: question?.scaling ?? null,
+        possibilities: question?.possibilities ?? null,
+    };
+    // Multiple choice: one outcome per option, each independently forecastable
+    if (type === "multiple_choice") {
+        const options = question?.options ?? [];
+        if (options.length > 0) {
+            const histogram = latest?.histogram ?? undefined;
+            return options.map((opt, idx) => {
+                const label = typeof opt === "string"
+                    ? opt
+                    : opt?.label ?? opt?.value ?? `Option ${idx + 1}`;
+                const price = Array.isArray(histogram) && typeof histogram[idx] === "number"
+                    ? Math.max(0, Math.min(1, histogram[idx]))
+                    : 1 / Math.max(options.length, 1);
+                return {
+                    outcomeId: `${questionId}-${idx}`,
+                    marketId: postId,
+                    label,
+                    price,
+                    priceChange24h: 0,
+                    metadata: { ...sharedMeta, choice_index: idx },
+                };
+            });
+        }
+    }
+    // Binary: Yes/No outcomes
+    if (type === "binary") {
+        return [
+            {
+                outcomeId: `${questionId}-YES`,
+                marketId: postId,
+                label: "Yes",
+                price: medianProb,
+                priceChange24h: 0,
+                metadata: sharedMeta,
+            },
+            {
+                outcomeId: `${questionId}-NO`,
+                marketId: postId,
+                label: "No",
+                price: Math.max(0, Math.min(1, 1 - medianProb)),
+                priceChange24h: 0,
+                metadata: sharedMeta,
+            },
+        ];
+    }
+    // Continuous / numeric / date -- not tradeable via createOrder.
+    // Displayed as synthetic Higher/Lower for read-only price indication.
+    return [
+        {
+            outcomeId: `${questionId}-HIGHER`,
+            marketId: postId,
+            label: "Higher",
+            price: medianProb,
+            priceChange24h: 0,
+            metadata: sharedMeta,
+        },
+        {
+            outcomeId: `${questionId}-LOWER`,
+            marketId: postId,
+            label: "Lower",
+            price: Math.max(0, Math.min(1, 1 - medianProb)),
+            priceChange24h: 0,
+            metadata: sharedMeta,
+        },
+    ];
+}
+/**
+ * Convert a raw Metaculus Post (v3 /api/posts/ response item) into a
+ * `UnifiedMarket`.
+ *
+ * Returns `null` for group-of-questions posts -- callers should use
+ * {@link expandPost} instead, which handles both single and group posts.
+ *
+ * @param post      Raw post object from the Metaculus API.
+ * @param eventId   Optional parent event ID (tournament slug) to override
+ *                  the value derived from post.projects.tournament.
+ */
+function mapMarketToUnified(post, eventId) {
+    if (!post || !post.id)
+        return null;
+    // Group-of-questions posts have no top-level question -- they must be
+    // expanded into individual sub-question markets via expandPost().
+    if (post.group_of_questions && !post.question)
+        return null;
+    const postId = String(post.id);
+    const question = post.question ?? {};
+    const medianProb = extractCommunityProbability(post);
+    const outcomes = buildOutcomes(question, postId, medianProb);
+    // Resolution date -- prefer scheduled_resolve_time, fall back to close time
+    const resolveDateStr = post.scheduled_resolve_time ??
+        question.scheduled_resolve_time ??
+        post.scheduled_close_time ??
+        post.actual_close_time;
+    const resolutionDate = resolveDateStr
+        ? new Date(resolveDateStr)
+        : new Date("2099-01-01T00:00:00Z");
+    const tags = buildTags(post);
+    // Primary category label
+    const categoryList = post?.projects?.category ?? [];
+    const category = categoryList.length > 0
+        ? typeof categoryList[0] === "string"
+            ? categoryList[0]
+            : categoryList[0]?.name
+        : undefined;
+    // Forecaster count -- proxy for liquidity (no monetary values on Metaculus)
+    const forecastCount = Number(post.nr_forecasters ?? question.nr_forecasters ?? 0);
+    // Derive eventId from first tournament slug if not explicitly provided
+    const tournamentList = post?.projects?.tournament ?? [];
+    const derivedEventId = tournamentList.length > 0
+        ? typeof tournamentList[0] === "string"
+            ? tournamentList[0]
+            : tournamentList[0]?.slug
+        : undefined;
+    const resolvedEventId = eventId ?? derivedEventId;
+    const um = {
+        marketId: postId,
+        eventId: resolvedEventId,
+        title: post.title ?? question.title ?? "",
+        description: question.description ??
+            question.resolution_criteria ??
+            "",
+        slug: post.slug ?? post.url_title ?? undefined,
+        outcomes,
+        resolutionDate,
+        volume24h: 0, // Metaculus has no monetary volume
+        volume: 0,
+        liquidity: forecastCount, // re-purposed as forecaster count
+        openInterest: forecastCount,
+        url: `https://www.metaculus.com/questions/${postId}/`,
+        image: post.projects?.default_project?.header_image ?? undefined,
+        category,
+        tags,
+    };
+    (0, market_utils_1.addBinaryOutcomes)(um);
+    return um;
+}
+/**
+ * Expand a group-of-questions post into individual sub-question markets.
+ *
+ * Each sub-question becomes its own `UnifiedMarket` with:
+ * - `marketId` = sub-question's post_id (for API lookups via GetPost)
+ * - outcomeIds based on the sub-question's question.id (for forecast API)
+ * - `eventId` = parent post ID (the group acts as a container)
+ * - `metadata.groupPostId` on each outcome for traceability
+ *
+ * @param post     A group-of-questions post (post.group_of_questions.questions[]).
+ * @param eventId  Optional override for the eventId field.
+ */
+function mapGroupPostToMarkets(post, eventId) {
+    const group = post.group_of_questions;
+    if (!group?.questions?.length)
+        return [];
+    const parentPostId = String(post.id);
+    const groupEventId = eventId ?? parentPostId;
+    const markets = [];
+    for (const subQuestion of group.questions) {
+        // Build a synthetic post that mapMarketToUnified can process.
+        // Use the sub-question's post_id as the post id if available,
+        // otherwise fall back to the sub-question's own id.
+        const syntheticPost = {
+            id: subQuestion.post_id ?? subQuestion.id,
+            title: subQuestion.title ?? subQuestion.label ?? post.title,
+            question: subQuestion,
+            // Inherit metadata from the parent post
+            slug: post.slug,
+            url_title: post.url_title,
+            projects: post.projects,
+            nr_forecasters: subQuestion.nr_forecasters ?? post.nr_forecasters,
+            scheduled_resolve_time: subQuestion.scheduled_resolve_time ?? post.scheduled_resolve_time,
+            scheduled_close_time: subQuestion.scheduled_close_time ?? post.scheduled_close_time,
+            actual_close_time: subQuestion.actual_close_time ?? post.actual_close_time,
+            status: post.status,
+        };
+        const market = mapMarketToUnified(syntheticPost, groupEventId);
+        if (market) {
+            // Tag each outcome with the parent group post ID for traceability
+            for (const outcome of market.outcomes) {
+                if (outcome.metadata) {
+                    outcome.metadata.groupPostId = Number(parentPostId);
+                }
+            }
+            markets.push(market);
+        }
+    }
+    return markets;
+}
+/**
+ * Convert a raw Metaculus post into one or more `UnifiedMarket` objects.
+ *
+ * Handles all post types:
+ * - Single-question posts (binary, multiple-choice, continuous) -> 1 market
+ * - Group-of-questions posts -> N markets (one per sub-question)
+ *
+ * Use this instead of calling `mapMarketToUnified` directly when processing
+ * feed results, since a single API post can yield multiple tradeable markets.
+ *
+ * @param post     Raw post object from the Metaculus API.
+ * @param eventId  Optional parent event ID (tournament slug).
+ */
+function expandPost(post, eventId) {
+    if (!post || !post.id)
+        return [];
+    // Group posts: expand each sub-question into its own market
+    if (post.group_of_questions && !post.question) {
+        return mapGroupPostToMarkets(post, eventId);
+    }
+    // Single-question post
+    const market = mapMarketToUnified(post, eventId);
+    return market ? [market] : [];
+}

package/dist/exchanges/myriad/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-04-02T13:41:49.135Z
+ * Generated at: 2026-04-06T14:01:00.996Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const myriadApiSpec: {

package/dist/exchanges/myriad/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.myriadApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-04-02T13:41:49.135Z
+ * Generated at: 2026-04-06T14:01:00.996Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.myriadApiSpec = {

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/opinion/opinion-openapi.yaml
- * Generated at: 2026-04-02T13:41:49.140Z
+ * Generated at: 2026-04-06T14:01:01.002Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const opinionApiSpec: {

package/dist/exchanges/opinion/api.js

@@ -3,7 +3,7 @@ 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-04-02T13:41:49.140Z
+ * Generated at: 2026-04-06T14:01:01.002Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.opinionApiSpec = {

package/dist/exchanges/polymarket/api-clob.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-04-02T13:41:49.090Z
+ * Generated at: 2026-04-06T14:01:00.943Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketClobSpec: {

package/dist/exchanges/polymarket/api-clob.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketClobSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-04-02T13:41:49.090Z
+ * Generated at: 2026-04-06T14:01:00.943Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketClobSpec = {

package/dist/exchanges/polymarket/api-data.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-04-02T13:41:49.104Z
+ * Generated at: 2026-04-06T14:01:00.959Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketDataSpec: {

package/dist/exchanges/polymarket/api-data.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketDataSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-04-02T13:41:49.104Z
+ * Generated at: 2026-04-06T14:01:00.959Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketDataSpec = {

package/dist/exchanges/polymarket/api-gamma.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-04-02T13:41:49.101Z
+ * Generated at: 2026-04-06T14:01:00.956Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketGammaSpec: {

package/dist/exchanges/polymarket/api-gamma.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketGammaSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-04-02T13:41:49.101Z
+ * Generated at: 2026-04-06T14:01:00.956Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketGammaSpec = {

package/dist/exchanges/polymarket/auth.js

@@ -158,22 +158,56 @@ class PolymarketAuth {
         if (this.clobClient) {
             return this.clobClient;
         }
-        // 1. Determine proxy and signature type early
+        // 1. Determine proxy and signature type early.
+        //
+        // Important: if signatureType is not provided we MUST run discovery
+        // even when funderAddress is provided. Previously this branch was
+        // skipped whenever funderAddress was set, which silently defaulted
+        // signatureType to 0 (EOA). For wallets whose funds live on a Gnosis
+        // Safe (the modern Polymarket onboarding default) the CLOB then
+        // reports balance "0" instead of the real value, with no error.
+        const sigTypeProvided = this.credentials.signatureType !== undefined && this.credentials.signatureType !== null;
         let proxyAddress = this.credentials.funderAddress || undefined;
-        let signatureType = this.mapSignatureType(this.credentials.signatureType);
-        if (!proxyAddress) {
-            const discovered = await this.discoverProxy();
-            proxyAddress = discovered.proxyAddress;
-            if (this.credentials.signatureType === undefined || this.credentials.signatureType === null) {
-                signatureType = discovered.signatureType;
+        let signatureType = sigTypeProvided
+            ? this.mapSignatureType(this.credentials.signatureType)
+            : undefined;
+        // Run discovery if either piece is missing. Note: discoverProxy()
+        // returns a synthetic { proxyAddress: signerEOA, signatureType: 0 }
+        // fallback when its HTTP call fails — that fallback should NOT be
+        // used to populate signatureType when funderAddress is already set,
+        // because it would silently assign EOA semantics to a Gnosis Safe.
+        let discoverySucceeded = false;
+        if (!proxyAddress || signatureType === undefined) {
+            try {
+                const discovered = await this.discoverProxy();
+                discoverySucceeded =
+                    !!this.discoveredProxyAddress &&
+                        this.discoveredSignatureType !== undefined;
+                if (!proxyAddress) {
+                    proxyAddress = discovered.proxyAddress;
+                }
+                if (signatureType === undefined && discoverySucceeded) {
+                    signatureType = discovered.signatureType;
+                }
+            }
+            catch {
+                // Discovery failure is handled by the heuristic below.
             }
         }
         // Get API credentials (L1 auth)
-        // Pass signature type if we know it (some accounts need it for derivation?)
         const apiCreds = await this.getApiCredentials();
         // 3. Defaults
         const signerAddress = this.signer.address;
         const finalProxyAddress = (proxyAddress || signerAddress);
+        // If signature type is still unknown, infer from address relationship:
+        // when the funder differs from the signer EOA, the funder must be a
+        // proxy/safe — default to Gnosis Safe (2), which is what Polymarket
+        // has created for new accounts since 2023. Users on the legacy
+        // Polymarket Proxy (1) need to set signatureType explicitly.
+        if (signatureType === undefined) {
+            signatureType =
+                finalProxyAddress.toLowerCase() !== signerAddress.toLowerCase() ? 2 : 0;
+        }
         const finalSignatureType = signatureType;
         // Create L2-authenticated client
         // console.log(`[PolymarketAuth] Initializing ClobClient | Signer: ${signerAddress} | Funder: ${finalProxyAddress} | SigType: ${finalSignatureType}`);

package/dist/exchanges/polymarket/index.js

@@ -357,45 +357,82 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             const client = await auth.getClobClient();
             // Polymarket relies strictly on USDC (Polygon)
             const USDC_DECIMALS = 6;
-            // Try fetching from CLOB client first
+            // Try fetching from CLOB client first.
+            //
+            // Note on the bundled @polymarket/clob-client error model: its HTTP
+            // wrapper swallows axios errors and RETURNS an envelope shaped like
+            // { error, status } instead of throwing. We must therefore validate
+            // the shape of the result before using it, otherwise downstream
+            // parseFloat() yields NaN and the on-chain fallback never triggers.
             let total = 0;
+            let clobBalanceAvailable = false;
             try {
                 const balRes = await client.getBalanceAllowance({
                     asset_type: clob_client_1.AssetType.COLLATERAL,
                 });
-                const rawBalance = parseFloat(balRes.balance);
-                total = rawBalance / Math.pow(10, USDC_DECIMALS);
+                if (balRes && typeof balRes.balance === 'string') {
+                    const rawBalance = parseFloat(balRes.balance);
+                    if (Number.isFinite(rawBalance)) {
+                        total = rawBalance / Math.pow(10, USDC_DECIMALS);
+                        clobBalanceAvailable = true;
+                    }
+                }
+                // If balRes was an error envelope, fall through to on-chain.
             }
             catch (clobError) {
-                // If CLOB fails or returns 0 (suspiciously), we can try on-chain
-                // but let's assume we proceed to on-chain check if total is 0
-                // or just do on-chain check always for robustness if possible.
-                // For now, let's trust CLOB but add On-Chain fallback if CLOB returns 0.
+                // Network/transport error — fall through to on-chain.
             }
             // On-Chain Fallback/Check (Robustness)
-            // If CLOB reported 0, let's verify on-chain because sometimes CLOB is behind or confused about proxies
-            if (total === 0) {
+            // Trigger when CLOB couldn't tell us, or reported a true zero (CLOB
+            // can lag or be confused about proxies for newly funded wallets).
+            if (!clobBalanceAvailable || total === 0) {
                 try {
                     const targetAddress = await auth.getEffectiveFunderAddress();
                     const balances = await this.getAddressOnChainBalance(targetAddress);
-                    total = balances[0]?.total ?? 0;
+                    const onChain = balances[0]?.total ?? 0;
+                    if (onChain > 0) {
+                        total = onChain;
+                    }
                 }
                 catch {
                 }
             }
-            // 2. Fetch open orders to calculate locked funds
-            // We only care about BUY orders for USDC balance locking
-            const openOrders = await client.getOpenOrders({});
+            // 2. Fetch open orders to calculate locked funds.
+            // We only care about BUY orders for USDC balance locking.
+            //
+            // The bundled @polymarket/clob-client throws "response.data is not
+            // iterable" from inside its getOpenOrders pagination loop whenever
+            // the CLOB API returns an HTTP error envelope (the library spreads
+            // response.data unconditionally). This is the root cause of #72:
+            // a wallet that has not completed Polymarket onboarding triggers an
+            // upstream auth/setup rejection that surfaces here as an opaque
+            // TypeError. Catch it and translate to a clear AuthenticationError.
             let locked = 0;
-            if (openOrders && Array.isArray(openOrders)) {
-                for (const order of openOrders) {
-                    if (order.side === clob_client_1.Side.BUY) {
-                        const remainingSize = parseFloat(order.original_size) - parseFloat(order.size_matched);
-                        const price = parseFloat(order.price);
-                        locked += remainingSize * price;
+            try {
+                const openOrders = await client.getOpenOrders({});
+                if (Array.isArray(openOrders)) {
+                    for (const order of openOrders) {
+                        if (order.side === clob_client_1.Side.BUY) {
+                            const remainingSize = parseFloat(order.original_size) - parseFloat(order.size_matched);
+                            const price = parseFloat(order.price);
+                            locked += remainingSize * price;
+                        }
                     }
                 }
             }
+            catch (ordersError) {
+                const msg = String(ordersError?.message ?? ordersError);
+                if (msg.includes('is not iterable')) {
+                    throw new errors_1.AuthenticationError('Polymarket CLOB rejected the request to list open orders. ' +
+                        'This usually means the wallet has not completed Polymarket ' +
+                        'onboarding (no proxy/safe exists for this signer), or that ' +
+                        'funderAddress / signatureType need to be passed explicitly. ' +
+                        'Visit https://polymarket.com to complete account setup, or ' +
+                        'pass funderAddress and signatureType in credentials.', 'Polymarket');
+                }
+                // Unexpected failure — surface through the standard mapper.
+                throw ordersError;
+            }
             return [{
                     currency: 'USDC',
                     total: total,

package/dist/exchanges/probable/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-04-02T13:41:49.127Z
+ * Generated at: 2026-04-06T14:01:00.988Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const probableApiSpec: {

package/dist/exchanges/probable/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.probableApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-04-02T13:41:49.127Z
+ * Generated at: 2026-04-06T14:01:00.988Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.probableApiSpec = {