原作：@MrRyanChi，@insidersdotbot 预测市场交易平台创始人

序言：你不知道的 Polymarket B面

在过去的六个月间，推特上出现了数亿千计的预测市场文章。

其中90%是再讲AI写程序怎么带来暴富神话。这是“缘”，是你接触这个刚刚开始的市场的第一步。

另外9%讲的是具体的交易策略，市场分享，聪明钱策略解析。这便是“道”，是你开始摸索自己交易策略，开始理解预测市场上赚钱思路的第一步。

然而这“法”，也就是预测市场底层的交易设计，PNL计算，金钱流动的规则，虽有那1%的人讲，但大多分散在一些短小精悍的推文当中。这些隐士高手，似乎始终不愿意，或者没有精力，将自己完整的法门一次性分享给所有人。

所以，在 insiders.bot 刚刚上线，Polymarket刚刚完成v2更新的今天，我想从最底层的技术，来一次性解构这个我们一直交易的市场底层的“法”。

去年10月，我写了一篇简易版，大致带大家了解了Polymarket的几个核心组件。这次，我想真正把所有技术上的设计细节展示给大家看，并且用大白话解释清楚。

这篇文章包含了我们团队过去八个月的心血。

这八个月间，@insidersdotbot 团队拆解了所有Polymarket的底层智能合约与算法架构，来实现最快速的交易，以及最精准的PNL计算。这点，只有我们自己做的API能够实现，直到今天，没有别人做得到。

所以，我想，我们或许正式最能拆解Polymarket底层的“法”的人。

这篇文章中，我会带你理解底层的 ctf-exchange-v2 智能合约如何处理每一笔资金，Relayer 是如何帮你垫付 Gas ，一路明白 Negative Risk 是如何在数学上保证价值守恒的。

这不是一篇简单的科普。这是我用开发者的视角重新拆解 Polymarket 底层机制的算法全解。

我们先从最基础的开始。也就是，当你下达一个订单时，你到底发送了什么？

P.S 这篇文章也经过了AI进行文风和结构适配，欢迎发给你的OpenClaw，Manus，Hermes，或者任何AI Agent作为训练语料！！！

第一章：从点击到上链，到底发生了什么

1.1 订单不是交易，是“意图”

在传统的去中心化交易所（比如 Uniswap），当你交易时，你的钱包会弹出一个确认框，你需要支付 Gas 费，然后把一笔交易（Transaction）发送到区块链的网络（Mempool）里等待矿工打包。

但在 Polymarket，当你下单时，你的钱包弹出的通常是一个“签名”（Sign）请求，而不是“交易”（Transaction）请求。而且，你不需要支付任何 Gas。

这不仅仅是用户体验的优化，这是整个底层架构的根本区别。

在 Polymarket 上，一个订单（Order）本质上是一段符合 EIP-712 标准的结构化数据。这段数据包含了你想要做什么：

• 你是 Maker 还是 Taker？你想买哪个 Token（tokenId）？

• 你想付出多少（makerAmount）？

• 你想得到多少（takerAmount）？

当你签名时，你只是用你的私钥对这段数据盖了个章，证明“我确实想这么干”。然后，这段带有签名的数据被发送到了 Polymarket 的中心化服务器上，存入了一个链下（Off-chain）的中央限价订单簿（CLOB）。

在这个阶段，区块链上什么都没有发生。 你的钱还在你的钱包里，代币也没有转移。你的订单只是数据库里的一行记录。

1.2 价格的隐式表达

我们先将时间暂停到你发送订单的这个瞬间。如果你仔细看 Polymarket 底层合约的订单结构，你会发现一个非常反直觉的事情：订单签名数据里没有“价格”（Price）这个字段。

这怎么可能？没有价格怎么交易？

在 Polymarket 的协议底层设计中，价格是隐式的。它是由你愿意付出的数量和你想得到的数量算出来的。

如果你想以 $0.60 的价格买入 100 个 YES 合约：

• 你需要付出：$60 pUSD（makerAmount = 60）

• 你想得到：100 个 YES 合约（takerAmount = 100）

• 隐含价格 = makerAmount / takerAmount = 60 / 100 = $0.60

如果你想以 $0.60 的价格卖出 100 个 YES 合约：

• 你需要付出：100 个 YES 合约（makerAmount = 100）

• 你想得到：$60 pUSD（takerAmount = 60）

• 隐含价格 = takerAmount / makerAmount = 60 / 100 = $0.60

（注：虽然在最新的 V2 SDK 中，开发者可以直接传入 price 和 size，但 SDK 在底层签名时，依然会将其转换为 makerAmount 和 takerAmount。这种设计的巧妙之处在于，智能合约不需要理解什么是“价格”，它只需要处理“资产 A 换资产 B”的逻辑。这大大简化了链上的计算逻辑，降低了 Gas 消耗。）

