blockrunai/blockrun-mcp/signal-to-trade-demo

Signal-to-Trade Demo

Run one reproducible chain: discover → verify → analyze → preview → inspect. Treat signals as evidence, never as a promise of profit. Never expose a wallet, credential, order ID, or transaction hash in presentation output.

Read references/demo-cases.md when selecting a case or preparing a fallback.

Hard safety contract

1. In a presentation dry-run, do not call wallet, setup, positions, orders, or

resources. Those responses can contain wallet-derived identifiers before the final answer is redacted. The presenter performs account readiness privately before screen sharing.

1. If the current egress is blocked, never call a funds-affecting action with

confirm:true. Continue with live data and a dry-run order preview only. A Stanford/US presentation is always dry-run mode.

1. Always preview through blockrun_polymarket_read action:"preview". It has

no confirmation input and cannot sign or submit an order. A real order requires the user's explicit approval of the exact market, outcome, amount, price/type, and current region eligibility.

1. Choose the smallest whole-dollar preview from $1–$5 that satisfies the live

min_order_size and book depth. Never present a smaller, non-executable preview as valid. Do not split orders to bypass caps.

1. Paid market-data calls may run in parallel on Base. On Solana keep

@blockrun/llm >= 3.8.4, which is what makes concurrent payments distinct.

1. Private operator preflight

• Confirm the Trading profile exposes eight tools and no image/video/media tool:

wallet, price, dex, markets, defi, rpc, polymarket_read, polymarket. (It was nine until 2026-09-06, when the gateway retired Surf and blockrun_surf went with it — a preflight that still counts nine fails.)

• Before screen sharing, the human operator may check blockrun_wallet, run

setup, and inspect positions/orders. Never include those raw calls in the presentation conversation.

• For the live dry-run conversation, begin directly with public market

discovery. No account state is required to preview a CLOB order.

2. Discover a current market

Use a dynamic search rather than a hard-coded condition or token ID:

blockrun_markets {
  path: "markets/search",
  params: { q: "Bitcoin", status: "open", venue: "polymarket", limit: "20" }
}

markets/search is the discovery path for a demo — it ranks across venues in one call. Do not automatically select the first polymarket/crypto-updown result because that feed can contain future placeholders with no liquidity. Rank candidates by:

• open status and a future close time;
• an unambiguous resolution source and threshold;
• non-zero 24-hour volume and trade count;
• a valid condition ID plus outcome token IDs;
• an outcome price away from 0 and 1;
• a live order preview that finds a usable book.

Resolve the selected market using polymarket/markets/keyset with condition_id, status:"open", and a small limit. Do not invent Gamma-only parameters such as active, closed, order, or ascending; the MCP rejects those before payment. Predexon's own search, sort, end_after, and end_before filters are supported on that endpoint.

3. Collect evidence sequentially

Use four independent lenses where the market supports them:

1. Underlying: get current BTC/USD with blockrun_price, then compute the

exact percentage move required to reach the market threshold before expiry.

1. Probability trend: query the selected Yes token:

``text blockrun_markets { path: "polymarket/candlesticks/token/<TOKEN_ID>", params: { interval: "1440", start_time: "<UNIX_SECONDS>", end_time: "<UNIX_SECONDS>" } } ``

interval is integer minutes (1440, not 1h) and is optional. 60 was observed returning a paid 400 where 1440 worked; start_time and end_time are Unix seconds.

1. Smart money: use a meaningful cohort:

``text blockrun_markets { path: "polymarket/market/<CONDITION_ID>/smart-money", params: { window: "30d", min_trades: "100" } } ``

Report wallet count, net-buyer share, volume, and aggregate PnL. A high buyer share with negative PnL is mixed evidence, not automatically bullish.

1. Liquidity/history: query historical orderbooks with token_id,

start_time, and end_time in Unix milliseconds. The order dry-run is the authoritative live fillability check.

Record the timestamp and data source for every observation. If a source fails, label it unavailable and continue; never manufacture a value.

4. Build the signal

Present an evidence table with these columns:

Then state:

• one-sentence thesis;
• strongest counterevidence;
• confidence (low, medium, or high) with a reason;
• proposed side and the smallest executable whole-dollar preview from $1–$5,

or NO TRADE when gates fail.

Do not describe the result as financial advice or a guaranteed “good signal.”

5. Preview and verify

Preview through the dedicated non-destructive action:

blockrun_polymarket_read {
  action: "preview",
  side: "buy",
  token_id: "<TOKEN_ID>",
  amount_usd: <SMALLEST_WHOLE_DOLLAR_FROM_1_TO_5_THAT_MEETS_MIN_SIZE>,
  order_type: "FOK"
}

Show the outcome, live best ask, estimated shares, max cost, and the explicit line DRY RUN — no order signed or submitted.

If the user explicitly approves a real order and the region is permitted, repeat the exact economics with blockrun_polymarket action buy/sell and confirm:true, then use blockrun_polymarket_read to inspect positions and open orders. Redact all identifiers. If a FOK does not fill, report it honestly; do not silently switch to FAK or raise the price.

Presentation output

End with a compact slide-ready block:

LIVE SIGNAL SNAPSHOT — <UTC timestamp>
Market: <question> | Implied probability: <p>
Underlying: <spot> | Required move: <x%> | Time left: <duration>
Trend: <change> | Smart money: <buyer share + PnL caveat>
Liquidity: <spread/activity>
Verdict: <side or NO TRADE> | Confidence: <level>
Order: $<amount> <side> preview | DRY RUN / SUBMITTED
Safety: local signing, capped notional, IDs redacted