3 张视图

Slop 计算公式

for pixel in 0..576:
  if α_rgba[pixel] != β_rgba[pixel]:
    mask[pixel/8] |= 1 << (7 - pixel%8)
    count++
slop = count                          // 0..576
slopLevel = count / 50                // 0..11 (展示用 bucket)

蒙版直接编码"哪些像素错了"，slop 是错的总数。合约不缓存，每次读 tokenURI 全部重算（24x24 = 576 个比较）。

关键数字

活跃平均 slop 高于初始 24.36 ——因为 merge 把低 slop 的 L0 都消耗了，剩下的活 NFT 包括 L1+ 的高 slop。Merge 经济学的副作用。

32 只完美渲染（slop = 0）

10,000 只里有 32 只模型渲染和原 Punk 完全一致。这些 NFT：

• void 后铸 0 SLOP（slop 数 = 0）
• 纯收藏价值，无 SLOP yield
• 合并后 embedding 偏移 → 不再完美 → 完美属性只在未合过的 L0里

看板「直接购买」tab → 最少 slop = 0 + 最多 slop = 0 → 列出当前挂单中的完美 slonks。

合成 Merge — N 只 NFT 凝成 1 张图

同等级两只合并：donor 永久销毁，survivor 升 1 级 + 拿到混合 embedding。不铸不烧 SLOP。

require: a.mergeLevel == b.mergeLevel
for i in 0..10:
  blended[i] = (int8)((int16(a.embedding[i]) + int16(b.embedding[i])) / 2)
  // 截断 toward zero（不是 floor）
survivor.embedding   = blended
survivor.mergeLevel += 1
burn(donor)
emit SlonkMerged(survivor, donor, donorSourceId, mergeLevel)

累加效应

升一级要烧 1 只同级。升 N 级 → 累计 2^N 只 NFT 的 embedding 都进了同一 survivor：

"几个 slop 对应一张图"的字面意义就是 merge。L7 survivor 是 128 只 NFT 各自的 slop / embedding 都被反复平均压进的 1 张图。survivor 的 sourceId 不变 → slop 永远 vs 那只锚定 Punk 算。

关键限制

• 必须严格同级（合约强制）：L0+L0、L1+L1...
• 需先 setApprovalForAll(MergeManager, true)（一次性，~50K gas）
• Merge 调用 ~100K gas
• 输出 slop 100% 确定性：合约模型直接算，不是估
• 付 gas 前可调 POST api.slonks.xyz/merge-preview 预览输出 slop
• 不铸不烧 SLOP — merge 只改 NFT，跟 SLOP 无关

Merge 经济：什么时候值？

本身 merge 不出 SLOP，但 survivor 的 slop 通常大于 donor + survivor 之和，所以未来 void 时 survivor 可铸更多 SLOP。

原始 2 只 L0 直接 void:
  slop_a + slop_b = 25 + 30 = 55 SLOP

合并后 L1 survivor 再 void:
  blended_slop ≈ 100-150 SLOP (典型)
  → 多铸 +50~100 SLOP，代价是少 1 只 NFT

例：L0+L0 平均 cost 0.30 ETH (≈$700)，输出 slop ≈ 130，break-even SLOP 价 ≈ $5.4。看板「合成捡漏」tab 实时算每对的 break-even。

实操注意（OpenSea / Blur）

• OpenSea：协议费 0%，creator royalty 按合约 ERC-2981 强制
• Blur：协议费 0%，royalty 默认 0%
• Slonks 主要在 OpenSea 流通，Blur 几乎无挂单
• Merge 后 OpenSea metadata 缓存旧图 → 必须手动 Refresh Metadata
• Merge Lab (slonks.xyz/merge-lab) 可视化预览，不消 gas

Void — NFT → $SLOP 的唯一通道

把 NFT 锁进 SlopGame 合约，提交模型证明 → 合约铸 SLOP 给 recipient。1 slop pixel = 1 $SLOP。

recipient = slopClaimRecipient[tokenId]   // 在 lockSlonk 时记录
slop      = countSlopPixels(verified_render, original_punk)
mint(recipient, slop * 1e18)
slopClaimed[tokenId] = true
addToVoidPool(tokenId)

三步流程

1. lockSlonk(tokenId) — 锁 NFT 进 SlopGame，记录你为 recipient
   17:30:23 UTC 前调会 revert VoidingNotOpen
2. (off-chain) 跑 ZK prover 生成 proof + publicInputs · slonks.xyz/void UI 自动跑（fallback：本地 CLI）
3. claimSlop(tokenId, proof, publicInputs) — 验证 proof 后铸 SLOP，token 进 void 池
   这步谁都能调，但 SLOP 只去给 lockSlonk 时记录的 recipient

中途想反悔可调 unlockSlonk(tokenId) 取回 NFT (claim 前都行，claim 后不可逆)。