1.3 Operator：Polymarket 的“交通警察”

既然订单都在链下，那它们是怎么变成链上真实的资产转移的？

这就引出了 Polymarket 架构中最核心的黑盒角色：Operator（操作员）。

在 ctf-exchange-v2 智能合约中，有一个极其关键的修饰符：onlyOperator。这意味着，只有 Polymarket 官方控制的那个特定地址，才有权限调用 matchOrders 和 fillOrder 等执行函数。

这与传统的 DeFi 完全不同。在 Uniswap，任何人都可以调用路由合约。但在 Polymarket，你不能自己去链上撮合交易。所有的匹配，必须由 Operator 来提交。

为什么要这么设计？为了消灭 MEV（矿工可提取价值）和抢跑（Front-running）。

在传统的链上订单簿中，如果有人挂了一个价格很低的大单，所有的套利机器人都会在 Mempool 里疯狂竞价（提高 Gas 费），试图抢在别人前面吃掉这个单子。这会导致 Gas 费飙升，普通用户体验极差。

而在 Polymarket，所有的订单都在链下的 CLOB 里。Operator 的匹配引擎（Matching Engine）在服务器上计算出谁和谁应该成交，然后把结果打包成一笔交易，由 Operator 发送到链上。

因为只有 Operator 能提交匹配结果，Mempool 里的机器人就算看到了这笔交易，也无法抢跑，因为他们没有权限调用执行函数。

这是一种典型的“混合去中心化”架构。撮合和排序是中心化的（由 Operator 决定），但结算和资金保管是去中心化的（由智能合约执行）。

Operator 可以决定先匹配谁后匹配谁，但它绝对无法盗走你的资金，因为它必须提供你签名的那段 EIP-712 数据，合约会严格验证签名。

P.S: 不过，这里还是要稍微提一嘴。我们 @insidersdotbot 最近似乎发现了这个机制一个可以利用地方，能够让跟单进行抢跑，或者进行极大幅度的延迟降低。如果有任何更新，我们会第一时间在官方账号公布。

第二章：Relayer 的经济学

2.1 “免 Gas”的错觉

Polymarket 最大的卖点之一就是对用户“免 Gas”（Gasless Transactions）。你只需要有 pUSD 就可以交易，不需要买 POL（前 MATIC）放在钱包里。

但区块链的物理定律是不可违背的：只要在 Polygon 上发生了状态改变（比如资产转移），就必须有人支付 Gas 费。

既然你没付，那是谁付的？答案是：Relayer（中继器）。

2.2 Relayer 的接力网络

Polymarket 并没有让用户自己去发交易，而是部署了一套名为 Relayer Client 的基础设施（relayer-v2.polymarket.com）。

在早期架构中，这类服务通常依赖 OpenZeppelin Defender Relay 这样的企业级服务，通过维护一个签名器池（Signer Pool）来解决高并发下的 nonce（交易序号）冲突问题。

当你的 App 创建了一笔交易（比如 Approve 代币、Redeem 收益），你用私钥签名后发给 Relayer。Relayer 会作为“交易赞助商”（Transaction Sponsor），把这笔交易提交到链上，并用自己的资金池为你垫付 Gas 费。

Relayer架构与经济循环

2.3 羊毛出在羊身上？

在早期的很多元交易（Meta-transaction）架构中，Relayer 垫付 Gas 后，通常会从用户的存款中扣除一笔手续费（比如 0.3% 或固定几美元）来弥补 Gas 成本。

但 Polymarket 极其激进：在当前的 V2 架构中，他们真的为你全额买单了。

官方文档明确写道：“Polymarket pays gas for all operations routed through the relayer”。无论是部署钱包、授权代币，还是拆分（Split）、合并（Merge）、赎回（Redeem），全部免 Gas 费，且不收任何隐性操作费。

为什么 Polymarket 愿意做这个亏本买卖？

因为 Polygon 上的 Gas 成本极低（通常只有几美分），而免 Gas 带来的丝滑体验，能吸引海量的 Web2 用户入场。只要用户在交易中产生了微小的 Taker 手续费（后面会讲），就足以覆盖这笔极低的 Gas 成本。

知道了这个，下一个问题自然就来了：这个“免 Gas”架构对我们交易有什么影响？

最大的隐性成本就是延迟（Latency）。你的订单不仅要经过 Polymarket 的匹配引擎，如果是直接上链的操作，还要经过 Relayer 的验证、Gas 估算、队列分配。

第三章：三种匹配方式，以及为什么买家和买家也能成交？

现在我们进入了整个 Polymarket 架构中最硬核、最反直觉的部分。

