← 返回 Skills 市场
cryptopunk2070

Fuku Predictions

作者 cryptopunk2070 · GitHub ↗ · v1.0.0
cross-platform ⚠ suspicious
398
总下载
1
收藏
0
当前安装
1
版本数
在 OpenClaw 中安装
/install fuku-predictions
功能描述
Trade Kalshi prediction markets through conversation, powered by Fuku sports model predictions. Use when a user asks about Kalshi markets, wants sports predi...
使用说明 (SKILL.md)

Fuku Predictions — Conversational Kalshi Trading Skill

Trade prediction markets through conversation. The agent learns what you care about, builds a personalized profile, then scans Kalshi markets for opportunities that match your style.

Three Modes

1. Profile Building (Interactive)

User describes preferences → agent builds a trading profile → saves for reuse.

2. Conversational Scanning

Agent scans markets using the profile → presents matching opportunities → user approves trades.

3. Autonomous Trading

Agent scans and trades automatically within risk limits.


Setup

Dependencies

pip install httpx cryptography python-dotenv

Kalshi API Key

Create .env in the skill directory:

KALSHI_API_KEY_ID=your_key_id
KALSHI_PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----
...
-----END RSA PRIVATE KEY-----"

Get credentials: https://kalshi.com/profile/api


Defining Preferences

Users express what they care about in natural language:

Situational: "I want home dogs getting 7+ points in CBB" · "Show me letdown spots after big wins" · "Find revenge games where the underdog lost by 15+ last time"

Player Mismatches: "Games where the best player has a 50+ FPR gap" · "Matchups when a star player is injured"

Statistical: "Only games with top 30 defenses" · "Pace mismatches (fast vs slow)" · "Spreads under 3 points"

Risk & Sizing: "$5 bets on highest confidence plays" · "Max 8 trades per day" · "Quarter-Kelly sizing"


Agent Tools

Profile Management

# Process user preference input
python3 scripts/agent_interface.py --input "I want home dogs getting 7+ points in CBB"

# Scan using a profile
python3 scripts/agent_interface.py --scan --profile default

# List profiles
python3 scripts/agent_interface.py --input "list my profiles"

Market Browser

# Tonight's markets with predictions and edges
python3 scripts/browse.py

# Filter by sport or game
python3 scripts/browse.py --sport cbb
python3 scripts/browse.py --game "Duke" --date 2026-03-03

# Change bet display amount (default $5)
python3 scripts/browse.py --bet 10

Direct Kalshi Access

python3 scripts/kalshi_client.py balance
python3 scripts/kalshi_client.py positions
python3 scripts/kalshi_client.py markets --series KXNBASPREAD

Presenting Markets to Users

Always include: the market, price (dollars), model prediction, edge, payout, and recommendation.

Talk in dollars, not contracts. Users say "$5 on Boston" — convert to contracts internally.

Three-tier display per market type:

  • Main line — contract closest to 50¢ (market consensus)
  • 🔒 Safer — highest edge (high confidence, modest payout)
  • 🎰 Riskier — near model's predicted line (~50% model probability, bigger payout, ≥3% edge required)

Edge icons: 🔥 ≥20% · ✅ ≥10% · 📊 ≥5% · ➖ \x3C5%

Example:

🏀 Boston @ Milwaukee — 7:30 PM
📊 Our model: BOS -8.4 | Total 224.1

• BOS -2.5 at 50¢ → 70% model (+20% edge 🔥) — $5 pays $10
  ↳ 🔒 Safer: BOS -1.5 at 57¢ → 82% model (+25% edge) — $5 pays $8
  ↳ 🎰 Riskier: BOS -8.5 at 31¢ → 50% model (+19% edge) — $5 pays $16
• Over 215.5 at 52¢ → 79% model (+27% edge 🔥) — $5 pays $9

💰 Balance: $49.95
Want me to put money on any of these?

Dollar-to-Contract Math

"$5 on BOS -8.5" at 31¢ → floor($5 / $0.31) = 16 contracts × $0.31 = $4.96 cost → $16.00 payout if YES → $11.04 profit.


Trading

from kalshi_client import KalshiClient
c = KalshiClient()

# Buy
c.place_order(ticker="KXNBA...", side="yes", action="buy",
              count=16, order_type="limit", yes_price=31)

# Sell to exit
c.place_order(ticker="KXNBA...", side="yes", action="sell",
              count=16, order_type="limit", yes_price=current_bid)

Edge Math

Normal distribution probability conversion (no scipy):

  • Uses math.erfc for CDF
  • Sport-specific σ: CBB spread 12.0 / total 11.0, NBA 11.0 / 10.5, NHL 1.5 / 1.3, Soccer 1.2 / 1.1
  • Player props: σ = 30% of predicted value (min 2.0)