为什么需要 ZK proof

合约不能信任「这个 NFT 当前 slop = X」的声明，因为模型在链外跑（链上跑 transformer 太贵 5-15M gas）。所以要求用户：

• 链下用 Noir 电路跑 model.render(embedding) → 拿到 576 个像素
• 生成 ZK proof：「这 576 像素是合约同款 model + 我的 embedding 的输出」
• 提交 proof + 像素到 claimSlop，合约调 verifier (0x5cbe9cbe...) 验证
• 合约信任了像素 → 数 slop → 铸 SLOP

链上 verify 仅 ~200K gas，比让合约自己跑 transformer 便宜 50-100×。这是 ZK 在 NFT 系统里的合理用法。

边界条件

• lockSlonk 时间锁：block.timestamp >= 1778175023 (= 2026-05-07 17:30:23 UTC)
• 每只 NFT 只能 claim 一次：slopClaimed[tokenId] 防双花
• 但 revival 后 slopClaimed 被清零，可以再次 void
• 铸量超 cap revert：SlopMintExceedsMaxSupply
• 0-slop NFT 也能 void → 铸 0 SLOP（无意义但合法）

Buy-and-void — 不铸 SLOP 的特殊路径

池子手续费攒成 ETH treasury，buyAndVoidSlonk(tokenId, target, value, data) 任何人能调：

• 用 treasury ETH 在 OS 买 1 只 NFT
• NFT 自动进 void 池（不调 lock，不需要 proof）
• 0 SLOP 铸造（关键）→ 系统层面 NFT 减少但 SLOP 不增 = 通缩
• 买入的 NFT 加入 revival 池，给烧 SLOP 的人抽

这是协议自动维护 SLOP 流通量 vs NFT 数量比例的机制。手续费持续把 ETH 转成"准备 revival 用的库存"。

Revival — 烧 $SLOP 抽 NFT

从 void 池里随机抽 1 只 NFT 给请求者，代价是烧当前 Dutch 价的 $SLOP。被抽中的 NFT embedding 全部重写，merge level 重置为 0。

require: voidedCount() >= 100   // 池子至少 100 只才开放
cost      = revivalCost()       // Dutch 当前价
require: cost <= maxCost       // 用户保护
burn(msg.sender, cost)          // 立即烧 SLOP
record requestRevival(...)
target_block  = block.number + 32       // 32 块后开抽
expiry_block  = target_block + 255      // 闲置过期

Dutch 拍卖价格曲线

dutchStart      = 576 $SLOP
elapsed_blocks  = block.number - lastRevivalRequestBlock
priceDrop       = floor(elapsed_blocks / 1)    // -1 SLOP / block (12s)
dutchPrice      = 576 - min(priceDrop, 476)
revivalCost     = max(100, dutchPrice)         // 地板 100

• 每个新 paid revival把价格拉回 576（reset on every buy）
• 从 576 跌到 100 需要 476 块 ≈ 95 分钟
• 同一时刻全局只允许 1 个 pending revival 请求（避免同质竞争）

抽签 + Embedding 重写

等过 32 块后调 finalizeRevival()（任何人都可以）：

seed       = keccak256(targetBlockHash, nonce, requester, gameAddr, chainId)
voidIndex  = seed % eligibleSlonkCount
tokenId    = voided_pool[voidIndex]

// 抽中的 token 的 embedding 重新生成
randomEmb  = random_int8[10]
sourceEmb  = imageModel.sourceEmbedding(tokenId.sourceId)
weight     = pick_weighted_bucket(seed)
new_emb    = blend(sourceEmb, randomEmb, weight)
transfer(tokenId, requester)

Embedding blend — 结果分布

期望平均 slop 接近源——多数 revival 出来的 NFT slop 不会暴涨。但 1% 概率出 400+ slop 的"宝箱"，烧 100 SLOP 抽到能 void 出 400 SLOP（净 +300）。这是 revival 的正期望来源。

身份保留 vs 重置

Revival 后 NFT 的状态：

开放条件 + 时间窗口

• Revival 第一次开放：void 池累计 ≥ 100 只 NFT
• 请求过期：发出后 32+255 = 287 块 ≈ 57 分钟
• 过期未 finalize：任何人可调 clearExpiredRequest() 清理（烧的 SLOP 不退）
• 下一笔新 request 必须先解决前一笔（finalize / 清过期）

能否爆出更多 SLOP？

• 新 embedding 的 slop 是 random（不可预测）
• 50% 接近源 punk：slop 跟原源差不多 → 大概率净亏 SLOP
• 1% 纯随机宝箱：embedding 完全偏离源 → 模型渲染差异大 → slop 大概率高（可达 400+）
• 抽中后立即 void → mint new_slop × 1 SLOP 给你
• 期望产出：~50-80 SLOP（接近 NFT 池子平均 slop）
• ⚠ 多数 revival slop 比烧的少 = 净亏 SLOP，但抽中 NFT 自身有 floor 价值兜底

