在 Hyperliquid 上用 100 行代码构建预测市场机器人

大多数预测市场教程止步于"安装 SDK 并下单"。那只是简单的部分。难的是知道该交易哪些市场，以及何时价格出现偏差。Hyperliquid 的 HIP-4 结果市场运行在与永续合约和现货相同的撮合引擎上，这意味着你可以将 cohort 持仓数据叠加到二元结果交易上，捕捉纯预测市场交易者无法发现的错误定价。

本指南将带你构建一个 Python 机器人，它能发现 HIP-4 市场、读取订单簿、检查 Smart Money 在标的资产上的动向，并在信号对齐时下单。整个代码大约 100 行。

HIP-4 结果市场的实际运作方式

HIP-4 于 2026 年 5 月 2 日在 Hyperliquid 主网上线。每个市场提出一个二元问题：BTC 是否会在特定到期日前超过目标价格？交易者使用 USDC 作为抵押品买入 YES 或 NO 仓位。到期时，获胜方按每单位 1 USDC 结算，失败方结算为 0。

任意时刻 YES 代币的价格代表市场对事件发生的隐含概率。若 YES 以 $0.65 交易，则市场定价该事件发生概率为 65%。互补的 NO 代币应在 $0.35 附近交易，因为双方共享一个合并订单簿，价格为 p 的 YES 买单对应价格为 1-p 的 NO 卖单。

HIP-4 与 Polymarket 有三点不同。第一，结算是确定性的：Hyperliquid 的验证者集合根据预先指定的客观数据源解析每份合约，没有争议窗口，也没有代币投票。第二，没有杠杆，没有清算风险。仓位在开仓时即完全抵押。第三，开仓手续费目前为零，但成交时 builder codes 仍然适用。

你必须搞清楚的编码系统

HIP-4 使用三种格式的编码系统，几乎每个开发者第一次遇到都会踩坑。每个结果有一个 ID，每一方（YES = 0，NO = 1）使用公式 encoding = 10 * outcome_id + side 生成数字编码。

但使用的格式取决于上下文。对于下单和订单簿查询，使用 # 前缀，所以结果 2 的 YES 变为 #20。对于余额查询，使用 + 前缀，同一仓位变为 +20。对于 SDK 内部资产 ID，将编码加上 100,000,000。

这些格式不可互换。在余额查询中使用 #20，或在下单时使用 +20，会静默失败且没有任何错误提示。以下是辅助函数：

def encode_coin(outcome_id: int, side: int) -> str:
    """Order placement and book queries."""
    return f"#{10 * outcome_id + side}"

def encode_balance_coin(outcome_id: int, side: int) -> str:
    """Balance lookups only."""
    return f"+{10 * outcome_id + side}"

def encode_asset_id(outcome_id: int, side: int) -> int:
    """SDK internal mapping."""
    return 100_000_000 + 10 * outcome_id + side

SDK 补丁必须应用： 官方 hyperliquid-python-sdk 原生不支持 HIP-4。其 coin_to_asset 映射表仅从 spot_meta 构建，因此从 100,000,000 开始的结果编码对解析器来说是未知的。你需要获取 outcomeMeta 并手动注入映射。下面的代码处理了这一点。

发现活跃市场

机器人需要做的第一件事是找到哪些市场存在。outcomeMeta 端点返回所有活跃和已结算的结果，包括结果 ID、用管道符分隔的描述（类别、标的资产、到期日、目标价格）以及方向规格。

import httpx

BASE_URL = "https://api.hyperliquid.xyz"

def fetch_outcome_meta():
    r = httpx.post(
        f"{BASE_URL}/info",
        json={"type": "outcomeMeta"},
        timeout=10.0,
    )
    return r.json()

def parse_active_markets(meta):
    markets = []
    for o in meta.get("outcomes", []):
        desc = o.get("description", "")
        parts = desc.split("|")
        if len(parts) >= 4:
            markets.append({
                "outcome_id": o["outcome"],
                "underlying": parts[1].strip(),
                "expiry": parts[2].strip(),
                "target": parts[3].strip(),
            })
    return markets

这会给你平台上每个结果市场的列表。按到期日过滤，专注于尚未结算的市场。例如，每日循环的 BTC 市场每天 06:00 UTC 根据 BTC 标记价格结算。

读取订单簿和隐含概率