在传统的交易所（比如币安的订单簿），匹配逻辑非常简单：Alice 想用 $60 买 1 个代币，Bob 想用 $60 卖 1 个代币。交易所把他们撮合在一起，代币从 Bob 到 Alice，钱从 Alice 到 Bob。结束。

但在 Polymarket（基于条件代币框架 CTF），事情完全不同。因为在这里，代币是可以被“凭空印出来”和“凭空销毁”的。

当你打开 ctf-exchange-v2 的源码，你会发现底层有三种完全不同的资产结算路径：COMPLEMENTARY、MINT 和 MERGE。

Complementary, Mint, Merge 大致结构

3.1 COMPLEMENTARY（互补匹配）：传统的二手交易

这是最容易理解的一种匹配方式，也是传统交易所唯一拥有的方式。

场景： 市场已经存在一段时间，大家手里都有筹码。

• Alice 想以 $0.60 买入 100 个 YES。

• Bob 手里有 YES，他想以 $0.60 卖出 100 个 YES。

Operator 发现这两个订单（BUY vs SELL），把它们打包上链。智能合约执行直接的点对点转账：

1. 把 100 个 YES 从 Bob 的地址转给 Alice。

2. 把 $60 pUSD 从 Alice 的地址转给 Bob。

这个机制有如下数学与工程特征：

• 零和游戏：系统的总代币供应量没有发生任何变化。

• Gas 消耗最低：只涉及基础的转账，不涉及 CTF 的复杂操作。

• 标准化：在一个成熟、流动性充足的市场中，绝大多数日常交易都是这种方式。

3.2 MINT（铸造匹配）：凭空创造流动性

这或许是是 Polymarket，乃至整个金融史上最为革命性的创新。

为了更好的解释，我们可以参考这个场景： 一个全新的市场刚刚上线，没有任何人手里有 YES 或 NO 代币。

• Alice 极度看好，她想以 $0.60 买入 100 个 YES。

• Bob 极度看衰，他想以 $0.40 买入 100 个 NO。

注意：他们两个都是买家！他们都没有对方想要的代币！

在传统的订单簿里，这两个订单只能干瞪眼，永远无法成交。在 Polymarket，如果遇到 BUY vs BUY（且代币互补），Operator 会把这两个订单撮合在一起！

1. 智能合约从 Alice 账户扣除 $60 pUSD。

2. 智能合约从 Bob 账户扣除 $40 pUSD。

3. 智能合约拿到这 $100 pUSD，将其锁定为抵押品，然后调用 _mint 函数，凭空铸造出 100 个 YES 和 100 个 NO。 4. 把 100 个 YES 发给 Alice。

4. 把 100 个 NO 发给 Bob。

这种机制的触发，必须基于一个严格的数学条件：买方出价之和必须大于等于 $1.00。

如果 Alice 出价 $0.60 买 YES，Bob 出价 $0.35 买 NO，加起来只有 $0.95。智能合约是无法用 $0.95 铸造出价值 $1.00 的完整代币对的。这个匹配会直接失败。

MINT匹配机制

从做市商角度看，这个机制是解决“冷启动”问题的终极武器。当市场刚开盘时，做市商不需要自己先去花钱铸造一堆代币放在手里（这会占用大量资金）。他们只需要在 YES 和 NO 两边同时挂出买单（比如 $0.49 买 YES，$0.49 买 NO）。当散户来卖的时候，就会触发铸造逻辑。

3.3 MERGE（合并匹配）：流动性的湮灭

有创造就有毁灭。MERGE 是 MINT 的反向过程。

我们看一个反过来的案例。市场即将结束，大家都在平仓。

• Alice 手里有 100 个 YES，她想以 $0.60 卖出。

• Bob 手里有 100 个 NO，他也想以 $0.40 卖出。

注意：他们两个都是卖家！ 没有任何人愿意出 pUSD 来买他们的代币。

Polymarket的机制这时候便会再度发力。当遇到 SELL vs SELL 时，Operator 再次施展魔法：

1. 智能合约从 Alice 那里拿走 100 个 YES。

2. 智能合约从 Bob 那里拿走 100 个 NO。

3. 智能合约调用 _merge 函数，将这 100 对 YES+NO 彻底销毁，并从金库中解锁 $100 pUSD。

4. 把 $60 pUSD 发给 Alice。

5. 把 $40 pUSD 发给 Bob。

而Merge机制则有以下数学与金融特征：

• 通缩机制：系统的总代币供应量减少了。

• 退出通道：它保证了即使没有“接盘侠”，只要 YES 和 NO 的卖家价格能凑够 $1.00（实际上是让出 $1.00 的空间），大家依然可以套现离场。

理解了这三种匹配方式，你就理解了 Polymarket 市场的生命周期：

• 早期（MINT 主导）：市场刚开，没有代币。多空双方通过 MINT 机制不断把资金注入系统，换取代币。总供应量迅速上升。

