@0xinsider/mcp 2.0.0 → 2.1.0

package/dist/sdk/schema.d.ts

@@ -128,6 +128,37 @@ export type Candle = {
     /** Close price in provider [0, 1] units (last observed point in the bucket). */
     c: number;
 };
+/** Model-wide readiness, read in the same database snapshot as category_records. Individual category rows retain their own status. */
+export type CategorySkillModelReadiness = {
+    status: "live" | "insufficient" | "stale" | "unknown" | "degraded";
+    model_version: string;
+    taxonomy_version: string;
+    observation_started_at: string;
+    as_of: string;
+    source_last_success_at: string | null;
+};
+/** Forward-only category evidence from observed Polymarket taker fills. Status is category eligibility, not a global letter grade or a guarantee of positive edge. Scores are probability differences. Unknown and degraded rows withhold scores. Coverage is partial; observation counts are not lifetime market counts. */
+export type CategorySkillV2 = {
+    status: "live" | "insufficient" | "stale" | "unknown" | "degraded";
+    model_version: string;
+    taxonomy_version: string | null;
+    platform: "polymarket";
+    scope: "observed_goldsky_primary_taker_fill";
+    source_coverage: "partial_whale_threshold_fills" | "graded_wallet_fills";
+    canonical_category: string;
+    as_of: string;
+    source_last_success_at: string | null;
+    observation_started_at: string;
+    latest_observation_at: string | null;
+    independent_event_count: number;
+    resolved_condition_count: number;
+    unresolved_observation_count: number;
+    edge_mean: number | null;
+    edge_sd: number | null;
+    edge_se: number | null;
+    edge_lower_95: number | null;
+    brier_event_avg: number | null;
+};
 export type ContentSearchResult = {
     /** Backend-owned stable editorial content identifier. */
     content_id: string;
@@ -191,6 +222,8 @@ export type CounterpartyParticipant = {
     resolution_source?: string | null;
     display_name?: string | null;
     grade?: string | null;
+    /** Latest nonfuture recorded wallet-wide trade time for the tracked trader supplying this participant's grade. Omitted when unavailable; not the receipt time or the owner EOA's activity. Trader context is read with the response and is not frozen by execution membership snapshots. */
+    last_traded_at?: string;
     /** 0xinsider profile path segment for this participant, present only when the execution wallet has a tracked trader: `@<username>` when that username resolves to the trader alone, otherwise the trader's lowercase wallet. Percent-encode the part after `@` and append to `https://0xinsider.com/profile/`. */
     profile_segment?: string | null;
     maker_fill_count: number;
@@ -363,12 +396,19 @@ export type ExportSourceRange = {
     latest_market_activity_at?: string | null;
 };
 export type ExportVolumeReconciliation = {
+    /** Verified full-history both-sides USD cash volume. Null without coverage; the local activity numerator may cover only a subset of history. */
     provider_lifetime_volume?: number | null;
     exported_activity_volume: number;
     exported_market_cost_basis: number;
     provider_activity_volume_gap?: number | null;
     activity_volume_coverage?: number | null;
 };
+/** Current category evidence, independent of the global grade. Pick of the Day stamps only the served display roster; frozen entry snapshots remain unchanged. */
+export type HolderCategoryEvidence = {
+    status: "live" | "insufficient" | "stale" | "unknown" | "degraded";
+    canonical_category?: string;
+    skill?: CategorySkillV2;
+};
 export type LargeExportPolicy = {
     mode: "v1_async_export";
     current_internal_route: string;
@@ -396,10 +436,35 @@ export type LargePosition = {
     id: string;
     /** Provider discriminator. Always polymarket. */
     platform: "polymarket";
-    /** Aggregate provider currentValue for this position leg in USD. */
+    /** Provider currentValue in USD for the outcome named by outcome_label / token_id, and for that outcome only. Null means the provider supplied no value for this leg, not a zero position. combined_value_usd carries the wallet's whole-market total. */
     total_size_usd?: number | null;
-    /** Provider per-position unrealized P&L (trader_markets.unrealized_pnl_num, from Polymarket cashPnl). */
+    /** Provider unrealized mark-to-market P&L (Polymarket cashPnl) for that same one outcome. Null means unavailable, not break-even. */
     position_unrealized_pnl?: number | null;
+    /** The wallet's currentValue across every outcome it holds in this market. Equals total_size_usd unless is_two_sided is true, and is the value the feed ranked this row by. */
+    combined_value_usd?: number | null;
+    /** The wallet's unrealized P&L across every outcome it holds in this market. Equals position_unrealized_pnl unless is_two_sided is true. */
+    combined_unrealized_pnl?: number | null;
+    /** Whether the wallet holds shares on both outcomes of this market. */
+    is_two_sided: boolean;
+    /** Every outcome the wallet holds, primary first. holdings[0] restates the top-level per-outcome fields; a further entry is a leg those fields do not describe. No amount here is a share-proportional slice of a both-sides total. */
+    holdings: ({
+        /** 0 = Yes, 1 = No. */
+        outcome_index: number;
+        /** The market's label for this outcome. */
+        outcome_label?: string | null;
+        /** Polymarket CLOB token id for this outcome; null for an unsynced market. */
+        token_id: string | null;
+        /** Shares held on this outcome. */
+        share_count: number;
+        /** Provider average entry price for this outcome. */
+        avg_entry_price?: number | null;
+        /** Provider mark price for this outcome. */
+        current_price?: number | null;
+        /** Provider currentValue for this outcome. Null means unavailable, not zero. */
+        value_usd?: number | null;
+        /** Provider unrealized P&L for this outcome. Null means unavailable, not break-even. */
+        unrealized_pnl?: number | null;
+    })[];
     /** Live share count for this position. */
     share_count: number;
     /** Volume-weighted entry price. */
@@ -412,7 +477,7 @@ export type LargePosition = {
     token_id?: string | null;
     /** Legs collapsed into this representative row for one (wallet, event, outcome side) group. 1 means standalone. */
     event_leg_count: number;
-    /** Aggregate provider currentValue across collapsed sibling legs; equals total_size_usd when event_leg_count = 1. */
+    /** Sum of the collapsed sibling legs' own holding values for this (wallet, event) group; equals total_size_usd when event_leg_count = 1, and null when any member's value is unknown. */
     event_total_value_usd?: number | null;
     first_seen_at: string;
     last_updated_at: string;
@@ -447,8 +512,9 @@ export type LeaderboardEntry = {
     score?: number | null;
     /** All-time P&L in USD (total_pnl), including unrealized open positions. Kept for back-compat; prefer realized_pnl for the banked figure. */
     pnl?: number | null;
-    /** All-time banked realized P&L in USD (total_pnl - open_pnl), excluding unrealized open positions. Matches the realized-P&L-dominant grade/board. */
+    /** Native realized P&L plus credited maker and taker rebates in USD, with fees already included. The exact numeric value is truncated toward zero to cents before JSON conversion. Wallets without a native snapshot retain their historical stored realized P&L. Omitted when the native snapshot has no net realized value. */
     realized_pnl?: number | null;
+    /** Full-history both-sides USD cash volume from a verified Polymarket user-volume observation. Omitted without coverage. */
     volume?: number | null;
     markets_traded?: number | null;
     win_rate?: number | null;
@@ -631,8 +697,26 @@ export type PickHolder = {
     shares: number;
     /** This wallet's win rate in the pick's canonical category bucket (the pick's `category` field, e.g. Basketball -- label the rate with it, never with the narrower `display_category` league): the share of the wallet's resolved markets in that category whose realized P&L closed positive, as a 0..1 fraction. Present only with `category_win_rate_status` = `measured`, on `display_holders` entries, and only when the wallet clears the resolved-market floor; recomputed at serve time from the current category read model, not frozen with the pick. Absent on `holders` entries, legacy rows, and payloads predating the field. */
     category_win_rate?: number | null;
+    /** The two counts `category_win_rate` is the ratio of, read from the same row: `wins / decided` equals the rate. Counts every resolved Polymarket market the wallet traded in the pick's canonical category, at any position size; the counts are rebuilt daily. Present only with `category_win_rate_status` = `measured`; absent otherwise and on payloads predating the field. */
+    category_win_record?: {
+        /** Resolved markets in the category that this wallet closed with a profit. */
+        wins: number;
+        /** Resolved markets in the category that this wallet closed with a profit or a loss. A market resolved at zero realized P&L is in neither count. */
+        decided: number;
+    };
     /** Why `category_win_rate` is present or absent on a `display_holders` entry: `measured` (rate present), `not_enough_data` (the wallet is below the resolved-market floor of 5 in the category), or `unavailable` (the annotation read failed; retry later). Absent entirely on `holders` entries, legacy rows, and payloads predating the field -- absence means the roster was never annotated, not a small sample. */
     category_win_rate_status?: "measured" | "not_enough_data" | "unavailable";
+    /** Days since this wallet's first trade. Stamped at serve time from the wallet's current trader record, never frozen with the pick. The five badge fields are present together, and only for a wallet that carries at least one badge; all absent means no badge, or a body cached before the fields shipped. */
+    wallet_age_days?: number | null;
+    /** True when the wallet's first trade was under 30 days ago. Stamped at serve time from the wallet's current trader record, never frozen with the pick. The five badge fields are present together, and only for a wallet that carries at least one badge; all absent means no badge, or a body cached before the fields shipped. */
+    is_new_wallet?: boolean;
+    /** Distinct markets this wallet has traded. Stamped at serve time from the wallet's current trader record, never frozen with the pick. The five badge fields are present together, and only for a wallet that carries at least one badge; all absent means no badge, or a body cached before the fields shipped. */
+    markets_traded?: number | null;
+    /** True when the wallet has traded 10,000 or more distinct markets, the breadth floor 0xinsider uses to mark automated wallets. It is a breadth rule, not proof of automation. Stamped at serve time from the wallet's current trader record, never frozen with the pick. The five badge fields are present together, and only for a wallet that carries at least one badge; all absent means no badge, or a body cached before the fields shipped. */
+    is_bot?: boolean;
+    /** The wallet's X handle from its Polymarket profile, normalized to 1-15 characters of [A-Za-z0-9_] with no `@`. Link it as `https://x.com/<handle>`. Stamped at serve time from the wallet's current trader record, never frozen with the pick. The five badge fields are present together, and only for a wallet that carries at least one badge; all absent means no badge, or a body cached before the fields shipped. */
+    x_username?: string | null;
+    category_evidence?: HolderCategoryEvidence;
 };
 export type PickOfTheDay = {
     /** Always 'full' for an authenticated Pro key. */
@@ -861,6 +945,25 @@ export type PickOfTheDayArchiveEntry = {
     /** Backend-formatted signed unit score, present exactly when unit_score is present. */
     unit_score_display?: string;
 };
+/** The frozen identity of the pick, exactly as the hash was taken over it. Served byte for byte as it was hashed -- keys sorted by UTF-8 byte value, no insignificant whitespace -- so a verifier concatenates and hashes with nothing to reconstruct. Property order below is the wire order. The outcome is deliberately NOT part of it: surviving a corrected outcome unchanged is the case the commitment exists for. Worked example: {"backed_price":"0.545000","condition_id":"0xabc","kickoff":"2026-09-20T23:05:00Z","pick_date":"2026-09-20","pick_outcome_index":1,"pick_outcome_label":"Lakers","pick_rank":1,"platform":"polymarket"} with the nonce 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f hashes to 44d18fa5e2aa3a2bf3c971dcc9317c8ccbdfd5480a4773b6d8ffd5fbeeea84dc. */
+export type PickOfTheDayCommitmentPayload = {
+    /** Frozen pre-game price of the backed side, 0..1, as the plain decimal text of the stored NUMERIC at full stored precision, trailing zeros included. A string, never a number: a float round-trip would change the bytes and break the hash. Deliberately not normalized -- 0.545000 stays "0.545000". */
+    backed_price: string;
+    /** Provider condition id of the backed market. */
+    condition_id: string;
+    /** Frozen provider kickoff, whole seconds, UTC, literal Z. Fixed precision, never a shortest-lossless rendering. */
+    kickoff: string;
+    /** ET product day (YYYY-MM-DD). */
+    pick_date: string;
+    /** Index of the backed outcome within the market. */
+    pick_outcome_index: 0 | 1;
+    /** Frozen display label of the backed outcome. */
+    pick_outcome_label: string;
+    /** 1-based daily slot. */
+    pick_rank: number;
+    /** Provider platform. */
+    platform: string;
+};
 export type PickOfTheDayHitRate = {
     /** Number of decided picks that won. */
     wins: number;
@@ -934,6 +1037,109 @@ export type PickOfTheDayHitRate = {
         hit_rate_pct: number;
     }[];
 };
+/** The commitment ledger: every published pick, ascending, in the state its commitment is actually in. The counts are derived from entries in the same pass that builds it. */
+export type PickOfTheDayLedger = {
+    /** One entry per published (pick_date, pick_rank), ascending by pick_date then pick_rank. */
+    entries: PickOfTheDayLedgerEntry[];
+    /** Number of entries, all states included. */
+    entry_count: number;
+    /** Entries committed to and not yet settled. */
+    sealed_count: number;
+    /** Entries committed to and verifiable now. */
+    opened_count: number;
+    /** Entries carrying no commitment, so provable by nothing: the honest size of the unprovable part of the record. It only stops growing; no pick is ever retro-sealed. */
+    uncommitted_count: number;
+};
+/** One ledger entry. Read `state` to know which shape you have; the three are disjoint. */
+export type PickOfTheDayLedgerEntry = PickOfTheDayLedgerSealedEntry | PickOfTheDayLedgerOpenedEntry | PickOfTheDayLedgerUncommittedEntry;
+/** A settled pick whose commitment is open: the nonce plus the exact payload the hash was taken over. Concatenate the payload bytes as received with the decoded nonce and sha256 them to reproduce commitment_hash. */
+export type PickOfTheDayLedgerOpenedEntry = {
+    state: "opened";
+    /** ET product day the pick belongs to (YYYY-MM-DD). */
+    pick_date: string;
+    /** 1-based daily slot within the product day. */
+    pick_rank: number;
+    /** sha256(canonical_json(payload) || nonce), lowercase hex, no 0x prefix. Publishable the moment the pick releases: without the nonce it is not invertible. */
+    commitment_hash: string;
+    /** The 32-byte nonce the hash was taken over, lowercase hex, no 0x prefix. Secret while the pick is live: a pick payload is low entropy, so a published nonce on a live pick would hand out the backed side. */
+    commitment_nonce: string;
+    /** The construction the hash was taken with, stated in the response so a verifier never has to guess the serialization. */
+    commitment_algo: "sha256(canonical_json(payload)||nonce)";
+    /** When the hash was frozen. Always strictly before kickoff: a pick that reaches kickoff unsealed stays unsealed forever, because a seal written after the game started would be a backdated proof. */
+    sealed_at: string;
+    /** When outcome was LAST written to a settled value, or null when that instant is unknown. It moves with a corrected market re-mapping an already-settled pick, while commitment_hash stays untouched -- which is how a mirror that keeps history sees a correction. */
+    resolved_at: string | null;
+    /** The frozen provider kickoff in the canonical payload form: whole seconds, UTC, literal Z. This exact string reappears inside payload.kickoff when the pick opens. */
+    kickoff: string;
+    payload: PickOfTheDayCommitmentPayload;
+    /** How the pick settled. Never pending: a pending pick is a sealed entry. */
+    outcome: "win" | "loss" | "void";
+    /** Frozen matchup, for a reader. */
+    matchup: string;
+    /** Frozen canonical sport bucket used for selection calibration (Basketball, MMA), not the exact public league identity; the archive owns that. */
+    category: string;
+    /** The pick's public page. */
+    permalink: string;
+};
+/** A published pick that has not settled. Carries the commitment and nothing that states a side or a price: no nonce, no payload, no outcome. Publishable the instant the pick releases. */
+export type PickOfTheDayLedgerSealedEntry = {
+    state: "sealed";
+    /** ET product day the pick belongs to (YYYY-MM-DD). */
+    pick_date: string;
+    /** 1-based daily slot within the product day. */
+    pick_rank: number;
+    /** sha256(canonical_json(payload) || nonce), lowercase hex, no 0x prefix. Publishable the moment the pick releases: without the nonce it is not invertible. */
+    commitment_hash: string;
+    /** The construction the hash was taken with, stated in the response so a verifier never has to guess the serialization. */
+    commitment_algo: "sha256(canonical_json(payload)||nonce)";
+    /** When the hash was frozen. Always strictly before kickoff: a pick that reaches kickoff unsealed stays unsealed forever, because a seal written after the game started would be a backdated proof. */
+    sealed_at: string;
+    /** The frozen provider kickoff in the canonical payload form: whole seconds, UTC, literal Z. This exact string reappears inside payload.kickoff when the pick opens. */
+    kickoff: string;
+    /** The pick's public page. */
+    permalink: string;
+};
+/** A published pick with no commitment: it predates the scheme, or it reached kickoff unsealed. Nothing here is evidence of WHEN the pick was made. It is emitted rather than skipped, because a ledger with holes where the unprovable picks were would silently flatter the record. Once the pick settles, payload names its market, side and price, so the outcome can still be checked against the market's own resolution. */
+export type PickOfTheDayLedgerUncommittedEntry = {
+    state: "uncommitted";
+    /** ET product day the pick belongs to (YYYY-MM-DD). */
+    pick_date: string;
+    /** 1-based daily slot within the product day. */
+    pick_rank: number;
+    /** Always true: this pick has no commitment and never will. */
+    pre_commitment: true;
+    /** How the pick settled, or pending. */
+    outcome: "pending" | "win" | "loss" | "void";
+    /** Frozen matchup, for a reader. */
+    matchup: string;
+    /** Frozen canonical sport bucket used for selection calibration (Basketball, MMA), not the exact public league identity; the archive owns that. */
+    category: string;
+    /** When outcome was LAST written to a settled value, or null when that instant is unknown. It moves with a corrected market re-mapping an already-settled pick, while commitment_hash stays untouched -- which is how a mirror that keeps history sees a correction. */
+    resolved_at: string | null;
+    /** The pick's market, side and price once it has settled; null while it is pending, and null for a settled pick whose stored row lacks one of these columns. Not hashed: nothing was committed over these values, which is what pre_commitment: true says. */
+    payload: PickOfTheDayUncommittedPayload | null;
+    /** The pick's public page. */
+    permalink: string;
+};
+/** A settled uncommitted pick's market, side and price. The same eight fields as PickOfTheDayCommitmentPayload, in the same key order, so a settled pick's side and price sit under payload whatever the entry's state. It is NOT a commitment: no hash was taken over it before the game, and it proves nothing about when the pick was made. */
+export type PickOfTheDayUncommittedPayload = {
+    /** Frozen pre-game price of the backed side, 0..1, as the plain decimal text of the stored NUMERIC at full stored precision, trailing zeros included -- rendered exactly as the commitment payload renders it. */
+    backed_price: string;
+    /** Provider condition id of the backed market. */
+    condition_id: string;
+    /** Frozen provider kickoff, UTC, literal Z; null when no kickoff was frozen. Whole seconds render exactly as the commitment payload does; a sub-second instant keeps its fraction rather than being truncated, since nothing here is hashed. */
+    kickoff: string | null;
+    /** ET product day (YYYY-MM-DD). */
+    pick_date: string;
+    /** Index of the backed outcome within the market. */
+    pick_outcome_index: 0 | 1;
+    /** Frozen display label of the backed outcome. */
+    pick_outcome_label: string;
+    /** 1-based daily slot. */
+    pick_rank: number;
+    /** Provider platform. */
+    platform: string;
+};
 /** Provider-first sports context for a Pick of the Day market: team crests, league branding, and live score. Team logos and league logo are provider-owned (Polymarket /teams crests for clubs, country flags for national teams and tennis players); no local derivation. */
 export type PickSportsContext = {
     /** League or competition display name (e.g. "Premier League"). */
@@ -1485,7 +1691,7 @@ export type Trader = {
     rank?: number | null;
     pnl: {
         total?: number | null;
-        /** For pnl.realized, expand=trust marks a matching native accounting snapshot as computed: native Polymarket realized P&L plus credited maker and taker rebates, with fees already included. Without a matching native accounting snapshot, pnl.realized is omitted and its trust metadata is unavailable. Raw total P&L is never substituted for realized P&L. */
+        /** For pnl.realized, expand=trust marks a matching native accounting snapshot as computed: native Polymarket realized P&L plus credited maker and taker rebates, with fees already included. The exact numeric value is truncated toward zero to cents before conversion to a JSON number. Without a matching native accounting snapshot, pnl.realized is omitted and its trust metadata is unavailable. Raw total P&L is never substituted for realized P&L. */
         realized?: number | null;
         unrealized?: number | null;
         /** DEPRECATED, always null. The local pnl_7d rollup over-counted P&L (#5416 class) and is no longer emitted. Read the provider-native weekly window from GET /api/trader/{address}/profile-summary instead. */
@@ -1497,6 +1703,7 @@ export type Trader = {
         markets_traded?: number | null;
         win_rate?: number | null;
         daily_win_rate?: number | null;
+        /** Full-history both-sides USD cash volume from Polymarket user-volume. Omitted without a verified observation; never leaderboard shares. Volume freshness is unknown in this DTO and does not use synced_at. */
         total_volume?: number | null;
     };
     strategy?: {
@@ -1533,6 +1740,9 @@ export type Trader = {
     sync_status?: string | null;
     /** Field-level trust metadata. Present only when expand=trust or expand[]=trust is requested. */
     trust?: TraderTrust;
+    /** Current evidence for observed and known categories (expand=categories or expand[]=categories). Omitted unless expanded. Includes insufficient, stale, unknown and degraded rows; absence of a category is not proof of skill. The global grade is unchanged. */
+    category_records?: CategorySkillV2[];
+    category_skill_model?: CategorySkillModelReadiness;
 };
 export type TraderContext = {
     trader: Trader;
@@ -1698,6 +1908,8 @@ export type TraderTrust = {
     last_active: TrustMetadata;
     synced_at: TrustMetadata;
     sync_status: TrustMetadata;
+    category_records: TrustMetadata;
+    category_skill_model: TrustMetadata;
 };
 export type TrendingWallet = {
     /** Prefixed trader ID (`trd_...`). */
@@ -1712,7 +1924,10 @@ export type TrendingWallet = {
     platform: "polymarket";
     /** Polymarket weekly/monthly P&L for the wallet in USD, taken from Polymarket's canonical leaderboard (data-api.polymarket.com/v1/leaderboard?timePeriod=week|month&orderBy=PNL). This is the ranking axis and the rows are returned in Polymarket's by-PNL order; it is the provider's number, not a locally summed realized-leaf total. */
     trending_pnl_usd: number;
-    window_volume_usd: number;
+    /** Both-sides cash volume over the window in USD, from Polymarket GET /v2/user-volume (volume_usdc). Omitted when Polymarket served no volume for the wallet: an absent observation, never zero. Polymarket tracks volume in whole UTC days, so this window is the whole-day span covering the requested one, which is not the exact span trending_pnl_usd was scored over. */
+    window_volume_usd?: number;
+    /** Both-sides traded volume over the window in SHARES, from the Polymarket leaderboard row, whose own schema states the figure is never USD. Omitted when the row carried none. */
+    window_volume_shares?: number;
     window_markets_traded: number;
     /** Distinct in-window UTC trade days from our trades (0 if the winner is not in our DB). */
     window_trade_days: number;
@@ -1969,6 +2184,7 @@ export interface OperationData {
     getMonthlyReportSnapshot: ReportSnapshot;
     getPickOfTheDay: PickOfTheDay;
     getPickOfTheDayArchive: PickOfTheDayArchive;
+    getPickOfTheDayLedger: PickOfTheDayLedger;
     getPlatforms: Platforms;
     getPositionTimeline: PositionTimelineEvent[];
     getPositionTimelineById: PositionTimelineEvent[];
@@ -2106,6 +2322,7 @@ export interface OperationQuery {
     };
     getPickOfTheDay: Record<string, never>;
     getPickOfTheDayArchive: Record<string, never>;
+    getPickOfTheDayLedger: Record<string, never>;
     getPlatforms: Record<string, never>;
     getPositionTimeline: {
         /** Market condition_id. One timeline per (trader, market). */