每个结果方向都有自己的订单簿。查询方式与现货订单簿相同，只需使用 #N 格式的 coin：

def fetch_book(coin: str):
    r = httpx.post(
        f"{BASE_URL}/info",
        json={"type": "l2Book", "coin": coin},
        timeout=10.0,
    )
    levels = r.json().get("levels", [[], []])
    bids = [(float(p), float(s)) for p, s in levels[0]]
    asks = [(float(p), float(s)) for p, s in levels[1]]
    return bids, asks

def get_mid_price(coin: str) -> float:
    bids, asks = fetch_book(coin)
    if bids and asks:
        return (bids[0][0] + asks[0][0]) / 2
    return 0.0

# 示例：结果 2
yes_mid = get_mid_price("#20")
no_mid = get_mid_price("#21")
print(f"YES: {yes_mid:.4f}, NO: {no_mid:.4f}, sum: {yes_mid + no_mid:.4f}")

在公平市场中，YES 中间价 + NO 中间价应约等于 1.0。任何持续的偏差要么是手续费造成的，要么是值得研究的错误定价。双方之间的价差是你的第一个信号。

将 Cohort 信号叠加到结果价格上

这才是预测市场机器人变得有趣的地方。纯粹的预测市场交易者只看订单簿，也许还会看一些外部新闻。拥有 cohort 数据的开发者能看到别的东西：Hyperliquid 上盈利能力最强的钱包在标的资产上实际在做什么。

设想一个 BTC 结果市场将 BTC 超过目标价格的概率定价为 55%。这是市场的最佳猜测。但我们的 cohort 数据显示，Money Printer 钱包（历史总盈利超过 100 万美元的钱包）在 BTC 永续合约上大幅净多头，而 Giga-Rekt 钱包（历史总亏损超过 100 万美元的钱包）则是净空头。当历史战绩最好的交易者与预测市场的隐含概率背道而驰时，这种背离就是值得行动的信号。

import requests

HT_BASE = "https://ht-api.coinmarketman.com/api/external"
HT_TOKEN = "your_hypertracker_jwt"

def get_cohort_bias(coin: str = "BTC"):
    """Fetch Money Printer and Giga-Rekt positioning."""
    headers = {"Authorization": f"Bearer {HT_TOKEN}"}
    r = requests.get(
        f"{HT_BASE}/cohort/metrics",
        params={"coin": coin},
        headers=headers,
    )
    data = r.json()
    # Extract cohort-level long/short ratio
    money_printer = next(
        (c for c in data if c.get("cohortId") == 8), None
    )
    giga_rekt = next(
        (c for c in data if c.get("cohortId") == 15), None
    )
    return money_printer, giga_rekt

Cohort ID 来自 HyperTracker 的 16 分段分类系统：8 个按永续合约权益规模分段（Shrimp 到 Leviathan），8 个按历史总盈亏分段（Money Printer 到 Giga-Rekt）。Money Printer 是 cohort 8，Giga-Rekt 是 cohort 15。当你看到 Money Printer 大量押注某一方，而结果市场的定价却在另一方时，那就是你的机器人可以利用的差距。

在 HIP-4 市场下单

下单方式与现货交易相同，但有几个 HIP-4 特有的限制。数量必须为整数（不允许小数单位）。最低名义价值为 $10 USDC，即 size * price >= 10。价格范围为 0.001 到 0.999。

from hyperliquid.exchange import Exchange
from eth_account import Account

def place_outcome_order(exchange, outcome_id, side, is_buy, price, size):
    coin = encode_coin(outcome_id, side)
    result = exchange.order(
        coin,
        is_buy=is_buy,
        sz=size,
        limit_px=price,
        order_type={"limit": {"tif": "Gtc"}},
    )
    return result

# 示例：以 $0.45 买入 25 个结果 2 的 YES
# 成本：25 * 0.45 = $11.25（超过 $10 最低限额）
# 若 YES 获胜：收到 25 * $1 = $25，利润 = $13.75
result = place_outcome_order(exchange, 2, 0, True, 0.45, 25)

请记住： HIP-4 仓位完全抵押。没有杠杆，没有清算。任何交易的最大亏损恰好等于开仓时支付的金额。这使得预测市场机器人比永续合约机器人更易于推理，因为你永远不需要担心保证金维持或被动平仓。

整合所有部分：完整机器人