• 中期（COMPLEMENTARY 主导）：市场流动性充足，大部分交易都是现有代币的换手。总供应量稳定。

• 晚期（MERGE 主导）：结果逐渐明朗，大家开始平仓。多空双方通过 MERGE 机制销毁代币，换回资金。总供应量下降。

请注意，这三种路径不是由 Operator 主观选择的，而是由订单的买卖方向（BUY vs SELL）严格决定的智能合约路由规则。

市场生命周期

第四章：Split/Merge/Redeem，以及你的 PnL 为什么是错的？

了解了匹配机制，我们再来看三个你可能每天都在用，但从未真正理解其财务影响的底层操作：Split（拆分）、Merge（合并） 和 Redeem（赎回）。

这三个操作是 Polymarket 的原子级操作。它们不是“交易”（不经过订单簿，不收取手续费），而是直接与智能合约交互的资产转换。

• Split：你给合约 $1 pUSD，合约给你 1 个 YES 和 1 个 NO。成本永远是精确的 $1。

• Merge：你给合约 1 个 YES 和 1 个 NO，合约还你 $1 pUSD。收益永远是精确的 $1。

• Redeem：市场决出胜负后，赢的代币换回 $1 pUSD，输的代币清零。

Split操作前后对比

4.1 谁在使用这些操作？

• 做市商（Market Makers）：他们是 Split 的最大用户。做市商需要在两边同时挂单，但他们不想去市场上买代币（会被收手续费）。他们直接把 $10 万资金 Split 成 10 万个 YES 和 10 万个 NO，然后挂在订单簿上。

• 套利者（Arbitrageurs）：他们是 Merge 的最大用户。当市场出现短暂的错价，比如 YES 跌到 $0.40，NO 跌到 $0.55。套利者会迅速买入 1 个 YES 和 1 个 NO（总成本 $0.95），然后立刻调用 Merge 换回 $1，无风险净赚 $0.05。这个数学条件非常清晰：当 Price(YES) + Price(NO) 1 - 手续费 时，无脑买入并 Merge。

所以，当你试图跟单一个套利者的聪明钱，或者做市商的聪明钱时，你必须准确判断Split/Merge对PNL带来的影响。否则，这就不是一个值得参考的“聪明钱”。

而当今市场上，包括Polymarket本身在内，都无法解决PNL的计算问题。当然，你可能已经猜到了 - insiders.bot 已经在PNL计算和聪明钱浏览器中解决了这个问题。

4.2 PnL 陷阱：为什么你的利润是错的？

正如上文所说，这是整个 Polymarket 生态中最普遍的错误。几乎所有的第三方 PnL（盈亏）追踪工具，甚至包括官方的一些 API，都在这里栽了跟头。

我给你算一笔账，你就知道这个陷阱有多深。

步骤 0：假设你本金有 $100。你看好“以太坊突破 $5000”这个市场。

步骤 1：你花了 $50 执行了一次 Split。现在你手里有 50 个 YES 和 50 个 NO。你的现金还剩 $50。

步骤 2：你觉得 50 个 YES 不够，又去市场上以 $0.40 的价格买了 50 个 YES。花费 $20。现金还剩 $30。

步骤 3：你把手里的 50 个 NO 以 $0.35 的价格卖掉。收回 $17.50。现金变成 $47.50。

现在，你手里有 100 个 YES 合约。你的真实成本是多少？

大多数排行榜是怎么算的（错误算法）：

他们只看你的“交易”记录。他们看到你买入了 50 个 YES，花费 $20。他们完全忽略了 Split（因为那不是交易）。

所以他们认为你的成本是：$20 / 50 = $0.40/个。

如果现在 YES 的市场价涨到了 $0.60，他们会显示你的利润是：100 × $0.60 - $20 = $40。

实际上你应该怎么算（正确算法，以及 insiders.bot 正在使用的算法）：

你的总现金流出：$50（Split） + $20（买入） = $70。

你的总现金流入：$17.50（卖出 NO）

你的净投入：$70 - $17.50 = $52.50

你的真实成本：$52.50 / 100 = $0.525/个。

如果现在 YES 的市场价是 $0.60，你的真实利润是：100 × $0.60 - $52.50 = $7.50

看到差距了吗？排行榜显示你赚了 $40，但你实际上只赚了 $7.50。中间那 $32.50 的“幻觉利润”，就是因为系统没有正确处理 Split 的成本和卖出 NO 的收益。

正确的 PnL 数学公式应该是：

总盈亏 = Σ(卖出收入) + Σ(Merge 收入) + Σ(Redeem 收入) - Σ(买入支出) - Σ(Split 支出) + 当前持仓市值