价差分析使用方法（Revive tab 顶部价差卡片）

价差 = floor 卖出实收 USD − revival 烧 SLOP 的 USD 等价。

• 价差 正：revival 比直接买 floor NFT 便宜 → 即使抽到普通 NFT 立刻卖也赚（floor 兜底）
• 价差 负：直接买 floor 更便宜 → revival 仅在赌"抽到高 slop NFT 立刻 void 出更多 SLOP"时合理
• 纯赌 SLOP yield 时：break-even SLOP 价 = 烧 cost × P(SLOP) / 期望抽中 slop

→ 切到 Revive tab 看实时价差 + 历史

$SLOP 代币机制（链上验证）

• 合约 hard cap: 5,760,000 SLOP = 10000 × 576 像素 (合约 MAX_SUPPLY)
• Cap 检查: _mintCapped → totalSupply() + amount > MAX_SUPPLY revert
• LP 注入: 576,000 SLOP @ $50K MC = $0.0868 起始价（mintLaunchInventory 一次性铸造给 PoolHook）
• Void 解锁: 2026-05-07 17:30:23 UTC（链上 voidingStartsAt()）
• 1 slop pixel = 1 SLOP（void claim 后 mint(recipient, slop * 1e18)）
• Pool fee 1% → buy-and-void treasury（buyAndVoidEthAccrued 累积 ETH，定期买回 floor 进 void）

💡 完整手续费分类速查 → 切到 💸 手续费 sub-tab

Voiding (NFT → SLOP)

把 NFT 销毁换 $SLOP。流程：

1. 离线跑 ZK prover (slonks.xyz/void UI · fallback: CLI)
   输入: tokenId
   输出: zkProof（证明模型渲染了什么）
2. 提交 proof + tokenId 上链
3. 合约 verify proof，对照原 Punk
   → mint slop_count × SLOP 给你
   → NFT 进 void pool

为什么用 ZK：链上跑 transformer 太贵（5-15M gas）。证明计算转链下，验证留链上（只 ~200K gas）。

Revival (SLOP → NFT)

烧 $SLOP 从 void 仓库抽一只 NFT。Dutch auction 定价：

• 起价 576 SLOP
• 每个 block –1，地板 100 SLOP
• 32 blocks 后随机抽（避免抢跑）
• 抽到的 NFT 被赋新 embedding（slop 重算 → 通常变化）

💸 手续费总览（速查）

每笔操作的 fee / gas / 收款人。(链) 链上验证 · (平) 平台规则 (OS / Uniswap) · (白) 白皮书。

典型套利路径的总成本

给 EV 计算用的"实际总扣费"列表：

实测真值（链上 / OS API 验证）

• Slonks NFT 版税：5% 卖价（OS 标 required: true）→ recipient 0x6fe2397c…2241a0，已累计入金 ~102 ETH ↗
• OS 协议费：1%（required）→ 0x0000a26b…faa719
• NFT 卖家实收 = 卖价 × 94%。买家成本 = 卖价 × 1.0（OS 不在买家头上加 fee）。
• 链上 ERC-2981 royaltyInfo() 返回 (0x0, 0) — 不通过 ERC-2981 enforce。
• 真实 enforcement = OS UI 层强制 + CW-3 transferValidator 0x721c008f…42e3 (Limit Break V3 operator allowlist)。直接链上 EOA 间 transferFrom 不扣版税（不算 sale）。

套利数学

核心公式：

cost_USD     = price_ETH × ETH_USD
yield_USD    = slop × P(SLOP)
break-even   = cost_USD / slop = 你需要的 SLOP 价

看板把所有 listing/合成 pair 按 break-even 升序排列，最上面的 = 最早 +EV。

关键合约地址（链上真值）

Slonks ERC-721      0x832233ddB7bcFFD0eD53127DD6bE3F1Aa5845108  (immutable)
$SLOP Token (ERC-20) 0x999b49c0d1612e619a4a4f6280733184da025108  (immutable, capped 5.76M)
SlopGame (void/revival) 0xb4ffbcce990a9a0b5f84722ba2d5db4e7bfc9d11  (mint authority)
PoolHook (Uniswap V4) 0xb89348ed102f4051c162df24748281c54014e34c
ZK Verifier         0x5cbe9cbedc27dd4f082119586f5d924645064eb3
Hirsch deployer     0x0dc1dd32b1300818c977ce5a36a464a5c0c14550  (owner, NOT renounced)
CryptoPunksData ext 0x16f5a35647d6f03d5d3da7b35409d65ba03af3b2  (sealed)

🔒 去信任化健康度（链上真值 · 每 5 分钟刷新）