以下是完整的循环代码。机器人发现活跃市场、读取订单簿、检查标的资产的 cohort 持仓，并在预测市场隐含概率与盈利最强的交易者实际行为出现背离时下单。

import time

def run_bot(exchange, info):
    """Main loop: discover, price, signal, execute."""
    meta = fetch_outcome_meta()
    markets = parse_active_markets(meta)

    for market in markets:
        oid = market["outcome_id"]
        underlying = market["underlying"]

        # 第一步：获取隐含概率
        yes_mid = get_mid_price(encode_coin(oid, 0))
        no_mid = get_mid_price(encode_coin(oid, 1))
        if yes_mid == 0 or no_mid == 0:
            continue

        # 第二步：获取 cohort 持仓
        mp, gr = get_cohort_bias(underlying)
        if not mp or not gr:
            continue

        # 第三步：简单背离检查
        # 以下阈值仅供说明，请通过回测校准
        mp_long_pct = mp.get("longPct", 50)
        if mp_long_pct > 70 and yes_mid < 0.50:  # example values
            # 示例仓位大小，满足 $10 最低名义价值
            size = max(10, int(10 / yes_mid) + 1)
            print(f"Signal: {underlying} MP {mp_long_pct}% long, "
                  f"YES at {yes_mid:.2f}. Buying YES.")
            place_outcome_order(exchange, oid, 0, True, yes_mid, size)

    time.sleep(300)  # 5 分钟循环

# 补丁 SDK 并运行
info, exchange = make_clients(PRIVATE_KEY, ADDRESS, BASE_URL)
while True:
    run_bot(exchange, info)

这里的背离阈值和仓位逻辑仅供说明。在生产环境中，你需要根据回测和自身风险承受能力来校准这些参数。关键在于架构：预测市场定价 + cohort 持仓 = 独立预测市场交易者无法获得的信号层。

边界情况与注意事项

SDK 补丁是必须的

官方 hyperliquid-python-sdk 不了解 HIP-4 资产。你需要在启动时获取 outcomeMeta，并将每个结果的编码注入 SDK 的 coin_to_asset 和 name_to_coin 映射表。没有这个补丁，SDK 会以关于未知 coin 的模糊错误拒绝你的订单。

def make_clients(private_key, address, base_url):
    account = Account.from_key(private_key)
    info = Info(base_url, skip_ws=True)
    exchange = Exchange(account, base_url, account_address=address)

    meta = fetch_outcome_meta()
    for o in meta.get("outcomes", []):
        for side in (0, 1):
            coin = encode_coin(o["outcome"], side)
            asset_id = encode_asset_id(o["outcome"], side)
            info.coin_to_asset[coin] = asset_id
            info.name_to_coin[coin] = coin
            exchange.info.coin_to_asset[coin] = asset_id
            exchange.info.name_to_coin[coin] = coin

    return info, exchange

仓位大小只能是整数

与永续合约可以交易小数数量不同，HIP-4 要求整数单位。如果计算出的大小是 22.7，则向上取整为 23。始终验证最低名义价值：size * price >= 10 USDC。

结算是自动的

你不需要调用赎回函数。到期时，USDC 会根据获胜方自动划入你的账户。没有 gas 费，没有领取交易。

Builder Codes 在这里同样适用

如果你在 HIP-4 之上构建前端，builder codes 与现货交易一样在卖单上赚取费用。这意味着每个基于 Hyperliquid 构建的预测市场平台都可以通过 builder codes 获利，而无需直接向用户收费。

为你的预测市场机器人添加 Cohort 智能

HyperTracker 的 API 提供 cohort 持仓数据，将普通预测市场机器人升级为具备 Smart Money 感知能力的系统。16 个行为分段，每 5 分钟刷新，一次 API 调用即可获取。

开始使用 HyperTracker 构建

预测市场赛道仍处于早期阶段。HIP-4 与 Hyperliquid 的永续合约和现货市场共享相同的撮合引擎、账户模型和 API 接口，这意味着你在 Hyperliquid 上构建所积累的所有知识都能直接复用。唯一需要掌握的新概念是编码方案、整数仓位大小，以及仓位不会被清算这一事实。对于已经在使用 cohort 数据的开发者来说，预测市场只是另一个可以叠加信号的工具。优势不在于预测市场本身，而在于在结果市场定价之前，你已经知道 Smart Money 在标的资产上的真实动向。