这就是为什么你在排行榜上看到某些大佬显示亏损几百万，但实际上他们赚得盆满钵满。因为赢的仓位被 Redeem 之后，很多工具会把这些持仓从历史记录中“抹掉”，只留下那些还在亏损的烂摊子。

PnL计算陷阱

第五章：手续费曲线

如果你经常交易，你会发现 Polymarket 的手续费并不是一个固定的百分比。有时你买 $1000 的合约被收了 $10，有时却只收了 $2。

为什么？让我们来看看隐藏在代码深处的费用公式：

Fee = C × feeRate × p × (1 - p) （其中 C 是交易数量，p 是价格）

5.1 为什么是 p(1-p)？

假设你想买 100 个 YES，费率是 2%：

• 如果 YES 的价格是 $0.50：手续费 = 100 × 2% × 0.50 × 0.50 = $0.50

• 如果 YES 的价格是 $0.90：手续费 = 100 × 2% × 0.90 × 0.10 = $0.18

• 如果 YES 的价格是 $0.10：手续费 = 100 × 2% × 0.10 × 0.90 = $0.18

你发现规律了吗？当价格在 0.50（五五开）时，手续费最高。当价格接近 0 或 1（大局已定）时，手续费极低。

更重要的是对称性。买入 $0.90 的 YES，和买入 $0.10 的 NO，在数学上是等价的。如果你买 $0.90 的 YES 收费很高，而买 $0.10 的 NO 收费很低，套利者就会疯狂买入 NO 然后通过 MINT 机制套利。p(1-p) 这个设计，保证了无论你从哪一面表达观点，系统收取的摩擦成本都是绝对对称的。

5.2 隐藏的数学之美

如果你学过统计学，你会对 p(1-p) 这个公式非常眼熟。它是伯努利分布（抛硬币）的方差公式。

在 Polymarket 的整个系统设计中，p(1-p) 就是“上帝公式”：

1. 它是手续费曲线：不确定性（方差）越高，系统收取的费用越高。

2. 它是信息熵的体现：你在 50% 时下注，你为市场提供了最多的新信息，所以你付出的代价最大。

谁支付手续费？永远是 Taker（吃单者）。Maker（挂单者）永远免手续费。

这个机制完美地对齐了激励：在市场最迷茫（50/50）的时候，早期入场者会被收取最高的手续费，这保护了做市商免受无谓的冲击；而在市场几乎确定的时候，极低的手续费鼓励套利者进场，把价格推向最终的 1 或 0。

手续费曲线

第六章：Negative Risk，aka DeFi 领域最优雅的魔术

如果你在 Polymarket 上玩过大选、奥斯卡或者体育比赛等多结果（Multi-outcome）市场，你一定接触过负风险（Negative Risk）市场。

这是整个文章中最烧脑，但也最能体现智能合约工程美学的部分。

P.S 这也是我们的联创 @DakshBigShit 在开发我们自己的API时，通过36小时马拉松爆肝才解决的部分。

6.1 传统多结果市场的痛点

假设有四个候选人：A、B、C、D。 你极度讨厌 A，你确信 A 绝对赢不了。你想“做空” A。

在传统的二元市场，你只需要买入 A 的 NO 合约。 但在多结果市场中，A 输了，意味着 B、C、D 中必然有一个赢了。 所以，“做空 A” 在数学上严格等价于 “做多 B + 做多 C + 做多 D”。(这句很重要，反复读到读懂为止。)

如果你去市场上分别买入 B、C、D 的 YES 合约，你会遇到一个巨大的问题：资金效率极低。因为你需要分别垫付三笔钱，而且如果这三个人的价格加起来大于 $1.00，你甚至可能亏本。

6.2 负风险适配器（NegRiskAdapter）的魔法

Polymarket 部署了一个专门的智能合约 NegRiskAdapter 来解决这个问题。它提供了一个叫 convertPositions 的函数。

这个函数的作用是：把你手里的 NO 合约，瞬间转换成其他所有候选人的 YES 合约，并且退还给你一笔现金。

让我们用硬核的数学来证明这个转换为什么是价值守恒的。

场景设定： 有 n 个候选人。

• 你手里有 A 份候选人 1 的 NO 合约，以及 A 份候选人 2 的 NO 合约（你同时做空了 1 和 2）。

• 你总共持有 m 个不同的 NO 合约（这里 m=2）。

转换前，你持仓的真实价值（在所有可能的世界线中）：

• 如果候选人 1 赢了：NO_1 变废纸，NO_2 价值 $1。总价值 = A。

• 如果候选人 2 赢了：NO_1 价值 $1，NO_2 变废纸。总价值 = A。

• 如果候选人 3 赢了（你没有做空的任何人赢了）：NO_1 价值 $1，NO_2 价值 $1。总价值 = 2A。

调用 convertPositions 后，合约给你发了什么？