Kalshi Market Structure

  • Series (sport): KXNBASPREAD, KXNBATOTAL, KXNBAGAME
  • Event (game): KXNBASPREAD-26MAR02BOSMIL
  • Market (contract): KXNBASPREAD-26MAR02BOSMIL-BOS7 → "Boston wins by over 7.5?"

Pricing: YES/NO in cents (1-99). YES 31¢ = 31% implied. 1 contract = $1 max payout.

Supported Sports

Sport Spread Total ML Props
NBA KXNBASPREAD KXNBATOTAL KXNBAGAME
CBB KXNCAAMBSPREAD KXNCAAMBTOTAL KXNCAABGAME
NHL KXNHLSPREAD KXNHLTOTAL KXNHLGAME Goals/Pts/Ast
Soccer Per-league (EPL/La Liga/Serie A/Bundesliga/Ligue 1/UCL/MLS) Per-league Per-league BTTS

Autopilot Config

config/config.json:

{
  "strategy": "model_follower",
  "sports": ["nba", "cbb"],
  "min_edge_pct": 3.0,
  "max_daily_loss_pct": 10,
  "max_daily_bets": 15,
  "sizing": "quarter_kelly",
  "mode": "approve"
}

Modes: dry_run (log only) · approve (ask user) · auto (hands-free)


Safety

  • Max daily loss limit (default 10%)
  • Position size caps (default 5% per trade)
  • Kill switch: touch KILL_SWITCH in skill directory
  • All trades logged locally to trades.json
  • API keys never leave the machine

Kalshi API Auth

RSA-PSS signatures. The client handles this automatically.

Signing quirk: Portfolio endpoints sign path WITHOUT query strings. Market endpoints sign WITH. See _SIGN_PATH_ONLY in kalshi_client.py.


Fuku Prediction API (Public)

Base: https://cbb-predictions-api-nzpk.onrender.com

Endpoint Data
/api/public/cbb/predictions?date=YYYY-MM-DD CBB predictions
/api/public/nba/predictions?date=YYYY-MM-DD NBA predictions
/api/public/nhl/predictions?date=YYYY-MM-DD NHL predictions
/api/public/soccer/predictions?date=YYYY-MM-DD Soccer predictions
/api/public/cbb/rankings?limit=N Team FPR rankings
/api/public/cbb/players?team=X&limit=N Player FPR data

Files

