pmxt-core 2.19.6 → 2.20.0

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-03-06T09:16:55.599Z
+ * Generated at: 2026-03-14T16:22:11.429Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.probableApiSpec = {

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

@@ -14,6 +14,8 @@ export declare class ProbableExchange extends PredictionMarketExchange {
         fetchOpenOrders: true;
         fetchPositions: true;
         fetchBalance: true;
+        watchAddress: false;
+        unwatchAddress: false;
         watchOrderBook: true;
         watchTrades: false;
         fetchMyTrades: true;

package/dist/exchanges/probable/index.js

@@ -45,6 +45,8 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchOpenOrders: true,
         fetchPositions: true,
         fetchBalance: true,
+        watchAddress: false,
+        unwatchAddress: false,
         watchOrderBook: true,
         watchTrades: false,
         fetchMyTrades: true,

package/dist/subscriber/base.d.ts

@@ -0,0 +1,82 @@
+import { Balance, Position, Trade } from '../types';
+export type SubscriptionOption = 'trades' | 'positions' | 'balances';
+export interface SubscribedAddressSnapshot {
+    /** The wallet address being watched */
+    address: string;
+    /** Recent trades for this address
+     * (if the above SubscriptionOption 'trades' option was requested)
+     */
+    trades?: Trade[];
+    /** Current open positions for this address
+     * (if the above SubscriptionOption 'positions' option was requested)
+     */
+    positions?: Position[];
+    /** Current balances for this address
+     * (if the above SubscriptionOption 'balances' option was requested)
+     */
+    balances?: Balance[];
+    /** Unix timestamp (ms) of this snapshot */
+    timestamp: number;
+}
+/**
+ * Partial snapshot constructed from a subscribed event's on-chain data.
+ * Only the types that could be fully derived from the event are present.
+ */
+export type SubscribedResult = Partial<Omit<SubscribedAddressSnapshot, 'address' | 'timestamp'>>;
+type SubscriptionBuilder = (address: string) => any;
+/**
+ * Tries to build a partial SubscribedAddressSnapshot from raw watched event data.
+ * The implementation varies depending on the implementation of SubscriptionBuilder.
+ *
+ * Data is the raw payload, the subscribed address, the requested types,
+ * and the last known snapshot.
+ *
+ * Return an `SubscribedResult` object containing only the types you can fully
+ * populate from the event
+ */
+export type SubscribedActivityBuilder = (data: unknown, address: string, types: SubscriptionOption[], lastSnapshot?: SubscribedAddressSnapshot | null) => SubscribedResult | null;
+export interface SubscriberConfig {
+    /**
+     * HTTP endpoint used for polling queries.
+     */
+    baseUrl?: string;
+    /**
+     * Milliseconds between query polls once websocket subscription is not available.
+     * @default 3000
+     */
+    pollMs?: number;
+    /**
+     * WebSocket endpoint
+     */
+    wsEndpoint?: string;
+    /** API key for authenticating with the external subscription provider.
+     * Required when the provider restricts access to authenticated clients.
+     */
+    apiKey?: string;
+    /**
+     * Builds the customized per-address subscription query
+     */
+    buildSubscription?: SubscriptionBuilder;
+    /**
+     * Milliseconds between reconnect attempts after a WebSocket disconnect.
+     * @default 5000
+     */
+    reconnectDelayMs?: number;
+}
+/**
+ * Optional subscription that notifies the watcher of on-chain activity for a
+ * watched address.
+ */
+export interface BaseSubscriber {
+    /**
+     * Start receiving notifications for `address`.
+     * Resolves once the subscription is active, or throws if the watcher
+     * cannot be set up (the watcher will fall back to polling-only on error).
+     */
+    subscribe(address: string, types: SubscriptionOption[], onEvent: (data: unknown) => void): Promise<void>;
+    /** Stop receiving notifications for `address`. */
+    unsubscribe(address: string): void;
+    /** Tear down all subscriptions and close underlying connections. */
+    close(): void;
+}
+export {};

package/dist/subscriber/base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/subscriber/external/goldsky.d.ts

@@ -0,0 +1,96 @@
+import { BaseSubscriber, SubscribedActivityBuilder, SubscriberConfig, SubscriptionOption } from '../base';
+/**
+ * A single GraphQL query to send to a Goldsky subgraph url.
+ */
+export interface GoldSkyGraphQlQuery {
+    url: string;
+    query: string;
+    variables?: Record<string, any>;
+}
+/**
+ * Executes a single GraphQL query and returns the `data` object, or `null` on
+ * error. Provided by `GoldSkySubscriber` to each builder.
+ */
+export type GoldSkyFetch = (query: GoldSkyGraphQlQuery) => Promise<Record<string, unknown> | null>;
+/**
+ * Async builder that orchestrates one or more GraphQL queries and returns the
+ * merged result.
+ *
+ * - Receives a `fetch` helper so it can chain requests sequentially or run
+ *   them in parallel as needed.
+ * - Return `null` when the requested `types` don't match what this builder
+ *   covers (polling will be skipped for that address).
+ * - Return an empty object `{}` when types match but the current query yields
+ *   no results (however, polling continues and waiting for future changes).
+ */
+export type GoldSkySubscriptionBuilder = (address: string, types: SubscriptionOption[], fetch: GoldSkyFetch, baseUrl?: string) => Promise<Record<string, unknown> | null>;
+export interface GoldSkyConfig extends Omit<SubscriberConfig, 'buildSubscription'> {
+    buildSubscription: GoldSkySubscriptionBuilder;
+}
+/**
+ * Polymarket combined subscription.
+ *
+ * - `'trades'`: two parallel indexed queries (maker + taker), merged and sorted
+ *   by timestamp in the builder. The combined `or` filter causes a full-table
+ *   scan and times out.
+ * - `'positions'`: PNL and positions metadata run sequentially.
+ *   Both use `orderBy: id` to avoid timeouts on unindexed sort columns; the
+ *   builder re-sorts by `amount desc` after fetching.
+ *
+ * Pair with `buildPolymarketActivity`.
+ */
+export declare const POLYMARKET_DEFAULT_SUBSCRIPTION: GoldSkySubscriptionBuilder;
+/**
+ * Limitless: watches ERC-20 `Transfer` events on the USDC contract.
+ * Only active when `'balances'` is in the requested types.
+ *
+ * Pair with `buildLimitlessBalanceActivity`.
+ */
+export declare const LIMITLESS_DEFAULT_SUBSCRIPTION: GoldSkySubscriptionBuilder;
+/**
+ * Derives `Trade[]` from Polymarket CTF Exchange `OrderFilled` event data.
+ */
+export declare const buildPolymarketTradesActivity: SubscribedActivityBuilder;
+/**
+ * Derives `Position[]` from the joined PNL + positions-metadata event data.
+ *
+ * `userPositions` (PNL) and `userBalances` (positions) are guaranteed
+ * to share the same tokenIds since step 2 is filtered by step 1's results.
+ *
+ * `currentPrice` and `unrealizedPnL` are left at 0 (not available on-chain).
+ */
+/**
+ * Derives `Position[]` from joined PNL (`userPositions`) + metadata (`userBalances`).
+ * `currentPrice` and `unrealizedPnL` are left at 0 (not available on-chain).
+ */
+export declare const buildPolymarketPositionsActivity: SubscribedActivityBuilder;
+/**
+ * Combined activity builder for Polymarket. Pair with `POLYMARKET_DEFAULT_SUBSCRIPTION`.
+ */
+export declare const buildPolymarketActivity: SubscribedActivityBuilder;
+/**
+ * Derives a USDC balance delta from a Limitless ERC-20 transfer event.
+ * Returns `null` to fall back to full RPC fetch when baseline is missing.
+ */
+export declare const buildLimitlessBalanceActivity: SubscribedActivityBuilder;
+/**
+ * Polls goldsky subgraph endpoints on a configurable interval.
+ *
+ * Passes a `GoldSkyFetch` helper to each builder invocation, allowing builders
+ * to chain requests sequentially or run them in parallel as needed.
+ */
+export declare class GoldSkySubscriber implements BaseSubscriber {
+    readonly config: GoldSkyConfig;
+    private readonly pollMs;
+    private abortControllers;
+    private pollTimers;
+    private callbacks;
+    private addressQueryTypes;
+    private closed;
+    constructor(config: GoldSkyConfig);
+    subscribe(address: string, types: SubscriptionOption[], onEvent: (data: unknown) => void): Promise<void>;
+    unsubscribe(address: string): void;
+    close(): void;
+    private query;
+    private runQuery;
+}

package/dist/subscriber/external/goldsky.js

@@ -0,0 +1,412 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoldSkySubscriber = exports.buildLimitlessBalanceActivity = exports.buildPolymarketActivity = exports.buildPolymarketPositionsActivity = exports.buildPolymarketTradesActivity = exports.LIMITLESS_DEFAULT_SUBSCRIPTION = exports.POLYMARKET_DEFAULT_SUBSCRIPTION = void 0;
+// ----------------------------------------------------------------------------
+// Polymarket endpoints
+// ----------------------------------------------------------------------------
+// Reference: https://docs.polymarket.com/market-data/subgraph
+const POLYMARKET_TRADES_ENDPOINT = 'https://api.goldsky.com/api/public/project_cl6mb8i9h0003e201j6li0diw/subgraphs/orderbook-subgraph/prod/gn';
+const POLYMARKET_POSITIONS_ENDPOINT = 'https://api.goldsky.com/api/public/project_cl6mb8i9h0003e201j6li0diw/subgraphs/positions-subgraph/0.0.7/gn';
+const POLYMARKET_PNL_ENDPOINT = 'https://api.goldsky.com/api/public/project_cl6mb8i9h0003e201j6li0diw/subgraphs/pnl-subgraph/0.0.14/gn';
+// NOTE: orderBy must use `id` (primary key) on pnl-subgraph and positions-subgraph.
+// Sorting by any unindexed column (e.g. amount, balance) causes a statement timeout.
+// ----------------------------------------------------------------------------
+// Internal query builders
+// ----------------------------------------------------------------------------
+const TRADES_FIELDS = `
+                id
+                timestamp
+                maker
+                taker
+                makerAssetId
+                takerAssetId
+                makerAmountFilled
+                takerAmountFilled`;
+const BUILD_POLYMARKET_TRADES_AS_MAKER_QUERY = (address, url) => ({
+    url: url ?? POLYMARKET_TRADES_ENDPOINT,
+    query: `
+        query GetPolymarketTradesMaker($address: Bytes!) {
+            orderFilledEvents(
+                where: { maker: $address }
+                first: 5
+                orderBy: timestamp
+                orderDirection: desc
+            ) {${TRADES_FIELDS}
+            }
+        }
+    `,
+    variables: { address: address.toLowerCase() },
+});
+const BUILD_POLYMARKET_TRADES_AS_TAKER_QUERY = (address, url) => ({
+    url: url ?? POLYMARKET_TRADES_ENDPOINT,
+    query: `
+        query GetPolymarketTradesTaker($address: Bytes!) {
+            orderFilledEvents(
+                where: { taker: $address }
+                first: 20
+                orderBy: timestamp
+                orderDirection: desc
+            ) {${TRADES_FIELDS}
+            }
+        }
+    `,
+    variables: { address: address.toLowerCase() },
+});
+const BUILD_POLYMARKET_PNL_QUERY = (address, url) => ({
+    url: url ?? POLYMARKET_PNL_ENDPOINT,
+    query: `
+        query GetPolymarketPnl($address: String!) {
+            userPositions(
+                where: { user: $address, amount_gt: "0" }
+                first: 1000
+                orderBy: id
+                orderDirection: asc
+            ) {
+                tokenId
+                amount
+                avgPrice
+                realizedPnl
+            }
+        }
+    `,
+    variables: { address: address.toLowerCase() },
+});
+const BUILD_POLYMARKET_POSITIONS_QUERY = (_address, tokenIds, url) => ({
+    url: url ?? POLYMARKET_POSITIONS_ENDPOINT,
+    query: `
+        query GetPolymarketPositions($tokenIds: [ID!]!) {
+            tokenIdConditions(
+                where: { id_in: $tokenIds }
+                first: 1000
+                orderBy: id
+                orderDirection: asc
+            ) {
+                id
+                outcomeIndex
+                condition {
+                    id
+                }
+            }
+        }
+    `,
+    variables: { tokenIds },
+});
+// ----------------------------------------------------------------------------
+// Exported subscription builders
+// ----------------------------------------------------------------------------
+/**
+ * Polymarket combined subscription.
+ *
+ * - `'trades'`: two parallel indexed queries (maker + taker), merged and sorted
+ *   by timestamp in the builder. The combined `or` filter causes a full-table
+ *   scan and times out.
+ * - `'positions'`: PNL and positions metadata run sequentially.
+ *   Both use `orderBy: id` to avoid timeouts on unindexed sort columns; the
+ *   builder re-sorts by `amount desc` after fetching.
+ *
+ * Pair with `buildPolymarketActivity`.
+ */
+const POLYMARKET_DEFAULT_SUBSCRIPTION = async (address, types, goldSkyFetch, baseUrl) => {
+    if (!types.includes('trades') && !types.includes('positions'))
+        return null;
+    // Trades (maker + taker) and PNL all run in parallel.
+    const [makerData, takerData, pnlData] = await Promise.all([
+        types.includes('trades') ? goldSkyFetch(BUILD_POLYMARKET_TRADES_AS_MAKER_QUERY(address, baseUrl)) : null,
+        types.includes('trades') ? goldSkyFetch(BUILD_POLYMARKET_TRADES_AS_TAKER_QUERY(address, baseUrl)) : null,
+        types.includes('positions') ? goldSkyFetch(BUILD_POLYMARKET_PNL_QUERY(address, baseUrl)) : null,
+    ]);
+    const result = {};
+    if (types.includes('trades')) {
+        const seen = new Set();
+        const trades = [];
+        for (const row of [...(makerData?.orderFilledEvents ?? []), ...(takerData?.orderFilledEvents ?? [])]) {
+            if (!seen.has(row.id)) {
+                seen.add(row.id);
+                trades.push(row);
+            }
+        }
+        trades.sort((a, b) => Number(b.timestamp) - Number(a.timestamp));
+        result.orderFilledEvents = trades;
+    }
+    if (pnlData) {
+        const sorted = (pnlData.userPositions ?? [])
+            .sort((a, b) => parseFloat(b.amount ?? '0') - parseFloat(a.amount ?? '0'));
+        result.userPositions = sorted;
+        const tokenIds = sorted.map((p) => String(p.tokenId));
+        if (tokenIds.length > 0) {
+            const metaData = await goldSkyFetch(BUILD_POLYMARKET_POSITIONS_QUERY(address, tokenIds, baseUrl));
+            if (metaData)
+                Object.assign(result, metaData);
+        }
+    }
+    return result;
+};
+exports.POLYMARKET_DEFAULT_SUBSCRIPTION = POLYMARKET_DEFAULT_SUBSCRIPTION;
+/**
+ * Limitless: watches ERC-20 `Transfer` events on the USDC contract.
+ * Only active when `'balances'` is in the requested types.
+ *
+ * Pair with `buildLimitlessBalanceActivity`.
+ */
+const LIMITLESS_DEFAULT_SUBSCRIPTION = async (address, types, fetch, baseUrl) => {
+    if (!types.includes('balances') || !baseUrl)
+        return null;
+    return fetch({
+        url: baseUrl,
+        query: /* GraphQL */ `
+            query WatchLimitlessAddress($address: Bytes!) {
+                transfers(
+                    where: { or: [{ from: $address }, { to: $address }] }
+                    first: 1
+                    orderBy: blockTimestamp
+                    orderDirection: desc
+                ) {
+                    id
+                    blockTimestamp
+                    from
+                    to
+                    value
+                }
+            }
+        `,
+        variables: { address: address.toLowerCase() },
+    });
+};
+exports.LIMITLESS_DEFAULT_SUBSCRIPTION = LIMITLESS_DEFAULT_SUBSCRIPTION;
+// ----------------------------------------------------------------------------
+// Activity builders
+// ----------------------------------------------------------------------------
+/**
+ * Derives `Trade[]` from Polymarket CTF Exchange `OrderFilled` event data.
+ */
+const buildPolymarketTradesActivity = (data, address, types) => {
+    if (!types.includes('trades'))
+        return null;
+    const filled = data?.orderFilledEvents;
+    if (!Array.isArray(filled) || filled.length === 0)
+        return null;
+    const addr = address.toLowerCase();
+    const trades = filled.map((f) => {
+        const isMaker = f.maker?.toLowerCase() === addr;
+        const currAssetId = BigInt(isMaker ? f.makerAssetId : f.takerAssetId);
+        const isBuying = currAssetId === 0n;
+        let shareAmount;
+        let usdcAmount;
+        if (isMaker) {
+            if (isBuying) {
+                usdcAmount = parseFloat(f.makerAmountFilled) / 1e6;
+                shareAmount = parseFloat(f.takerAmountFilled) / 1e6;
+            }
+            else {
+                shareAmount = parseFloat(f.makerAmountFilled) / 1e6;
+                usdcAmount = parseFloat(f.takerAmountFilled) / 1e6;
+            }
+        }
+        else {
+            if (isBuying) {
+                usdcAmount = parseFloat(f.takerAmountFilled) / 1e6;
+                shareAmount = parseFloat(f.makerAmountFilled) / 1e6;
+            }
+            else {
+                shareAmount = parseFloat(f.takerAmountFilled) / 1e6;
+                usdcAmount = parseFloat(f.makerAmountFilled) / 1e6;
+            }
+        }
+        return {
+            id: f.id,
+            timestamp: Number(f.timestamp) * 1000,
+            price: shareAmount > 0 ? usdcAmount / shareAmount : 0,
+            amount: shareAmount,
+            side: isBuying ? 'buy' : 'sell',
+            outcomeId: isMaker ? f.makerAssetId : f.takerAssetId,
+        };
+    });
+    return { trades };
+};
+exports.buildPolymarketTradesActivity = buildPolymarketTradesActivity;
+/**
+ * Derives `Position[]` from the joined PNL + positions-metadata event data.
+ *
+ * `userPositions` (PNL) and `userBalances` (positions) are guaranteed
+ * to share the same tokenIds since step 2 is filtered by step 1's results.
+ *
+ * `currentPrice` and `unrealizedPnL` are left at 0 (not available on-chain).
+ */
+/**
+ * Derives `Position[]` from joined PNL (`userPositions`) + metadata (`userBalances`).
+ * `currentPrice` and `unrealizedPnL` are left at 0 (not available on-chain).
+ */
+const buildPolymarketPositionsActivity = (data, _address, types) => {
+    if (!types.includes('positions'))
+        return null;
+    const pnlRows = data?.userPositions ?? [];
+    if (pnlRows.length === 0)
+        return null;
+    const conditionRows = data?.tokenIdConditions ?? [];
+    const metaByToken = new Map();
+    for (const c of conditionRows) {
+        metaByToken.set(c.id ?? '', {
+            marketId: c.condition?.id ?? '',
+            outcomeIndex: Number(c.outcomeIndex ?? 0),
+        });
+    }
+    const positions = pnlRows.map((p) => {
+        const tokenId = String(p.tokenId ?? '');
+        const meta = metaByToken.get(tokenId);
+        return {
+            marketId: meta?.marketId ?? '',
+            outcomeId: tokenId,
+            outcomeLabel: (meta?.outcomeIndex ?? 0) === 1 ? 'Yes' : 'No',
+            size: parseFloat(p.amount ?? '0') / 1e6,
+            entryPrice: parseFloat(p.avgPrice ?? '0') / 1e6,
+            currentPrice: 0, // Not available on-chain
+            unrealizedPnL: 0, // Not available on-chain
+            realizedPnL: parseFloat(p.realizedPnl ?? '0') / 1e6,
+        };
+    });
+    return { positions };
+};
+exports.buildPolymarketPositionsActivity = buildPolymarketPositionsActivity;
+/**
+ * Combined activity builder for Polymarket. Pair with `POLYMARKET_DEFAULT_SUBSCRIPTION`.
+ */
+const buildPolymarketActivity = (data, address, types, lastSnapshot) => {
+    const result = {};
+    if (types.includes('trades')) {
+        const r = (0, exports.buildPolymarketTradesActivity)(data, address, types, lastSnapshot);
+        if (r?.trades)
+            result.trades = r.trades;
+    }
+    if (types.includes('positions')) {
+        const r = (0, exports.buildPolymarketPositionsActivity)(data, address, types, lastSnapshot);
+        if (r?.positions)
+            result.positions = r.positions;
+    }
+    return Object.keys(result).length > 0 ? result : null;
+};
+exports.buildPolymarketActivity = buildPolymarketActivity;
+/**
+ * Derives a USDC balance delta from a Limitless ERC-20 transfer event.
+ * Returns `null` to fall back to full RPC fetch when baseline is missing.
+ */
+const buildLimitlessBalanceActivity = (data, address, types, lastActivity) => {
+    if (!types.includes('balances'))
+        return null;
+    const transfers = data?.transfers;
+    if (!Array.isArray(transfers) || transfers.length === 0)
+        return null;
+    const prev = lastActivity?.balances?.find(b => b.currency === 'USDC');
+    if (!prev)
+        return null;
+    const t = transfers[0];
+    const addr = address.toLowerCase();
+    const isIncoming = t.to?.toLowerCase() === addr;
+    const delta = parseFloat(t.value) / 1e6;
+    const newTotal = Math.max(0, isIncoming ? prev.total + delta : prev.total - delta);
+    return {
+        balances: [{
+                currency: 'USDC',
+                total: newTotal,
+                available: Math.max(0, newTotal - prev.locked),
+                locked: prev.locked,
+            }],
+    };
+};
+exports.buildLimitlessBalanceActivity = buildLimitlessBalanceActivity;
+// ----------------------------------------------------------------------------
+// GoldSkySubscriber
+// ----------------------------------------------------------------------------
+/**
+ * Polls goldsky subgraph endpoints on a configurable interval.
+ *
+ * Passes a `GoldSkyFetch` helper to each builder invocation, allowing builders
+ * to chain requests sequentially or run them in parallel as needed.
+ */
+class GoldSkySubscriber {
+    config;
+    pollMs;
+    abortControllers = new Map();
+    pollTimers = new Map();
+    callbacks = new Map();
+    addressQueryTypes = new Map();
+    closed = false;
+    constructor(config) {
+        this.config = config;
+        this.pollMs = config.pollMs ?? 3000;
+    }
+    async subscribe(address, types, onEvent) {
+        if (this.closed)
+            return;
+        this.callbacks.set(address, onEvent);
+        this.addressQueryTypes.set(address, types);
+        const existing = this.pollTimers.get(address);
+        if (existing) {
+            clearInterval(existing);
+            this.pollTimers.delete(address);
+        }
+        const timer = setInterval(() => this.query(address), this.pollMs);
+        this.pollTimers.set(address, timer);
+    }
+    unsubscribe(address) {
+        const timer = this.pollTimers.get(address);
+        if (timer) {
+            clearInterval(timer);
+            this.pollTimers.delete(address);
+        }
+        this.abortControllers.get(address)?.abort();
+        this.abortControllers.delete(address);
+        this.callbacks.delete(address);
+        this.addressQueryTypes.delete(address);
+    }
+    close() {
+        this.closed = true;
+        for (const address of [...this.pollTimers.keys()]) {
+            this.unsubscribe(address);
+        }
+    }
+    async query(address) {
+        const callback = this.callbacks.get(address);
+        const types = this.addressQueryTypes.get(address);
+        if (!callback || !types)
+            return;
+        this.abortControllers.get(address)?.abort();
+        const controller = new AbortController();
+        this.abortControllers.set(address, controller);
+        const goldSkyFetch = (q) => this.runQuery(q, controller.signal);
+        const data = await this.config.buildSubscription(address, types, goldSkyFetch, this.config.baseUrl);
+        if (!data)
+            return;
+        callback(data);
+    }
+    async runQuery(q, signal) {
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.config.apiKey) {
+            headers['Authorization'] = `Bearer ${this.config.apiKey}`;
+        }
+        try {
+            const res = await fetch(q.url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ query: q.query, variables: q.variables ?? {} }),
+                signal,
+            });
+            if (!res.ok) {
+                console.warn(`[GoldSkySubscriber] HTTP ${res.status} from ${q.url}`);
+                return null;
+            }
+            const json = await res.json();
+            if (json?.errors) {
+                console.warn(`[GoldSkySubscriber] GraphQL errors from ${q.url}:`, JSON.stringify(json.errors));
+                return null;
+            }
+            return json?.data ?? null;
+        }
+        catch (err) {
+            if (err?.name !== 'AbortError') {
+                console.warn(`[GoldSkySubscriber] Fetch failed for ${q.url}:`, err);
+            }
+            return null;
+        }
+    }
+}
+exports.GoldSkySubscriber = GoldSkySubscriber;