公式是：退还给你 A × (m-1) 的资金，外加 A 份候选人 3、4、… n 的 YES 合约。

在这个例子中，退还：A × (2-1) = A 份的现金！外加 A 份候选人 3 的 YES，A 份候选人 4 的 YES…

转换后，你持仓的真实价值（在所有可能的世界线中）：

• 如果候选人 1 赢了：你手里的 YES_3, YES_4 全变废纸。你只剩下现金 A。总价值 = A。（与转换前相等！）

• 如果候选人 2 赢了：你手里的 YES_3, YES_4 全变废纸。你只剩下现金 A。总价值 = A。（与转换前相等！）

• 如果候选人 3 赢了：你手里的 YES_3 价值 $1，其他变废纸。加上现金 A。总价值 = A + A = 2A。（与转换前相等！）

Q.E.D. 无论世界怎么发展，转换前后的价值绝对相等。

Negative Risk 转换数学证明

6.3 为什么这是一个“单向不可逆”的熵增过程？

这个转换机制有一个极其迷人的物理学特性：它是单向不可逆的。

你可以把 NO 转换成 YES + 现金。但你绝不能把 YES + 现金反向转换成 NO。

为什么？因为在智能合约底层，当你把 NO 转换成 YES 时，合约实际上是把你的 NO 合约发送到了黑洞地址（Burn 销毁），然后利用这部分释放出来的抵押品空间，“合成”出了新的 YES 合约。这不需要注入新的外部资金。

但如果你想反过来，把 YES 变成 NO，你需要凭空创造出新的抵押品（因为 NO 合约的覆盖面比 YES 广得多）。适配器没有这个权限去动用国库的资金。

这就像打碎一个鸡蛋。NO 是那个完整的鸡蛋，包含了所有的可能性。转换操作就是把鸡蛋打碎，分成了蛋黄（YES）和蛋清（现金）。过程价值守恒，但你永远无法把它们拼回一个完整的鸡蛋。

这里有个巨大的套利空间：如果你发现市场上某个候选人的 NO 价格，大于其他所有候选人 YES 价格的总和。你就可以买入这个 NO，调用 convertPositions 拿到现金和一堆 YES，然后立刻把这些 YES 卖掉。这就是在多结果市场中最高阶的无风险套利策略。

第七章：速度的物理极

最后，我们来谈谈交易中最残酷的维度：时间。

在传统的高频交易中，我们在讨论微秒（百万分之一秒）。在 Polymarket，我们在讨论毫秒。但这里有一个巨大的、结构性的不平等。

如果你在 Reddit 的算法交易板块混迹过，你会发现所有开发 Polymarket 机器人的程序员都曾抱怨过同一件事：“为什么我下 Taker 单总是要等 300 毫秒，而 Maker 单只要 25 毫秒？”

7.1 为什么 Maker 快，Taker 慢？

• 当你下达一个 Maker（挂单）时： 你的订单（签名数据）发送到 Polymarket 的服务器。服务器检查一下签名有效，直接把这条记录塞进内存里的 CLOB（订单簿）数据库。然后立刻给你返回一个 ACK（确认）。整个过程完全在链下发生，只需要一次数据库写入。耗时：~25 毫秒。

• 当你下达一个 Taker（吃单）时： 你的订单发送到服务器。匹配引擎发现你的单子可以和订单簿里的某个 Maker 匹配。 此时，Operator 必须启动复杂的结算流水线：

  1. 决定使用哪种匹配路径（COMPLEMENTARY, MINT, 还是 MERGE）。

  2. 构造包含双方签名的链上交易数据。

  3. 把交易发给 Relayer。

  4. Relayer 估算 Gas，分配 Nonce。

  5. 将交易广播到 Polygon 节点。

  6. 等待节点确认这笔交易不会因为余额不足等原因 Revert。

  整个过程跨越了多个微服务，甚至触及了区块链的边缘。耗时：~250 到 300 毫秒。

7.2 这 250 毫秒意味着什么？

这 250 毫秒的物理鸿沟，深刻地塑造了 Polymarket 的生态。

第一，你很难在 Polymarket 上抢跑（Front-run）。 因为所有的 Taker 单都必须排队等待 Operator 处理，你无法通过提高 Gas 费来插队。Mempool 抢跑在这里暂时是个伪命题。

第二，Maker 策略的绝对优势。 因为撤单（Cancel）和 Maker 挂单一样，都是链下操作，只需要 25 毫秒。当突发新闻发生时，聪明的做市商可以利用这 250 毫秒的时间差，抢在 Taker 的订单被结算之前，把自己的挂单撤掉（这就叫规避逆向选择 Adverse Selection）。

7.3 每周二早晨的 90 秒停机