File Purpose
scripts/browse.py Primary — markets with predictions, edges, payouts
scripts/agent_interface.py Conversational profile building + scanning
scripts/profile_engine.py Profile-based opportunity scoring
scripts/profile_builder.py Natural language → profile JSON
scripts/autopilot.py Autonomous scanning + trading pipeline
scripts/kalshi_client.py Kalshi API client (auth, orders, markets)
scripts/scanner.py Full edge scanner (all contracts)
scripts/executor.py Trade execution with risk management
scripts/portfolio.py Position tracking and P&L
scripts/setup.py Interactive setup wizard
config/config.json Strategy and risk settings
config/profiles/*.json User trading profiles
references/strategies.md Strategy explanations
references/kalshi-markets.md How Kalshi markets work
安全使用建议
Before installing or providing credentials: - Do not place your Kalshi RSA private key into .env until you inspect kalshi_client.py to verify it only signs requests locally and never sends the raw private key to external services. If you are not comfortable reading code, ask a developer you trust to audit kalshi_client.py and any network code. - Investigate the external predictions host (fuku_api_base = https://cbb-predictions-api-nzpk.onrender.com). Determine who runs it and what data you will send to it (player/game queries, your profile, or account info). If the skill sends trade intent or account identifiers to that service, your model/strategy and possibly account activity could be exposed. - The registry metadata claims no env vars but the skill requires Kalshi credentials; treat that as a red flag for sloppy packaging. Prefer a skill that declares required credentials formally in metadata. - Start in dry_run mode and keep auto_trade disabled. Test the skill locally without real money, monitor network calls (e.g., with a transparent proxy like mitmproxy if you can) and confirm no unexpected outbound requests carry secrets. - The code spawns subprocesses with a hardcoded 'arch -arm64' wrapper; test on your host in a safe environment to ensure it behaves as expected. This is odd but not necessarily malicious. - If you cannot or will not perform the checks above, avoid supplying the Kalshi private key and avoid enabling 'auto' mode. Treat this skill as untrusted until audited.
功能分析
Type: OpenClaw Skill Name: fuku-predictions Version: 1.0.0 The skill is designed for legitimate automated trading on Kalshi prediction markets, handling API keys securely (local .env, RSA-PSS signing). However, it contains significant vulnerabilities. The `scripts/agent_interface.py` uses `subprocess.run` to execute `autopilot.py` with a `profile_name` derived from user input, creating a potential shell injection vector. Additionally, `scripts/profile_engine.py`'s `load_profile` function could load a profile from an arbitrary absolute path if user input is crafted, leading to malicious configuration. The `scripts/setup.py` also modifies the user's crontab, a high-privilege action, although the command itself is constructed from internal paths. These are critical vulnerabilities that could be exploited for arbitrary code execution or malicious configuration, but there is no clear evidence of intentional malicious behavior (e.g., data exfiltration to an attacker-controlled server, backdoors, or obfuscation).
能力评估
Purpose & Capability
Name/description match the code: the package is an autopilot/trading suite for Kalshi using a Fuku sports model. However the registry metadata declares no required credentials while SKILL.md and the code expect a Kalshi API key (RSA private key + id) in a local .env — that mismatch is a coherence issue. Also config points to a third-party predictions endpoint (fuku_api_base on onrender.com) which is not explained in the public description; it's plausible for a model-backed skill but should be documented and justified.
Instruction Scope
SKILL.md instructs to store Kalshi credentials locally and claims 'API key stored locally — never transmitted externally.' The codebase references an external predictions API (fuku_api_base) and performs network calls and subprocess execution (e.g., launching autopilot.py). Those external requests could receive request metadata or parameters — the README claim that keys never leave the machine is not verifiable without auditing kalshi_client.py and network calls. agent_interface.py spawns subprocesses using a hardcoded command ('arch -arm64 python3 autopilot.py'), which is unexpected and may fail or behave differently on non-arm64 hosts.
Install Mechanism
There is no install spec in the registry (instruction-only), which limits automatic system changes. SKILL.md suggests pip installing httpx, cryptography, python-dotenv — a reasonable minimal dependency set for HTTP requests and local secret handling. Because code files are bundled, the skill will execute arbitrary Python code when invoked; that is normal for this type of skill but increases the need for code review.
Credentials
The registry lists no required env vars or primary credential, but SKILL.md asks the user to create a .env containing KALSHI_API_KEY_ID and KALSHI_PRIVATE_KEY (private RSA key). That is a clear mismatch. The private key is powerful: it allows API calls and signing for your Kalshi account; you should only provide it if you trust the code. The skill claims keys 'never transmitted externally,' but the presence of a third-party predictions API and networked components means you must audit the code to confirm the private key is only used locally to sign requests to Kalshi and never sent elsewhere.
Persistence & Privilege
always:false (no forced always-on) and autonomous invocation is allowed (default). The skill can run 'auto' trading mode that places real trades; combined with access to your Kalshi credentials this is powerful. This is not an immediate disqualifier, but you should restrict autonomous/auto modes until you verify behavior. The skill writes local files (trades.json, optional KILL_SWITCH file) which is expected for a trading agent and is limited to its directory.
如何使用
  1. 确保已安装 OpenClaw(本地或 Docker 部署)
  2. 在对话框中输入安装命令:/install fuku-predictions
  3. 安装完成后,直接呼叫该 Skill 的名称或使用 /fuku-predictions 触发
  4. 根据 Skill 的参数说明提供必要输入,即可获得结构化输出
版本历史
v1.0.0
Initial release: conversational Kalshi trading with personalized profiles, 4 sports, autopilot mode
元数据
Slug fuku-predictions
版本 1.0.0
许可证
累计安装 0
当前安装数 0
历史版本数 1
常见问题

Fuku Predictions 是什么?

Trade Kalshi prediction markets through conversation, powered by Fuku sports model predictions. Use when a user asks about Kalshi markets, wants sports predi... 它是一个面向 Claude Code / OpenClaw 的 AI Agent Skill 插件,目前累计下载 398 次。

如何安装 Fuku Predictions?

在 OpenClaw 或 Claude Code 对话框中运行命令「/install fuku-predictions」即可一键安装,无需额外配置。

Fuku Predictions 是免费的吗?

是的,Fuku Predictions 完全免费(开源免费),可自由下载、安装和使用。

Fuku Predictions 支持哪些平台?

Fuku Predictions 跨平台运行,可在任意部署了 OpenClaw / Claude Code 的环境中使用(cross-platform)。

谁开发了 Fuku Predictions?

由 cryptopunk2070(@cryptopunk2070)开发并维护,当前版本 v1.0.0。

💬 留言讨论