关于时间，还有一个鲜为人知的细节。 根据官方文档，每周二美国东部时间早上 7:00，Polymarket 的匹配引擎会重启。在这大约 90 秒的时间里，系统停止处理任何匹配，API 会返回 HTTP 425（Too Early）错误。

更残酷的是，V2 引入了 Heartbeat（心跳）机制。如果服务器 10 秒内没有收到客户端的心跳，就会自动取消该用户所有的开仓订单。在重启的这 90 秒内，做市商的心跳被迫中断，他们的订单会被系统集体清空。

这 90 秒，是系统中真正的“流动性真空”。对于期权定价模型来说，这 90 秒的 Theta（时间衰减）如何计价，以及如何在第 91 秒引擎恢复时第一时间抢占盘口，是留给顶级平台和量化工作室的终极谜题。

延迟时间线对比

第八章：V2 大规模重构与“幽灵成交”（Ghost Fill）的终极战役

如果你一直读到这里，你已经掌握了 Polymarket 的核心骨架。但如果你想在 2026 年继续在这个市场上赚钱，你必须了解刚刚发生的一场大地震。

在 2026 年 2 月到 5 月期间，Polymarket 悄然进行了一次史诗级的 V2 架构升级。这次升级不仅重构了抵押物和手续费公式，更重要的是，它打响了解决预测市场最臭名昭著的 Bug，也就是幽灵成交（Ghost Fill）的终极战役。

8.1 什么是幽灵成交？链上与链下的状态割裂

在 Polymarket V2 升级前，无数做市商和量化机器人被一个现象折磨得死去活来： 你的机器人在 5 分钟线级别市场（比如 BTC Up/Down 5m）捕捉到了一个绝佳的机会，立刻发出了吃单（Taker）请求。Polymarket 的 API 瞬间返回：“Matched! Success!”，你的 Telegram 报警也弹出了“FILLED”的狂欢。 但当你打开 Polygonscan 查区块链浏览器时，却发现这笔交易被标记为 REVERTED（失败），白白浪费了 Gas 费。而你的持仓毫无变化。

订单簿明明显示成交了，区块链却说没发生。这就是幽灵成交（Ghost Fill）。

要理解这个 Bug 的本质，我们需要回到第一章讲的底层架构：链下撮合（Off-chain Matching）+ 链上结算（On-chain Settlement）。

当 Alice 的买单和 Bob 的卖单在链下中央限价订单簿（CLOB）中匹配时，系统只是在数据库里把这两笔订单画了个等号。真正的资产转移，需要 Operator 将双方的签名打包，提交到 Polygon 链上执行 TransferFrom。

这就产生了一个致命的时间差。在这个时间差里，用户的钱包状态可能会发生改变。

8.2 幽灵成交的两种攻击路径

在早期的 V1 和 V2 刚上线时，黑客和恶意做市商利用这个时间差，发明了两种极具破坏性的攻击手法：

• 第一种：低成本的 incrementNonce 攻击（V1 时代）

  在 V1 架构中，订单状态由一个全局的 nonce（随机数）管理。恶意玩家可以在链下疯狂挂出极具吸引力的假单（Spoofing）。当有真实的买家咬钩，订单在链下显示匹配后，恶意玩家抢在 Operator 提交上链前，直接在链上调用 incrementNonce 函数。

  这个操作成本极低（几美分 Gas），却能瞬间让该地址下所有旧 nonce 的订单全部失效。当 Operator 把匹配好的交易提交上链时，智能合约发现 nonce 不对，直接 Revert。攻击者全身而退，而真实的买家不仅错失了交易时机，还可能被虚假的盘口误导。

• 第二种：空钱包的“僵尸订单”（V2 早期）

  V2 升级移除了全局 nonce，改用单个订单 Hash 来管理取消状态，堵住了第一条路。但黑客很快发现了更底层的漏洞：余额欺骗。 一个恶意用户可以往钱包里充值 $1000，签署一堆总价值 $10000 的挂单放到订单簿上，然后立刻把钱包里的钱全部转走。 因为 Polymarket 的订单是离线签名的，只要签名有效、代币授权（Approval）没撤销，这些订单在链下撮合引擎看来就是“合法”的。但实际上，这个钱包的余额是 $0。

  当你的机器人吃掉了这些“僵尸订单”，Operator 提交上链时，底层调用的 Solady 库函数 TransferFrom 就会因为对方余额不足而报错（错误码 0x7939f424）。你的交易再次 Revert。

8.3 为什么传统交易所没有这个问题？

你可能会问：为什么币安或者传统的去中心化交易所（如 Uniswap）没有这个问题？

因为币安是纯中心化的，你的钱存在它的数据库里，它拥有绝对的控制权，撮合和扣款是原子性同时发生的。 而 Uniswap 是纯链上的，撮合和扣款都在一个智能合约的同一笔交易里完成，也是原子性的。

但 Polymarket 选择了混合架构：链下撮合追求极速，链上结算追求透明。而用户的资金存放在完全自托管的钱包（如 EOA 或 Gnosis Safe）中，用户拥有绝对的处置权，可以随时随地把钱转走。

只要撮合两端的资金状态与用户真正自由的自托管钱包挂钩，“状态割裂”就永远存在。

8.4 终极解决方案：Deposit Wallet（关联金库）

2026 年 5 月 4 日，Polymarket 官方宣布了一项核心协议级的重大更新，直接将幽灵成交的比例从巅峰期的 30% 降到了 0.17%，并趋近于零。

他们是怎么做到的？答案是引入了 Deposit Wallet（关联金库）。

Polymarket 终于意识到，解决幽灵成交的根本方法，是限制用户资金的“绝对自由”。 在新架构下，用户不能再直接用自己的原生钱包（EOA）参与链下撮合。你必须先将资金存入一个由智能合约控制的 Deposit Wallet。

在这个金库中：

• 你有所有权，但没有绝对的即时处置权。

• 当你在链下挂单时，金库会在逻辑上锁定相应的可用余额。

• 如果你想把钱从金库提走，这个提款操作（State Revocation）本身被赋予了物理时间成本。它必须经过智能合约的校验，确保你没有正在撮合中的未决订单。

通过引入这个缓冲层，Polymarket 强行把链下的撮合状态和链上的资金状态绑定在了一起，彻底消灭了“空钱包挂单”的可能性。这不仅是工程上的胜利，更是对去中心化金融中“自托管”与“交易效率”之间矛盾的一次深刻妥协与重构。

8.5 V2 的其他硬核升级

除了终极解决 Ghost Fill，V2 架构还包含了几个深刻改变市场格局的升级：

• pUSD 的权力交接：4 月 28 日，底层抵押物从 USDC.e 全面切换为 pUSD。这让 Polymarket 获得了底层资产的生息控制权，从而能够为用户提供高达 4.00% 的年化持仓奖励。pUSD 成为了新的资本效率基础设施。

• 完美公式 p(1-p) 的实装：抛弃了 V1 时代粗糙的 min(p, 1-p) 近似值，直接将手续费公式修改为完美的伯努利方差公式 p × (1-p)。数学上的绝对平滑，让套利者的定价模型更加精确。

• 拆除人为减速带：在早期，为了保护做市商免受 API 机器人的毒打，代码里硬编码了高达 500 毫秒的 Taker 延迟。随着 V2 引擎性能的提升和 Heartbeat（心跳）机制的引入（断联 10 秒即清空订单），官方在 2 月底彻底移除了这个人为减速带，宣告 Polymarket 正式进入微秒级的 HFT（高频交易）肉搏战。（这也是为什么我们 insiders.bot 准备在近期开源API，加入这场战斗）

结语：从0开始看透这台机器

从你点击下单的那一刻起：

• 你的签名被送入了链下的订单簿。

• Relayer 燃烧了它的 Gas 为你铺平了道路。

• Operator 在 COMPLEMENTARY、MINT 和 MERGE 中为你寻找最优的匹配路径。

• 手续费曲线用 p(1-p) 的优雅公式抽走了微小的摩擦成本。

• 如果你操作复杂，NegRiskAdapter 甚至会为你施展物质守恒的炼金术。

最终，一切都在那决定生死的 250毫秒 内尘埃落定。（这也是为什么 insiders.bot 把跟单的透明性和速度看的至关重要）

你的钱没有消失。它只是严格遵循着这台名为 ctf-exchange-v2 的精密机器的物理定律，流向了它该去的地方。

下次当你在 Polymarket 上看到一个离谱的赔率，或者一个诱人的套利机会时，不要急着点击 Buy。先在脑子里跑一遍这台机器的齿轮。

了解了这些基础的“法”，在配以正确的“道”，你必将战无不胜。

P.S 本文的PDF版也已经准备完毕。关注 @insidersdotbot 并 DM “PDF” 即可快速获取。

参考文献

[1] Polymarket Official Documentation: Matching Engine Restarts and Heartbeat Mechanism.

[2] Polymarket Official Documentation: Fees and p(1-p) Calculation Formula.

[3] Polymarket/ctf-exchange-v2 Smart Contract Source Code (GitHub).

[4] NegRiskAdapter.sol: Mathematical Implementation of Multi-outcome Conversions.

[5] leolabs.me: “Why Your Polymarket PnL is Wrong” (Split/Merge accounting analysis).

[6] Reddit r/algotrading & Binance Square: Polymarket Taker delay removal announcements (Feb 2026).

[7] Polymarket V2 Migration Guide: Transition from USDC.e to pUSD (April 2026).