Polymarket_data: replace gap_supplement from repo hf_push only

gap_supplement/GAP_DATASET_README.md

@@ -0,0 +1,40 @@
+# Polymarket_data_fixed — gap_supplement 说明
+
+**源码与上传物均来自本 Git 仓库 `Polymarket_data`（路径 `hf_push/gap_supplement/`），不包含其他项目目录。**
+
+## 本目录内容
+
+| 文件 | 说明 |
+|------|------|
+| `trades_fix_gap.parquet` | 全量 `gap_*.parquet` → `extract_trades` + 四键去重 |
+| `quant_fix_gap.parquet` | `clean_trades_df` |
+| `users_fix_gap.parquet` | `clean_users_df` |
+| `gap_full_pipeline_report.json` | 逐文件统计 |
+| `MERGE_GAP_SKILL.md` | 与基线 parquet 合并教程 |
+| `code/` | `scripts/gap_recovery/` 内相关脚本快照 |
+
+## 当前生成统计
+
+- 非空 gap 文件：**565**  
+- OrderFilled 行：**1,435,481**  
+- Trades：去重前 1,435,481 → **9,302,609**（去重 60,889）  
+- Quant：**5,719,281**；Users：**11,438,562**  
+- markets 映射：**是** `/home/dev/poly_data/huggingface_data/raw/markets.parquet`
+
+## HF 相邻块「小空洞」2～50 缺失区块
+
+- 脚本：`code/verify_hf_orderfilled_gaps_2_50_duckdb.py`，汇总见 poly_data 下 `data/hf_orderfilled_gaps_2_50_summary.json`。  
+- **区间总数约 1,017,230**（统计对象为空档段，非本目录单文件）。  
+- `--rpc-sample N` 为**随机抽检**，**不保证**小空档内 100% 无遗漏。  
+
+## detected_gaps 大区间的链上补救
+
+- 脚本：`code/run_recent_recovery_parallel.py`：初始终批次 **50** 区块 `eth_getLogs`，成功扩大至最多 **100**；失败则 **÷5** 细分重试；单块失败记入 `permanently_failed_blocks.txt` 并前进；多节点轮换与超时见源码。  
+- 与 `MIN_BLOCK`～`MAX_BLOCK` 相交的待补区间共 **322** 段，跨度均 **≥50**；**本批 parquet 对应这些区间的汇总**，未对全部小空洞逐段补链上。
+
+## 合并基线
+
+见 `MERGE_GAP_SKILL.md`。
+
+---
+*由 `scripts/gap_recovery/prepare_hf_gap_bundle.py` 生成/更新。*

gap_supplement/GAP_SUPPLEMENT_README.md

@@ -0,0 +1,27 @@
+# Gap 全量补充（trades_fix_gap / quant_fix_gap / users_fix_gap）
+
+## 背景
+
+本地 `data/recovered_chunks/gap_*.parquet` 为链上 `OrderFilled` 解码结果（与仓库 `format_batch` 列集一致），用于补足上游 orderfilled 稀疏或未收录的区块。
+
+## 处理流程（与 Polymarket_data 仓库一致）
+
+1. 合并全部非空 gap 文件；逐文件调用 `extract_trades`（控制内存），再按四键去重。
+2. 可选 `load_token_mapping(markets.parquet)` 填充 `market_id` / `condition_id` / `event_*` 等。
+3. `clean_trades_df` → quant；`clean_users_df` → users。
+4. 去重键：`(timestamp, transaction_hash, maker, taker)`。
+
+## 使用
+
+```bash
+# 全量（默认 markets 见 huggingface_data/raw/markets.parquet）
+python3 update_utils/gap_sample_to_trades_quant_users_hf.py
+
+# 仅上传已生成 staging
+export HF_TOKEN=...
+python3 update_utils/gap_sample_to_trades_quant_users_hf.py --upload-only
+```
+
+## 与全量 HF raw 合并
+
+将本目录 parquet 与全量 `trades.parquet` 纵向合并后按四键去重，再全量重建 quant/users。

gap_supplement/MERGE_GAP_SKILL.md

@@ -0,0 +1,131 @@
+---
+
+name: polymarket-gap-merge-parquet
+description: 将 gap 补充 parquet 与 poly_data 下 huggingface_data/raw 全量 trades/quant/users 合并（DuckDB；含内存与分块策略）。
+
+---
+
+# Polymarket gap 与基线 parquet 合并
+
+## 路径约定
+
+- **Gap**：`$POLY_ROOT/data/hf_gap_push_staging/trades_fix_gap.parquet`（或 `Polymarket_data/hf_push/gap_supplement/` 下同名文件）。
+- **基线**：`$POLY_ROOT/huggingface_data/raw/trades.parquet`（约 **37GiB** 压缩、**~5.69e8** 行；与 gap 列不完全一致，合并时只用**两表共有列**）。
+- **去重键**：`(timestamp, transaction_hash, maker, taker)` — 先 `CAST(timestamp AS BIGINT)`、`lower()` 规范化地址与哈希。
+
+
+### 验证 `*fix_gap.parquet` 是否含元数据 3-50 档分片
+
+对 `hf_orderfilled_gaps_2_50_intervals.parquet` 中 `missing_block_cnt`∈[3,50] 所映到之分片，随机重放 `extract_trades` 后检查四键是否**全部**出现在 `trades_fix_gap.parquet` 中（与管线一致）：
+
+```bash
+export POLY_ROOT=/path/to/poly_data
+cd /path/to/Polymarket_data
+python3 scripts/gap_recovery/verify_fix_gap_3_50.py --trades /path/to/trades_fix_gap.parquet --min-mc 3 --max-mc 50 --sample-paths 50
+# 默认还写: $POLY_ROOT/data/hf_merge_exec/verify_fix_gap_3_50_report.json
+# 退出码 0：四键在 merged 中全部命中(抽样)；1：未通过或表为空
+```
+
+脚本会读 merged 的**块号窗**，只在 `gap_低_高` 与窗**有交集**的 3-50 分片里做非空池+抽样，避免低块分片与仅含高块区 merged 的假阴性；并对 merged 自抽样做 `ANTI JOIN` 自洽检查。
+
+---
+
+## 内存与实测（本机 DuckDB 合并）
+
+使用仓库内脚本（仅测合并逻辑，**非**全量基线）：
+
+```bash
+cd /path/to/Polymarket_data
+# 小样本：基线 20 万行（block>=84000000）+ gap 50 万行，约 18s，进程 RSS 峰值约 1.3GiB
+python3 scripts/gap_recovery/test_merge_trades_memory.py \
+  --base-sample-rows 200000 --base-min-block 84000000 --gap-limit 500000 \
+  --memory-limit 12GB --threads 4
+
+# 大样本：同上基线子集 + **全量 gap（约 794 万行）**，约 96s，进程 RSS 峰值约 **8.5GiB**（`/usr/bin/time -v` 与 `ru_maxrss` 同量级）
+python3 scripts/gap_recovery/test_merge_trades_memory.py \
+  --base-sample-rows 200000 --base-min-block 84000000 --gap-limit 0 \
+  --memory-limit 16GB --threads 4
+```
+
+**结论（重要）**：
+
+| 场景 | 量级 | 观测峰值 RSS（量级） |
+|------|------|------------------------|
+| 基线子集 + gap 50 万 | ~0.7M 行去重后 | **~1.3GiB** |
+| 基线子集 + **全量 gap** | ~8.1M 行去重后 | **~8.5GiB** |
+| **全量基线 + 全量 gap** | ~5.76e8 行 | **不可**按上表线性外推；`ROW_NUMBER` 分区去重在亿级行上会触发大量 **外排/落盘**，需 **大容量 NVMe `temp_directory`** 与 **高 `memory_limit`**，且单次失败成本高。 |
+
+**经验规则**：
+
+- 仅合并 **gap（约 800 万行）** 量级：建议 **≥16GiB** 可用 RAM + SSD `temp_directory`。
+- **整表 trades（约 5.7e8 行）+ gap 单次 UNION 去重**：建议 **≥64GiB RAM** 且 **`temp_directory` 预留 ≥200GiB 空闲**（与压缩比、重复率有关，仅量级估计）；否则采用下文**分块流式**策略。
+
+---
+
+## DuckDB 推荐 PRAGMA（全量前必设）
+
+```sql
+SET preserve_insertion_order=false;
+PRAGMA threads=4;              -- 可按 CPU 调整
+PRAGMA memory_limit='64GB';    -- 按机器内存酌减，过小会更多 spill、更慢
+PRAGMA temp_directory='/path/to/fast_ssd/duckdb_merge_tmp';
+```
+
+---
+## 单列集合对齐后的「单查询」合并（仅当资源足够时）
+
+两表**共有列**可用 Python/pyarrow 取交集（见 `test_merge_trades_memory.py`）。核心 SQL 结构：
+
+```sql
+COPY (
+  SELECT * EXCLUDE (_rn) FROM (
+    SELECT *, ROW_NUMBER() OVER (
+      PARTITION BY _ts, _tx, _mk, _tk ORDER BY _ts
+    ) AS _rn
+    FROM (
+      SELECT
+        CAST(CAST(timestamp AS VARCHAR) AS BIGINT) AS _ts,
+        lower(CAST(transaction_hash AS VARCHAR)) AS _tx,
+        lower(CAST(maker AS VARCHAR)) AS _mk,
+        lower(CAST(taker AS VARCHAR)) AS _tk,
+        <共有列逗号分隔>
+      FROM read_parquet('trades.parquet')
+      UNION ALL
+      SELECT ...同上... FROM read_parquet('trades_fix_gap.parquet')
+    ) u
+  ) x WHERE _rn = 1
+) TO 'trades_merged.parquet' (FORMAT PARQUET, COMPRESSION ZSTD);
+```
+
+校验后同目录 `mv trades_merged.parquet trades.parquet`（先保留备份）。
+
+---
+
+## 内存不够时的策略：按区块分桶流式合并（推荐生产）
+
+思路：避免对 **5e8 行一次性** 做窗口去重。
+
+1. **列出 gap 涉及的 `block_number` 区间**（或 `transaction_hash` 集合）；通常 gap 仅占链上一小段。
+2. **将基线 trades 按 `block_number` 分桶**（例如每 200 万区块一批），对每一批：
+   - `base_i` = 该区块范围内的基线行；
+   - `gap_i` = gap 中落在该范围（或与该批 tx 有交集）的行；
+   - 在**批��**做 `UNION ALL` + `ROW_NUMBER` 去重（行数可控，内存可预期）；
+   - 将结果 **追加** 到 `trades_part_0001.parquet`… 或使用支持追加的写入器。
+3. **无 gap 覆盖的区块批**：可直接 **文件级拷贝/重命名** 或 `COPY (SELECT * FROM read_parquet(...) WHERE block BETWEEN ...) TO part`，无需与 gap 拼接。
+4. 最后用 **DuckDB `read_parquet([...])` 顺序扫描多 part** 写回单一 `trades.parquet`，或保留 **Hive 分区** 供 DuckDB/Polars 直接扫（分析端常更省事）。
+
+若仍 OOM：**再缩小每批 block 跨度** 或 **先按 `hash(transaction_hash)%K` 分片**（需二次校验边界）。
+
+---
+
+## quant / users
+
+- 行数远小于 trades 时，DuckDB 单次合并通常更轻；仍建议设置 `temp_directory`。
+- **列名不一致**（如 `address` vs `user`）须先 `SELECT` 对齐再 `UNION`。
+
+---
+
+## 相关脚本
+
+- `scripts/gap_recovery/test_merge_trades_memory.py` — 可复现实测与参数扫描。  
+- `scripts/gap_recovery/gap_to_trades_quant_users_hf.py` — 生成 gap 侧 parquet。

gap_supplement/code/build_merge_gap_3_50_complement.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+"""
+一键：区间表 [3,50] 为「小档分片集」；recovered 全量为全集；大档=全集减（按路径）小档的补集。分别打 staging 后 merge。
+
+不替换 huggingface_data/raw 全量基线；全量 + gap 的 DuckDB 合并在 docs/MERGE_GAP_SKILL.md。
+
+用法:
+  export POLY_ROOT=/path/to/poly_data
+  cd /path/to/Polymarket_data && python3 scripts/gap_recovery/build_merge_gap_3_50_complement.py
+
+[3,5] 小档 + 大档(补集) 或现成大档 staging 示例:
+  # 仅小档 3-5 元数据 + 大档=recovered 除去小档路径
+  ... --min-mc 3 --max-mc 5
+
+  # 小档 3-5 新生成 + 大档用历史目录（如「50+ 已跑过」的 trades/quant/users）:
+  ... --min-mc 3 --max-mc 5 --other-staging /path/to/staging_gt50
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pyarrow.parquet as pq
+
+REPO = Path(__file__).resolve().parents[2]
+POLY = Path(os.environ.get("POLY_ROOT", str(REPO.parent / "poly_data")))
+SCR = REPO / "scripts" / "gap_recovery"
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--interval-table",
+        type=Path,
+        default=POLY / "data" / "hf_orderfilled_gaps_2_50_intervals.parquet",
+    )
+    ap.add_argument("--min-mc", type=int, default=3)
+    ap.add_argument("--max-mc", type=int, default=50)
+    ap.add_argument(
+        "--out-base",
+        type=Path,
+        default=POLY / "data" / "hf_gap_merged_bands",
+    )
+    ap.add_argument(
+        "--other-staging",
+        type=Path,
+        default=None,
+        help="若已有一份「大档/50+ 历史」staging（含 trades_fix_gap/quant_fix_gap/users_fix_gap），"
+        "则不再从 recovered 补集重算大档，直接与「小档」按 merge 合并去重。",
+    )
+    ap.add_argument(
+        "--install-gap-supplement",
+        action="store_true",
+        help="合并后复制到本仓库 Polymarket_data/hf_push/gap_supplement/ 并运行 prepare_hf_gap_bundle.py",
+    )
+    ap.add_argument(
+        "--no-hf-sync",
+        action="store_true",
+        help="与 --install-gap-supplement 联用时：只拷文件+README，不调用 hf_sync（需自管 HF 上传）",
+    )
+    ap.add_argument(
+        "--install-hf-raw",
+        action="store_true",
+        help="合并完成后将 st_merged 的 trades/quant/users 以 trades.parquet 等名**覆盖**到 "
+        "POLY_ROOT/huggingface_data/raw/（**仅**在环境变量 POLY_I_CONFIRM_OVERWRITE_HF_RAW=1 时执行，且先备份旧文件到 raw/.backup_gap_merge_* ）",
+    )
+    ap.add_argument(
+        "--path-limit",
+        type=int,
+        default=0,
+        help=">0 时小档分片只处理前 N 个（调通合并/HF 用）；0 为全量小档。",
+    )
+    args = ap.parse_args()
+    it = args.interval_table
+    if not it.is_absolute():
+        it = (POLY / str(it).lstrip("./")).resolve()
+    if not it.is_file():
+        print(f"未找到 {it}", flush=True)
+        return 1
+
+    sys.path[:0] = [str(REPO), str(SCR)]
+    from gap_interval_paths import all_recovered_parquet_paths, complement_paths, gather_paths_for_mc_range  # noqa: WPS433
+    from gap_to_trades_quant_users_hf import run_gap_to_staging  # noqa: WPS433
+    from merge_gap_staging_pair import merge_staging_pair  # noqa: WPS433
+
+    chunks = POLY / "data" / "recovered_chunks"
+    if not chunks.is_dir():
+        print(f"无目录 {chunks}", flush=True)
+        return 1
+    allp = all_recovered_parquet_paths(chunks)
+    if not allp:
+        print("recovered 下无分片", flush=True)
+        return 2
+    small = gather_paths_for_mc_range(POLY, it, args.min_mc, args.max_mc)
+    if not small:
+        print("小档列表为空，中止", flush=True)
+        return 3
+    if int(args.path_limit) > 0:
+        n0 = len(small)
+        lim = int(args.path_limit)
+        picked: list[Path] = []
+        for p in small:
+            if len(picked) >= lim:
+                break
+            if not p.is_file():
+                continue
+            try:
+                if int(pq.read_metadata(p).num_rows) < 1:
+                    continue
+            except OSError:
+                continue
+            picked.append(p)
+        small = picked
+        print(f"--path-limit {lim}: 小档 {n0} 条路径 → 收满 {len(small)} 个**非空**分片", flush=True)
+        if not small:
+            print("path-limit 下无非空小档分片, 中止", flush=True)
+            return 3
+    oth: Path | None = args.other_staging
+    if oth is not None and not oth.is_absolute():
+        oth = (POLY / str(oth).lstrip("./")).resolve()
+    if oth is not None and not oth.is_dir():
+        print(f"未找到 --other-staging 目录: {oth}", flush=True)
+        return 4
+
+    if oth is not None:
+        for name in ("trades_fix_gap.parquet", "quant_fix_gap.parquet", "users_fix_gap.parquet"):
+            if not (oth / name).is_file():
+                print(f"other-staging 缺文件: {oth / name}", flush=True)
+                return 5
+        print(f"大档使用现成 staging: {oth}（不扫 recovered 补集）", flush=True)
+    else:
+        large = complement_paths(allp, small)
+        print(
+            f"小档 mc∈[{args.min_mc},{args.max_mc}]: {len(small)} 个; 全量 {len(allp)}; 大档(补集) {len(large)}",
+            flush=True,
+        )
+
+    base = args.out_base
+    d_small = base / "st_small"
+    d_large = base / "st_large"
+    d_merged = base / "st_merged"
+    d_small.mkdir(parents=True, exist_ok=True)
+    d_merged.mkdir(parents=True, exist_ok=True)
+    if oth is None:
+        d_large.mkdir(parents=True, exist_ok=True)
+
+    mkp = POLY / "huggingface_data" / "raw" / "markets.parquet"
+
+    run_gap_to_staging(
+        None,
+        mkp if mkp.is_file() else None,
+        d_small,
+        str(chunks / "gap_*.parquet"),
+        small,
+    )
+
+    if oth is not None:
+        rc = merge_staging_pair(d_small, oth, d_merged)
+        if rc != 0:
+            return rc
+        _write_merged_pipeline_report(d_merged, d_small, oth, "other_staging", args)
+        if args.install_hf_raw:
+            r0 = _install_merged_to_huggingface_raw(d_merged, POLY)
+            if r0 != 0:
+                return r0
+        if args.install_gap_supplement:
+            return _install_gap_supplement(d_merged, not args.no_hf_sync)
+        return 0
+
+    if not large:
+        for name in ("trades_fix_gap.parquet", "quant_fix_gap.parquet", "users_fix_gap.parquet"):
+            s = d_small / name
+            if s.is_file():
+                shutil.copy2(s, d_merged / name)
+        print("大档为 0：已将小档复制到 st_merged", flush=True)
+        if (d_small / "gap_full_pipeline_report.json").is_file():
+            shutil.copy2(d_small / "gap_full_pipeline_report.json", d_merged / "gap_full_pipeline_report.json")
+        if args.install_hf_raw:
+            r0 = _install_merged_to_huggingface_raw(d_merged, POLY)
+            if r0 != 0:
+                return r0
+        if args.install_gap_supplement:
+            return _install_gap_supplement(
+                d_merged, not args.no_hf_sync
+            )
+        return 0
+
+    run_gap_to_staging(
+        None,
+        mkp if mkp.is_file() else None,
+        d_large,
+        str(chunks / "gap_*.parquet"),
+        large,
+    )
+    rc = merge_staging_pair(d_small, d_large, d_merged)
+    if rc != 0:
+        return rc
+    _write_merged_pipeline_report(d_merged, d_small, d_large, "complement_recovered", args)
+    if args.install_hf_raw:
+        r0 = _install_merged_to_huggingface_raw(d_merged, POLY)
+        if r0 != 0:
+            return r0
+    if args.install_gap_supplement:
+        return _install_gap_supplement(d_merged, not args.no_hf_sync)
+    return 0
+
+
+def _write_merged_pipeline_report(
+    merged: Path,
+    small: Path,
+    other: Path,
+    other_kind: str,
+    args: argparse.Namespace,
+) -> None:
+    """在 st_merged 写 gap_full_pipeline_report.json，供 prepare_hf_gap_bundle 使用。"""
+    base: dict = {
+        "mode": "build_merge_3_50",
+        "merge_kind": other_kind,
+        "min_mc": args.min_mc,
+        "max_mc": args.max_mc,
+        "other_staging": str(other) if other_kind == "other_staging" else str(other),
+        "merged_dir": str(merged),
+    }
+    sf = small / "gap_full_pipeline_report.json"
+    if sf.is_file():
+        try:
+            sm = json.loads(sf.read_text(encoding="utf-8"))
+            base["small_staging_report"] = sm
+            for k in (
+                "gap_files",
+                "gap_event_rows",
+                "trades_rows_before_dedupe",
+                "trades_dedupe_removed",
+                "markets_parquet",
+                "markets_mapping_used",
+            ):
+                if k in sm:
+                    base[k] = sm[k]
+        except (OSError, json.JSONDecodeError):
+            pass
+    mt = merged / "merge_gap_staging_pair_report.txt"
+    if mt.is_file():
+        try:
+            base["merge_text_report"] = mt.read_text(encoding="utf-8")[:4000]
+        except OSError:
+            pass
+    for label, name in (
+        ("trades_rows", "trades_fix_gap.parquet"),
+        ("quant_rows", "quant_fix_gap.parquet"),
+        ("users_rows", "users_fix_gap.parquet"),
+    ):
+        p = merged / name
+        if p.is_file():
+            base[label] = int(pq.read_metadata(p).num_rows)
+    (merged / "gap_full_pipeline_report.json").write_text(
+        json.dumps(base, indent=2, ensure_ascii=False, default=str),
+        encoding="utf-8",
+    )
+    (merged / "gap_merged_composite_report.json").write_text(
+        json.dumps(base, indent=2, ensure_ascii=False, default=str),
+        encoding="utf-8",
+    )
+
+
+def _install_merged_to_huggingface_raw(merged: Path, poly: Path) -> int:
+    """
+    用合并后的 trades_fix_gap/quant_fix_gap/users_fix_gap **覆盖** huggingface_data/raw 下
+    trades.parquet / quant.parquet / users.parquet。
+    危险操作：需 POLY_I_CONFIRM_OVERWRITE_HF_RAW=1。
+    """
+    if (os.environ.get("POLY_I_CONFIRM_OVERWRITE_HF_RAW", "").strip() not in ("1", "true", "yes")):
+        print("跳过 --install-hf-raw：未设置 POLY_I_CONFIRM_OVERWRITE_HF_RAW=1", flush=True)
+        return 0
+    raw = poly / "huggingface_data" / "raw"
+    if not raw.is_dir():
+        print(f"无目录 {raw}", flush=True)
+        return 1
+    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    bak = raw / f".backup_gap_merge_{ts}"
+    bak.mkdir(parents=True, exist_ok=True)
+    mapping = (
+        ("trades_fix_gap.parquet", "trades.parquet"),
+        ("quant_fix_gap.parquet", "quant.parquet"),
+        ("users_fix_gap.parquet", "users.parquet"),
+    )
+    for src_n, dst_n in mapping:
+        s = merged / src_n
+        d = raw / dst_n
+        if not s.is_file():
+            print(f"缺少合并产物: {s}", flush=True)
+            return 1
+        if d.is_file():
+            shutil.copy2(d, bak / dst_n)
+            print(f"已备份 {d} -> {bak / dst_n}", flush=True)
+        shutil.copy2(s, d)
+        print(f"已写入 {d} <- {s}", flush=True)
+    (bak / "README.txt").write_text(
+        f"由 build_merge_gap_3_50_complement --install-hf-raw 在 UTC {ts} 前备份。恢复: cp {bak}/* .",
+        encoding="utf-8",
+    )
+    return 0
+
+
+def _install_gap_supplement(merged: Path, publish_hf: bool) -> int:
+    sup = REPO / "hf_push" / "gap_supplement"
+    sup.mkdir(parents=True, exist_ok=True)
+    for n in (
+        "trades_fix_gap.parquet",
+        "quant_fix_gap.parquet",
+        "users_fix_gap.parquet",
+    ):
+        p = merged / n
+        if p.is_file():
+            shutil.copy2(p, sup / n)
+    for n in ("gap_full_pipeline_report.json", "gap_merged_composite_report.json", "merge_gap_staging_pair_report.txt"):
+        p = merged / n
+        if p.is_file():
+            shutil.copy2(p, sup / n)
+    prep = REPO / "scripts" / "gap_recovery" / "prepare_hf_gap_bundle.py"
+    r = subprocess.run(
+        [sys.executable, str(prep)],
+        cwd=str(REPO),
+    )
+    if r.returncode != 0:
+        return r.returncode
+    if not publish_hf:
+        print("已写 hf_push/gap_supplement；未推送（--no-hf-sync）", flush=True)
+        return 0
+    sync = REPO / "scripts" / "gap_recovery" / "hf_sync_gap_dataset.py"
+    s = subprocess.run(
+        [sys.executable, str(sync)],
+        cwd=str(REPO),
+        env=os.environ.copy(),
+    )
+    return s.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gap_supplement/code/build_trades_supplement_from_gap_parquets.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+将本地补充的 gap_*.parquet（链上 OrderFilled 解码结果）转为 trades 表，并与 Polymarket_data 仓库约定对齐。
+
+目标
+- 校验列与仓库 decode 落盘格式一致（与 EventDecoder.format_batch / run_recent_recovery 一致）。
+- 使用仓库 polymarket.processors.trades.extract_trades 生成 trades。
+- 可选传入 markets.parquet 做 token 映射；可选与已有 trades.parquet 合并去重，为「无缺失 trades」打基础。
+
+输出默认
+- data/supplement/gap_derived_trades.parquet
+- data/supplement/gap_to_trades_report.json
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+REPO = Path(__file__).resolve().parents[2]
+POLY = Path(os.environ.get("POLY_ROOT", str(REPO.parent / "poly_data")))
+PROJ = REPO
+CHUNKS = POLY / "data" / "recovered_chunks"
+OUT_DIR = POLY / "data" / "supplement"
+OUT_TRADES = OUT_DIR / "gap_derived_trades.parquet"
+OUT_REPORT = OUT_DIR / "gap_to_trades_report.json"
+
+EXPECTED_ORDERFILLED_COLS = [
+    "transaction_hash",
+    "block_number",
+    "log_index",
+    "timestamp",
+    "contract",
+    "event_name",
+    "datetime",
+    "order_hash",
+    "maker",
+    "taker",
+    "maker_asset_id",
+    "taker_asset_id",
+    "maker_amount_filled",
+    "taker_amount_filled",
+    "maker_fee",
+    "taker_fee",
+    "protocol_fee",
+]
+
+TRADES_DEDUPE_KEYS = ["timestamp", "transaction_hash", "maker", "taker"]
+
+
+def _validate_columns(cols: list[str]) -> list[str]:
+    missing = [c for c in EXPECTED_ORDERFILLED_COLS if c not in cols]
+    extra = [c for c in cols if c not in EXPECTED_ORDERFILLED_COLS]
+    return missing, extra
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--gap-glob",
+        type=str,
+        default=str(CHUNKS / "gap_*.parquet"),
+        help="glob，默认 recovered_chunks 下全部 gap_*.parquet（含 gap_lack_remedy_*）",
+    )
+    ap.add_argument(
+        "--markets-parquet",
+        type=Path,
+        default=None,
+        help="可选：markets.parquet 路径，用于 load_token_mapping（与仓库 cli 一致）",
+    )
+    ap.add_argument(
+        "--merge-with",
+        type=Path,
+        default=None,
+        help="可选：已有 trades.parquet，与补充 trades 纵向合并后按四键去重",
+    )
+    ap.add_argument("--out-trades", type=Path, default=OUT_TRADES)
+    ap.add_argument(
+        "--max-files",
+        type=int,
+        default=0,
+        help="仅处理前 N 个 gap 文件（按路径排序，0=不限制）",
+    )
+    args = ap.parse_args()
+
+    sys.path.insert(0, str(PROJ))
+    from polymarket.processors.trades import extract_trades, load_token_mapping  # noqa: E402
+
+    import glob as glob_mod
+
+    glob_base = args.gap_glob
+    if not Path(glob_base).is_absolute():
+        glob_base = str((POLY / glob_base.lstrip("./")).resolve())
+    paths = sorted(Path(p) for p in glob_mod.glob(glob_base))
+    paths = [p for p in paths if p.is_file()]
+    if not paths:
+        print(f"未匹配到 parquet: {glob_base}", flush=True)
+        return 1
+    paths_nonempty = [p for p in paths if pq.read_metadata(p).num_rows > 0]
+    if args.max_files and args.max_files > 0:
+        paths_nonempty = paths_nonempty[: args.max_files]
+    if not paths_nonempty:
+        print("所选 glob 下无非空 parquet", flush=True)
+        return 1
+
+    per_file = []
+    all_parts: list[pd.DataFrame] = []
+    for p in paths_nonempty:
+        t = pq.read_table(p)
+        cols = list(t.column_names)
+        miss, extra = _validate_columns(cols)
+        per_file.append({"path": str(p), "rows": t.num_rows, "missing_cols": miss, "extra_cols": extra})
+        if miss:
+            print(f"列缺失 {p.name}: {miss}", flush=True)
+            return 2
+        all_parts.append(t.to_pandas())
+
+    gap_df = pd.concat(all_parts, ignore_index=True)
+    events = gap_df.to_dict("records")
+    token_map = load_token_mapping(args.markets_parquet) if args.markets_parquet else None
+    trades_df = extract_trades(events, token_map)
+    if trades_df.empty:
+        print("extract_trades 结果为空", flush=True)
+        return 3
+
+    before = len(trades_df)
+    trades_df = trades_df.drop_duplicates(subset=TRADES_DEDUPE_KEYS, keep="first")
+    deduped = before - len(trades_df)
+
+    merge_info: dict = {}
+    out_final = trades_df
+    if args.merge_with and args.merge_with.is_file():
+        base = pd.read_parquet(args.merge_with, engine="pyarrow")
+        out_final = pd.concat([base, trades_df], ignore_index=True)
+        m0 = len(out_final)
+        out_final = out_final.drop_duplicates(subset=TRADES_DEDUPE_KEYS, keep="first")
+        merge_info = {
+            "base_rows": len(base),
+            "supplement_rows_before_merge": len(trades_df),
+            "concat_rows": m0,
+            "rows_after_dedupe": len(out_final),
+            "merge_source": str(args.merge_with),
+        }
+
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+    args.out_trades.parent.mkdir(parents=True, exist_ok=True)
+    table = pa.Table.from_pandas(out_final, preserve_index=False)
+    pq.write_table(table, args.out_trades, compression="zstd")
+
+    report = {
+        "repo_polymarket_data": str(PROJ),
+        "expected_orderfilled_columns": EXPECTED_ORDERFILLED_COLS,
+        "gap_files_in_glob": len(paths),
+        "gap_files_processed_nonempty": len(paths_nonempty),
+        "gap_event_rows": len(gap_df),
+        "trades_rows_extract": before,
+        "trades_dedupe_removed_same_four_keys": deduped,
+        "trades_rows_after_internal_dedupe": len(trades_df),
+        "output_trades_parquet": str(args.out_trades),
+        "trades_columns": list(out_final.columns),
+        "per_gap_file": per_file,
+        "merge": merge_info or None,
+        "next_steps": (
+            "若需 market_id 等字段完整：提供 --markets-parquet；"
+            "与全量 HF/本地 trades 合并：--merge-with <trades.parquet>；"
+            "合并后仍缺：继续用 Goldsky/RPC 补 orderfilled 再跑本脚本。"
+        ),
+    }
+    OUT_REPORT.write_text(json.dumps(report, indent=2, ensure_ascii=False, default=str), encoding="utf-8")
+    print(json.dumps({k: v for k, v in report.items() if k != "per_gap_file"}, indent=2, ensure_ascii=False))
+    print(f"\n明细 per 文件: {OUT_REPORT}", flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gap_supplement/code/gap_interval_paths.py

@@ -0,0 +1,92 @@
+"""
+根据 hf_orderfilled_gaps_2_50_intervals.parquet（及子档）与主链块窗，解析
+recovered_chunks/gap_*.parquet 路径集合；并计算全量分片减子集后的补集。
+"""
+from __future__ import annotations
+
+import os
+import glob
+from pathlib import Path
+
+import duckdb
+
+
+# 与 gap 回补/校验常用主链分析窗一致；可通过环境覆盖
+DEFAULT_MIN_BLOCK = int(os.environ.get("POLY_GAP_HF_MIN_BLOCK", "70229300"))
+DEFAULT_MAX_BLOCK = int(os.environ.get("POLY_GAP_HF_MAX_BLOCK", "84923445"))
+
+
+def _clip_interval(gs: int, ge: int, min_b: int, max_b: int) -> tuple[int, int] | None:
+    a = max(gs, min_b)
+    b = min(ge, max_b)
+    if a > b:
+        return None
+    return a, b
+
+
+def path_for_clipped(mapped_a: int, mapped_b: int, chunks: Path) -> Path:
+    return chunks / f"gap_{mapped_a}_{mapped_b}.parquet"
+
+
+def gather_paths_for_mc_range(
+    poly_root: Path,
+    table_parquet: Path,
+    min_mc: int,
+    max_mc: int,
+    *,
+    min_block: int = DEFAULT_MIN_BLOCK,
+    max_block: int = DEFAULT_MAX_BLOCK,
+) -> list[Path]:
+    """
+    从区间表选 missing_block_cnt in [min_mc, max_mc]，裁剪到 [min_block,max_block] 后
+    映射到 data/recovered_chunks/gap_*.parquet 路径（去重、仅已存在、非 0 字节由调用方可筛）。
+    """
+    chunks = poly_root / "data" / "recovered_chunks"
+    t = str(table_parquet).replace("'", "''")
+    con = duckdb.connect()
+    rows: list[tuple] = con.execute(
+        f"""
+        SELECT gap_start, gap_end
+        FROM read_parquet('{t}')
+        WHERE missing_block_cnt BETWEEN {int(min_mc)} AND {int(max_mc)}
+          AND gap_end >= {int(min_block)} AND gap_start <= {int(max_block)}
+        """
+    ).fetchall()
+    out: list[Path] = []
+    seen: set[str] = set()
+    for gs, ge in rows:
+        c = _clip_interval(int(gs), int(ge), min_block, max_block)
+        if c is None:
+            continue
+        a, b = c
+        p = path_for_clipped(a, b, chunks)
+        k = p.resolve().as_posix()
+        if k in seen or not p.is_file():
+            continue
+        seen.add(k)
+        out.append(p)
+    return sorted(out, key=lambda x: x.as_posix())
+
+
+def all_recovered_parquet_paths(chunks: Path) -> list[Path]:
+    """data/recovered_chunks 下所有 gap_*.parquet 与 gap_lack_remedy_*.parquet（若存在）。"""
+    pats = (
+        str(chunks / "gap_*.parquet"),
+        str(chunks / "gap_lack_remedy_*.parquet"),
+    )
+    seen: set[str] = set()
+    out: list[Path] = []
+    for pat in pats:
+        for s in glob.glob(pat):
+            p = Path(s)
+            if p.is_file():
+                r = p.resolve().as_posix()
+                if r not in seen:
+                    seen.add(r)
+                    out.append(p)
+    return sorted(out, key=lambda x: x.as_posix())
+
+
+def complement_paths(all_paths: list[Path], selected: list[Path]) -> list[Path]:
+    sel = {p.resolve().as_posix() for p in selected}
+    return [p for p in all_paths if p.resolve().as_posix() not in sel]

gap_supplement/code/gap_to_trades_quant_users_hf.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""
+全量 gap_*.parquet → extract_trades → clean_trades_df / clean_users_df。
+
+本脚本位于 Polymarket_data 仓库内；默认从同级 poly_data/data/recovered_chunks 读 gap，
+输出到本仓库 hf_push/gap_supplement/（仅该目录用于 Hugging Face 数据集上传）。
+
+环境变量：POLY_ROOT — 指向 poly_data 根目录（含 data/、huggingface_data/）。
+"""
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import os
+import sys
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[2]
+POLY = Path(os.environ.get("POLY_ROOT", str(REPO.parent / "poly_data")))
+CHUNKS = POLY / "data" / "recovered_chunks"
+STAGING = REPO / "hf_push" / "gap_supplement"
+DEFAULT_MARKETS = POLY / "huggingface_data" / "raw" / "markets.parquet"
+DEFAULT_REPO = "wilsonwangwang/Polymarket_data_fixed"
+
+EXPECTED_ORDERFILLED_COLS = [
+    "transaction_hash",
+    "block_number",
+    "log_index",
+    "timestamp",
+    "contract",
+    "event_name",
+    "datetime",
+    "order_hash",
+    "maker",
+    "taker",
+    "maker_asset_id",
+    "taker_asset_id",
+    "maker_amount_filled",
+    "taker_amount_filled",
+    "maker_fee",
+    "taker_fee",
+    "protocol_fee",
+]
+
+TRADES_DEDUPE_KEYS = ["timestamp", "transaction_hash", "maker", "taker"]
+
+README_GAP = """# Gap 全量补充（trades_fix_gap / quant_fix_gap / users_fix_gap）
+
+见同目录上级 `GAP_DATASET_README.md`（由 `prepare_hf_gap_bundle.py` 生成）及仓库根目录 `docs/MERGE_GAP_SKILL.md`。
+"""
+
+REPORT_NAME = "gap_full_pipeline_report.json"
+LEGACY_STAGING_FILES = ("gap_sample_run_report.json", "validation_gap_vs_hf_raw.json")
+LEGACY_HF_FILES = ("gap_sample_run_report.json", "validation_gap_vs_hf_raw.json")
+
+UPLOAD_NAMES = [
+    "trades_fix_gap.parquet",
+    "quant_fix_gap.parquet",
+    "users_fix_gap.parquet",
+    "GAP_SUPPLEMENT_README.md",
+    REPORT_NAME,
+]
+
+
+def _hf_token() -> str | None:
+    return os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+
+
+def _cleanup_local_legacy(staging_dir: Path) -> None:
+    for name in LEGACY_STAGING_FILES:
+        p = staging_dir / name
+        if p.is_file():
+            p.unlink()
+
+
+def upload_gap_supplement(
+    staging_dir: Path,
+    repo_id: str,
+    repo_path_prefix: str,
+    delete_legacy_remote: bool,
+) -> int:
+    tok = _hf_token()
+    if not tok:
+        print("未设置 HF_TOKEN 或 HUGGING_FACE_HUB_TOKEN", flush=True)
+        return 4
+    try:
+        from huggingface_hub import HfApi  # noqa: PLC0415, WPS433
+    except ImportError:
+        print("请安装: pip install huggingface_hub", flush=True)
+        return 5
+    api = HfApi(token=tok)
+    prefix = repo_path_prefix.strip("/")
+    if delete_legacy_remote:
+        for legacy in LEGACY_HF_FILES:
+            remote = f"{prefix}/{legacy}" if prefix else legacy
+            try:
+                api.delete_file(path_in_repo=remote, repo_id=repo_id, repo_type="dataset")
+                print(f"deleted remote {remote}", flush=True)
+            except Exception as e:  # noqa: BLE001
+                print(f"skip delete {remote}: {e}", flush=True)
+    for name in UPLOAD_NAMES:
+        lp = staging_dir / name
+        if not lp.is_file():
+            print(f"缺少文件，跳过: {lp}", flush=True)
+            continue
+        remote = f"{prefix}/{name}" if prefix else name
+        api.upload_file(
+            path_or_fileobj=str(lp),
+            path_in_repo=remote,
+            repo_id=repo_id,
+            repo_type="dataset",
+            commit_message=f"Gap supplement (Polymarket_data repo only): {name}",
+        )
+        print(f"uploaded {remote}", flush=True)
+    return 0
+
+
+def _validate_columns(cols: list[str]) -> list[str]:
+    return [c for c in EXPECTED_ORDERFILLED_COLS if c not in cols]
+
+
+def run_gap_to_staging(
+    gap_parquet: str | None,
+    markets_parquet: Path | None,
+    staging_dir: Path,
+    gap_glob: str,
+    path_list: list[Path] | None = None,
+) -> dict:
+    import pandas as pd  # noqa: PLC0415
+    import pyarrow as pa  # noqa: PLC0415
+    import pyarrow.parquet as pq  # noqa: PLC0415
+
+    sys.path.insert(0, str(REPO))
+    from polymarket.processors.cleaner import clean_trades_df, clean_users_df  # noqa: E402, PLC0415
+    from polymarket.processors.trades import extract_trades, load_token_mapping  # noqa: E402, PLC0415
+
+    staging_dir.mkdir(parents=True, exist_ok=True)
+    _cleanup_local_legacy(staging_dir)
+
+    mk_path = markets_parquet
+    if mk_path is None and DEFAULT_MARKETS.is_file():
+        mk_path = DEFAULT_MARKETS
+    token_map = load_token_mapping(mk_path) if mk_path and mk_path.is_file() else None
+
+    per_file: list[dict] = []
+    trade_parts: list[pd.DataFrame] = []
+
+    if path_list is not None:
+        paths = list(path_list)
+        if not paths:
+            raise SystemExit("path_list 为空")
+        for p in paths:
+            if not p.is_file():
+                raise SystemExit(f"文件不存在: {p}")
+        paths = [p for p in paths if pq.read_metadata(p).num_rows > 0]
+        if not paths:
+            raise SystemExit("path_list 中无非空 gap parquet")
+    elif gap_parquet:
+        paths = [Path(gap_parquet)]
+        if not paths[0].is_file():
+            raise SystemExit(f"文件不存在: {paths[0]}")
+    else:
+        g = gap_glob if Path(gap_glob).is_absolute() else str((POLY / gap_glob.lstrip("./")).resolve())
+        paths = sorted(Path(p) for p in glob.glob(g) if Path(p).is_file())
+        paths = [p for p in paths if pq.read_metadata(p).num_rows > 0]
+        if not paths:
+            raise SystemExit(f"未找到非空 gap parquet: {g}")
+
+    for i, p in enumerate(paths):
+        t = pq.read_table(p)
+        cols = list(t.column_names)
+        miss = _validate_columns(cols)
+        per_file.append({"path": str(p), "rows": t.num_rows, "missing_cols": miss})
+        if miss:
+            raise SystemExit(f"列缺失 {p.name}: {miss}")
+        events = t.to_pandas().to_dict("records")
+        df = extract_trades(events, token_map)
+        per_file[-1]["trades_extracted"] = len(df)
+        if not df.empty:
+            trade_parts.append(df)
+        if (i + 1) % 20 == 0 or i + 1 == len(paths):
+            print(f"processed {i + 1}/{len(paths)} gap files", flush=True)
+
+    if not trade_parts:
+        raise SystemExit("extract_trades 全部为空")
+
+    trades_df = pd.concat(trade_parts, ignore_index=True)
+    before = len(trades_df)
+    trades_df = trades_df.drop_duplicates(subset=TRADES_DEDUPE_KEYS, keep="first")
+    deduped = before - len(trades_df)
+    _skeys = [c for c in ("timestamp", "transaction_hash", "order_hash") if c in trades_df.columns]
+    if _skeys:
+        trades_df = trades_df.sort_values(_skeys, kind="mergesort", ignore_index=True)
+
+    quant_df = clean_trades_df(trades_df)
+    users_df = clean_users_df(trades_df)
+
+    p_trades = staging_dir / "trades_fix_gap.parquet"
+    p_quant = staging_dir / "quant_fix_gap.parquet"
+    p_users = staging_dir / "users_fix_gap.parquet"
+    pq.write_table(pa.Table.from_pandas(trades_df, preserve_index=False), p_trades, compression="zstd")
+    pq.write_table(pa.Table.from_pandas(quant_df, preserve_index=False), p_quant, compression="zstd")
+    pq.write_table(pa.Table.from_pandas(users_df, preserve_index=False), p_users, compression="zstd")
+    (staging_dir / "GAP_SUPPLEMENT_README.md").write_text(README_GAP, encoding="utf-8")
+
+    gap_event_rows = sum(int(x["rows"]) for x in per_file)
+    if path_list is not None:
+        mode = "path_list"
+    else:
+        mode = "single_gap" if gap_parquet else "all_gaps"
+    rep_file = {
+        "mode": mode,
+        "repo_root": str(REPO),
+        "poly_root": str(POLY),
+        "gap_glob": gap_glob if not gap_parquet else None,
+        "gap_files": len(paths),
+        "gap_event_rows": gap_event_rows,
+        "trades_rows_before_dedupe": before,
+        "trades_dedupe_removed": deduped,
+        "trades_rows": len(trades_df),
+        "quant_rows": len(quant_df),
+        "users_rows": len(users_df),
+        "markets_parquet": str(mk_path) if mk_path else None,
+        "markets_mapping_used": bool(token_map),
+        "staging_dir": str(staging_dir),
+        "files": [str(p_trades), str(p_quant), str(p_users)],
+        "per_gap_file": per_file,
+    }
+    (staging_dir / REPORT_NAME).write_text(
+        json.dumps(rep_file, indent=2, ensure_ascii=False, default=str), encoding="utf-8"
+    )
+    rep_out = {k: v for k, v in rep_file.items() if k != "per_gap_file"}
+    rep_out["per_gap_file_count"] = len(per_file)
+    return rep_out
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--gap-parquet", type=str, default=None)
+    ap.add_argument("--gap-glob", type=str, default=str(CHUNKS / "gap_*.parquet"))
+    ap.add_argument("--markets-parquet", type=Path, default=None)
+    ap.add_argument("--staging-dir", type=Path, default=STAGING)
+    ap.add_argument("--push", action="store_true")
+    ap.add_argument("--upload-only", action="store_true")
+    ap.add_argument("--delete-legacy-hf", action="store_true")
+    ap.add_argument("--repo-id", type=str, default=DEFAULT_REPO)
+    ap.add_argument("--repo-path-prefix", type=str, default="gap_supplement")
+    ap.add_argument(
+        "--path-list-file",
+        type=Path,
+        default=None,
+        help="每行一个 gap parquet 绝对或相对 poly_data 的路径，替代 --gap-glob / --gap-parquet",
+    )
+    ap.add_argument(
+        "--hf-intervals-table",
+        type=Path,
+        default=None,
+        help="如 data/hf_orderfilled_gaps_2_50_intervals.parquet；与 --min-mc --max-mc 联用",
+    )
+    ap.add_argument("--min-mc", type=int, default=3, help="missing_block_cnt 下界")
+    ap.add_argument("--max-mc", type=int, default=50, help="missing_block_cnt 上界")
+    args = ap.parse_args()
+
+    if args.upload_only:
+        return upload_gap_supplement(
+            args.staging_dir, args.repo_id, args.repo_path_prefix, args.delete_legacy_hf
+        )
+
+    pls: list[Path] | None = None
+    if args.hf_intervals_table:
+        from gap_interval_paths import gather_paths_for_mc_range  # noqa: WPS433
+
+        pt = args.hf_intervals_table
+        if not Path(pt).is_absolute():
+            pt = (POLY / str(pt).lstrip("./")).resolve()
+        if not Path(pt).is_file():
+            raise SystemExit(f"未找到区间表: {pt}")
+        pls = gather_paths_for_mc_range(POLY, Path(pt), args.min_mc, args.max_mc)
+        if not pls:
+            raise SystemExit("hf-intervals 筛选后无已存在的 gap 分片（请确认回补与块窗）")
+    elif args.path_list_file is not None:
+        r0 = Path(args.path_list_file)
+        if r0.is_file():
+            lp = r0
+        else:
+            c0 = (POLY / str(args.path_list_file).lstrip("/")).resolve()
+            lp = c0 if c0.is_file() else (Path.cwd() / args.path_list_file).resolve()
+        if not lp.is_file():
+            raise SystemExit(f"未找到 path_list_file: {lp}")
+        lines = [x.strip() for x in lp.read_text(encoding="utf-8").splitlines() if x.strip()]
+        pls = []
+        for x in lines:
+            p = Path(x)
+            if not p.is_absolute():
+                p = (POLY / x.lstrip("./")).resolve()
+            if p.is_file():
+                pls.append(p)
+        if not pls:
+            raise SystemExit("path_list_file 中无已存在的文件路径")
+
+    rep = run_gap_to_staging(
+        args.gap_parquet,
+        args.markets_parquet,
+        args.staging_dir,
+        args.gap_glob,
+        pls,
+    )
+    print(json.dumps(rep, indent=2, ensure_ascii=False))
+    if rep.get("per_gap_file_count", 0) > 5:
+        print(f"\n(各 gap 文件明细见 {args.staging_dir / REPORT_NAME})", flush=True)
+
+    if args.push:
+        return upload_gap_supplement(
+            args.staging_dir, args.repo_id, args.repo_path_prefix, args.delete_legacy_hf
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gap_supplement/code/hf_gap_recovered_verification_report.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+对照 HF 空档区间 parquet 与 data/recovered_chunks/gap_{start}_{end}.parquet，
+写验证 JSON：统计 missing_block_cnt 在 [min, max] 的区间在本地是否已落盘及行数。
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+import polars as pl
+import pyarrow.parquet as pq
+
+MIN_BLOCK = 70229300
+MAX_BLOCK = 84923445
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(
+        description="验证 HF 区间与本地 gap_*.parquet 是否一致"
+    )
+    ap.add_argument("--min-missing", type=int, default=30)
+    ap.add_argument("--max-missing", type=int, default=50)
+    ap.add_argument(
+        "--intervals-file",
+        type=Path,
+        default=None,
+        help="默认: 10～30 用 10_30 子表（若存在），30～50 用 30_50，否则 2_50 全表",
+    )
+    ap.add_argument(
+        "--out",
+        type=Path,
+        default=None,
+        help="默认: data/hf_gap_{min}_{max}_recovered_verification.json",
+    )
+    ap.add_argument(
+        "--include-all-details",
+        action="store_true",
+        help="在 JSON 中写入每个区间的详情（区间很多时文件较大，默认只写缺文件列表）",
+    )
+    args = ap.parse_args()
+
+    repo = Path(__file__).resolve().parents[2]
+    poly = Path(os.environ.get("POLY_ROOT", str(repo.parent / "poly_data")))
+    data = poly / "data"
+    chunks = data / "recovered_chunks"
+    out_path = args.out
+    p0_5 = data / "hf_orderfilled_gaps_0_5_intervals.parquet"
+    p3_5 = data / "hf_orderfilled_gaps_3_5_intervals.parquet"
+    p5_10 = data / "hf_orderfilled_gaps_5_10_intervals.parquet"
+    p10_30 = data / "hf_orderfilled_gaps_10_30_intervals.parquet"
+    p30_50 = data / "hf_orderfilled_gaps_30_50_intervals.parquet"
+    p2 = data / "hf_orderfilled_gaps_2_50_intervals.parquet"
+    p = args.intervals_file
+    if p is None:
+        if p5_10.is_file() and args.min_missing >= 5 and args.max_missing <= 10:
+            p = p5_10
+        elif p3_5.is_file() and args.min_missing >= 3 and args.max_missing <= 5:
+            p = p3_5
+        elif p0_5.is_file() and 0 <= args.min_missing and args.max_missing <= 5:
+            p = p0_5
+        elif 10 <= args.min_missing and args.max_missing <= 30 and p10_30.is_file():
+            p = p10_30
+        elif args.min_missing >= 30 and p30_50.is_file() and args.max_missing >= 30:
+            p = p30_50
+        else:
+            p = p2
+    if out_path is None:
+        out_path = data / f"hf_gap_{args.min_missing}_{args.max_missing}_recovered_verification.json"
+    if not p.is_file():
+        print(f"未找到区间表: {p}，请先运行 verify_hf_orderfilled_gaps_2_50_duckdb.py", file=sys.stderr)
+        return 1
+
+    df = pl.read_parquet(p)
+    dff = df.filter(
+        pl.col("missing_block_cnt").is_between(
+            args.min_missing, args.max_missing
+        )
+    )
+    dff = dff.filter(
+        (pl.col("gap_end") >= MIN_BLOCK) & (pl.col("gap_start") <= MAX_BLOCK)
+    )
+
+    missing: list[dict] = []
+    present = 0
+    total_rows = 0
+    details: list[dict] = []
+    n = dff.height
+
+    for row in dff.iter_rows(named=True):
+        gs = int(row["gap_start"])
+        ge = int(row["gap_end"])
+        a = max(gs, MIN_BLOCK)
+        b = min(ge, MAX_BLOCK)
+        if a > b:
+            continue
+        gap_id = f"{a}_{b}"
+        cpath = chunks / f"gap_{gap_id}.parquet"
+        mcnt = int(row.get("missing_block_cnt", 0))
+        ex = cpath.is_file()
+        n_rows = 0
+        size_b = 0
+        if ex:
+            try:
+                size_b = cpath.stat().st_size
+                n_rows = pq.read_metadata(cpath).num_rows
+            except OSError as e:
+                rec_err = {
+                    "gap_start": a,
+                    "gap_end": b,
+                    "missing_block_cnt": mcnt,
+                    "chunk_path": str(cpath),
+                    "error": str(e),
+                }
+                missing.append(rec_err)
+                if args.include_all_details:
+                    err_detail = {**rec_err, "file_exists": False, "n_rows": 0, "chunk": cpath.name}
+                    del err_detail["error"]
+                    err_detail["io_error"] = str(e)
+                    details.append(err_detail)
+                continue
+            present += 1
+            total_rows += n_rows
+        else:
+            missing.append(
+                {
+                    "gap_start": a,
+                    "gap_end": b,
+                    "missing_block_cnt": mcnt,
+                    "chunk_path": str(cpath),
+                }
+            )
+        if args.include_all_details:
+            details.append(
+                {
+                    "gap_start": a,
+                    "gap_end": b,
+                    "missing_block_cnt": mcnt,
+                    "file_exists": ex and n_rows >= 0,
+                    "n_rows": n_rows,
+                    "size_bytes": size_b,
+                    "chunk": cpath.name,
+                }
+            )
+
+    report: dict = {
+        "source_intervals_parquet": str(p.resolve()),
+        "min_missing": args.min_missing,
+        "max_missing": args.max_missing,
+        "min_block": MIN_BLOCK,
+        "max_block": MAX_BLOCK,
+        "polymarket_root": str(poly),
+        "recovered_chunks_dir": str(chunks),
+        "intervals_matched": n,
+        "chunks_file_present": present,
+        "chunks_file_missing": len(missing),
+        "total_rows_in_present_chunks": total_rows,
+        "all_chunks_present": len(missing) == 0,
+        "missing_chunk_intervals": missing,
+    }
+    if args.include_all_details:
+        report["details"] = details
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(
+        json.dumps(report, indent=2, ensure_ascii=False, default=str), encoding="utf-8"
+    )
+    print(json.dumps({k: v for k, v in report.items() if k not in ("missing_chunk_intervals", "details")}, indent=2, ensure_ascii=False))
+    print(f"完整报告: {out_path}", flush=True)
+    if missing:
+        print(
+            f"仍缺 {len(missing)} 个 gap 文件。运行: "
+            f"python3 run_recent_recovery_parallel.py --use-hf-intervals "
+            f"--hf-missing-min {args.min_missing} --hf-missing-max {args.max_missing}",
+            flush=True,
+        )
+    return 0 if not missing else 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gap_supplement/code/hf_sync_gap_dataset.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+仅上传 Polymarket_data/hf_push/gap_supplement/ 至 Hugging Face 数据集（不触碰其他目录）。
+
+用法：
+  export HF_TOKEN=...
+  python3 scripts/gap_recovery/hf_sync_gap_dataset.py
+
+环境变量：
+  HF_REPO_ID  默认 wilsonwangwang/Polymarket_data_fixed
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[2]
+DEFAULT_BUNDLE = REPO / "hf_push" / "gap_supplement"
+DEFAULT_REPO = "wilsonwangwang/Polymarket_data_fixed"
+PREFIX = "gap_supplement"
+
+
+def _resolve_hf_token() -> str | None:
+    t = (os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN") or "").strip()
+    if t:
+        return t
+    p = Path.home() / ".huggingface" / "token"
+    if p.is_file():
+        try:
+            x = p.read_text(encoding="utf-8").strip()
+            if x:
+                return x
+        except OSError:
+            pass
+    try:
+        from huggingface_hub import get_token  # noqa: PLC0415
+
+        x2 = (get_token() or "").strip()  # hub>=0.20
+        if x2:
+            return x2
+    except Exception:  # noqa: BLE001
+        pass
+    try:
+        from huggingface_hub import HfFolder  # noqa: PLC0415
+
+        x3 = (HfFolder.get_token() or "").strip()  # 旧: huggingface-cli 登录
+        if x3:
+            return x3
+    except Exception:  # noqa: BLE001
+        pass
+    return None
+
+
+def main() -> int:
+    tok = _resolve_hf_token()
+    if not tok:
+        print("需要凭据：export HF_TOKEN=… 或 ~/.huggingface/token 或 huggingface-cli login", flush=True)
+        return 1
+    try:
+        from huggingface_hub import HfApi  # noqa: PLC0415
+    except ImportError:
+        print("pip install huggingface_hub", flush=True)
+        return 2
+
+    bundle = Path(os.environ.get("HF_GAP_BUNDLE", str(DEFAULT_BUNDLE))).resolve()
+    if not bundle.is_dir():
+        print(f"缺少目录: {bundle}", flush=True)
+        return 3
+
+    repo_id = os.environ.get("HF_REPO_ID", DEFAULT_REPO)
+    api = HfApi(token=tok)
+
+    try:
+        for item in api.list_repo_tree(repo_id, path_in_repo=PREFIX, repo_type="dataset", recursive=True):
+            if type(item).__name__ != "RepoFile":
+                continue
+            try:
+                api.delete_file(path_in_repo=item.path, repo_id=repo_id, repo_type="dataset")
+                print(f"deleted {item.path}", flush=True)
+            except Exception as e:  # noqa: BLE001
+                print(f"delete skip {item.path}: {e}", flush=True)
+    except Exception as e:  # noqa: BLE001
+        print(f"list/delete: {e}", flush=True)
+
+    api.upload_folder(
+        folder_path=str(bundle),
+        path_in_repo=PREFIX,
+        repo_id=repo_id,
+        repo_type="dataset",
+        commit_message="Polymarket_data: replace gap_supplement from repo hf_push only",
+    )
+    print(f"uploaded {repo_id}/{PREFIX}/ from {bundle}", flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gap_supplement/code/incremental_gap_remedy.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""
+仅针对「缺失」的 gap 分片做增量补救（不覆盖已有 gap_*.parquet）：
+
+1) remedy：recent_recovery_state 已记录但磁盘无 gap_<start>_<end>.parquet（与 --remedy-state-no-parquet 一致）
+2) fresh：detected_gaps 窗口内仍无 parquet 且不在 state 的区间（与 run_recent_recovery_parallel --backward 一致）
+
+plan：只统计 + 预估耗时；run：顺序执行上述两阶段并跑 lack CSV 校验。
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import time
+import os
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[2]
+POLY = Path(os.environ.get("POLY_ROOT", str(REPO.parent / "poly_data")))
+DATA = POLY / "data"
+CHUNKS = DATA / "recovered_chunks"
+GAPS_FILE = DATA / "detected_gaps.json"
+STATE_FILE = DATA / "recent_recovery_state.json"
+MIN_BLOCK = 70229300
+MAX_BLOCK = 84923445
+
+
+def _recent_gaps() -> list[dict]:
+    with open(GAPS_FILE, encoding="utf-8") as f:
+        gaps = json.load(f)
+    recent: list[dict] = []
+    for g in gaps:
+        if g["end"] >= MIN_BLOCK and g["start"] <= MAX_BLOCK:
+            recent.append(
+                {"start": max(g["start"], MIN_BLOCK), "end": min(g["end"], MAX_BLOCK)}
+            )
+    return recent
+
+
+def _state() -> set[str]:
+    if not STATE_FILE.is_file():
+        return set()
+    with open(STATE_FILE, encoding="utf-8") as f:
+        return set(json.load(f))
+
+
+def plan_counts() -> dict:
+    state = _state()
+    recent = _recent_gaps()
+    remedy_pending: list[str] = []
+    fresh_pending: list[str] = []
+    remedy_gaps: list[dict] = []
+    fresh_gaps: list[dict] = []
+    skipped_has = 0
+    for g in recent:
+        gid = f"{g['start']}_{g['end']}"
+        out = CHUNKS / f"gap_{gid}.parquet"
+        if out.is_file():
+            skipped_has += 1
+            continue
+        if gid in state:
+            remedy_pending.append(gid)
+            remedy_gaps.append(g)
+        else:
+            fresh_pending.append(gid)
+            fresh_gaps.append(g)
+
+    def _span(gs: list[dict]) -> int:
+        return sum(int(x["end"]) - int(x["start"]) + 1 for x in gs)
+
+    span_remedy = _span(remedy_gaps)
+    span_fresh = _span(fresh_gaps)
+    return {
+        "detected_gaps_in_window": len(recent),
+        "skipped_has_parquet": skipped_has,
+        "remedy_pending_count": len(remedy_pending),
+        "fresh_pending_count": len(fresh_pending),
+        "remedy_block_span": span_remedy,
+        "fresh_block_span": span_fresh,
+        "remedy_pending_ids_head": remedy_pending[:20],
+        "fresh_pending_ids_head": fresh_pending[:20],
+    }
+
+
+def estimate_eta_sec(
+    remedy_n: int,
+    fresh_n: int,
+    span_remedy: int,
+    span_fresh: int,
+    workers: int,
+    avg_sec: float,
+) -> float:
+    """粗算：大区间 eth_getLogs + 解码耗时主要来自区块跨度，其次才是分片个数。"""
+    w = max(1, workers)
+    span_sec = (span_remedy + span_fresh) / float(
+        os.environ.get("GAP_REMEDY_BLOCKS_PER_SEC_EST", "7.5")
+    )
+    chunk_sec = ((remedy_n + fresh_n) / w) * avg_sec
+    return max(60.0, span_sec * 0.55 + chunk_sec + 90.0)
+
+
+def cmd_plan(args: argparse.Namespace) -> int:
+    workers = int(os.environ.get("RECOVERY_MAX_WORKERS", "6"))
+    avg_sec = float(os.environ.get("GAP_REMEDY_AVG_SEC_PER_CHUNK", "22"))
+    c = plan_counts()
+    eta = estimate_eta_sec(
+        c["remedy_pending_count"],
+        c["fresh_pending_count"],
+        c["remedy_block_span"],
+        c["fresh_block_span"],
+        workers,
+        avg_sec,
+    )
+    c["workers_assumed"] = workers
+    c["avg_sec_per_chunk_assumed"] = avg_sec
+    c["eta_seconds_est"] = round(eta, 1)
+    c["eta_human_est"] = _fmt_eta(c["eta_seconds_est"])
+    c["note"] = (
+        "预估为粗算（RPC 限速/空分片/大区间会变）；"
+        "仅处理当前仍缺 parquet 的区间，已有文件不会覆盖。"
+    )
+    s = json.dumps(c, indent=2, ensure_ascii=False)
+    if args.json:
+        print(s)
+    else:
+        print(s)
+    return 0
+
+
+def _fmt_eta(sec: float) -> str:
+    if sec < 120:
+        return f"约 {int(sec)} 秒"
+    if sec < 3600:
+        return f"约 {sec / 60:.1f} 分钟"
+    return f"约 {sec / 3600:.1f} 小时"
+
+
+def cmd_run(args: argparse.Namespace) -> int:
+    py = sys.executable
+    rec = REPO / "scripts" / "gap_recovery" / "run_recent_recovery_parallel.py"
+    ver = POLY / "update_utils" / "verify_lack_csv_in_gap_parquet_full.py"
+    env = os.environ.copy()
+    env.setdefault("RECOVERY_SKIP_MERGE", "1")
+
+    t0 = time.time()
+    print("--- 阶段 1/3：remedy（仅 state 有记录且无 parquet）---", flush=True)
+    r1 = subprocess.run(
+        [py, str(rec), "--remedy-state-no-parquet", "--backward"],
+        cwd=str(REPO),
+        env=env,
+    )
+    if r1.returncode != 0:
+        return r1.returncode
+
+    print("--- 阶段 2/3：backward（仅仍无 parquet 且不在 state 的区间）---", flush=True)
+    r2 = subprocess.run([py, str(rec), "--backward"], cwd=str(REPO), env=env)
+    if r2.returncode != 0:
+        return r2.returncode
+
+    print("--- 阶段 3/3：verify lack_data_trades.csv ---", flush=True)
+    r3 = subprocess.run([py, str(ver)], cwd=str(POLY))
+    elapsed = time.time() - t0
+    rep = DATA / "logs" / "incremental_gap_remedy_last_run.json"
+    rep.parent.mkdir(parents=True, exist_ok=True)
+    rep.write_text(
+        json.dumps(
+            {
+                "finished_at_unix": int(time.time()),
+                "elapsed_sec": round(elapsed, 2),
+                "exit_codes": {"remedy": r1.returncode, "backward": r2.returncode, "verify": r3.returncode},
+            },
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+    print(f"全部完成，耗时 {elapsed:.1f}s；摘要 {rep}", flush=True)
+    return r3.returncode
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="增量 gap 补救规划与执行")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    p_plan = sub.add_parser("plan", help="统计缺失分片并输出预估耗时")
+    p_plan.add_argument("--json", action="store_true")
+    p_plan.set_defaults(func=cmd_plan)
+
+    p_run = sub.add_parser("run", help="顺序执行 remedy + backward + lack 校验")
+    p_run.set_defaults(func=cmd_run)
+
+    args = ap.parse_args()
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gap_supplement/code/merge_gap_staging_pair.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""
+将两份 gap staging（trades_fix_gap/quant_fix_gap/users_fix_gap 各一份）在 trades 上纵向合并、
+四键去重、按 (timestamp, transaction_hash, order_hash) 稳定排序，再重算 quant/users。
+
+通常：staging_small = 区间表 [3,50] 分片；staging_large = recovered 补集（大跨度 / lack_remedy 等）。
+
+**内存**（大文件）：默认用 DuckDB 做「A ∪ (B 反 A 上四键)」+ 外排，**不在 pandas 中同时读入 A、B 两份全表**；中间写临时 Parquet 后再单表读入做 `clean_trades`/`clean_users`。
+可 `export POLY_GAP_MERGE_USE_PANDAS=1` 强制旧版 concat（仅建议小表调试）。
+
+**环境**：
+- `POLY_ROOT` / `POLY_DUCKDB_TEMP`：DuckDB 外排目录
+- `POLY_GAP_MERGE_DUCKDB_MEMORY`：如 `8GB`（默认 `12GB`）
+- `POLY_GAP_MERGE_DUCKDB_THREADS`：DuckDB 线程数，默认 4
+
+用法:
+  export POLY_ROOT=...
+  python3 merge_gap_staging_pair.py --staging-a .../st_small --staging-b .../st_large --out .../st_merged
+"""
+from __future__ import annotations
+
+import argparse
+import gc
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+REPO = Path(__file__).resolve().parents[2]
+TRADES_KEYS = ["timestamp", "transaction_hash", "maker", "taker"]
+
+
+def _sort_t(df: pd.DataFrame) -> pd.DataFrame:
+    keys = [c for c in ("timestamp", "transaction_hash", "order_hash") if c in df.columns]
+    if not keys:
+        return df
+    return df.sort_values(keys, kind="mergesort", ignore_index=True)
+
+
+def _sql_path(p: Path) -> str:
+    return str(p).replace("'", "''")
+
+
+def _duckdb_config(con, poly_root: Path) -> None:
+
+    mem = os.environ.get("POLY_GAP_MERGE_DUCKDB_MEMORY", "12GB")
+    th = int(os.environ.get("POLY_GAP_MERGE_DUCKDB_THREADS", "4"))
+    tmp = os.environ.get("POLY_DUCKDB_TEMP")
+    if not tmp:
+        tbase = poly_root / "data" / "tmp_duckdb_merge"
+        tbase.mkdir(parents=True, exist_ok=True)
+        tmp = str(tbase)
+    con.execute(f"PRAGMA memory_limit='{mem}'")
+    con.execute(f"PRAGMA temp_directory='{_sql_path(Path(tmp))}'")
+    con.execute(f"PRAGMA threads={th}")
+    con.execute("SET preserve_insertion_order=false")
+
+
+def _merge_trades_duckdb_to_file(pa_path: Path, pb_path: Path, out_parquet: Path, poly_root: Path) -> tuple[int, int, int]:
+    """
+    仅合并 trades 去重：A 行优先，再追加 B 中四键未出现在 A 中的行。排序后写到 out_parquet。
+    返回 (|A|, |B|, 合并行数)
+    """
+    import duckdb  # noqa: WPS433
+
+    ap, bp = _sql_path(pa_path), _sql_path(pb_path)
+    op = _sql_path(out_parquet)
+    con = duckdb.connect()
+    _duckdb_config(con, poly_root)
+    ra = con.execute("SELECT count(*)::BIGINT AS c FROM read_parquet(?)", [str(pa_path)]).fetchone()[0]
+    rb = con.execute("SELECT count(*)::BIGINT AS c FROM read_parquet(?)", [str(pb_path)]).fetchone()[0]
+    con.execute(
+        f"""
+        COPY (
+            WITH
+            a AS (SELECT * FROM read_parquet('{ap}')),
+            b0 AS (SELECT * FROM read_parquet('{bp}')),
+            b_only AS (
+                SELECT b0.* FROM b0
+                WHERE NOT EXISTS (
+                    SELECT 1 FROM a
+                    WHERE a."timestamp" IS NOT DISTINCT FROM b0."timestamp"
+                    AND a.transaction_hash IS NOT DISTINCT FROM b0.transaction_hash
+                    AND a.maker IS NOT DISTINCT FROM b0.maker
+                    AND a.taker IS NOT DISTINCT FROM b0.taker
+                )
+            ),
+            u AS (
+                SELECT * FROM a UNION ALL SELECT * FROM b_only
+            )
+            SELECT * FROM u
+            ORDER BY
+                u."timestamp" NULLS LAST,
+                u.transaction_hash NULLS LAST,
+                u.order_hash NULLS LAST
+        ) TO '{op}' (FORMAT PARQUET, COMPRESSION ZSTD)
+        """
+    )
+    n = con.execute("SELECT count(*)::BIGINT AS c FROM read_parquet(?)", [str(out_parquet)]).fetchone()[0]
+    con.close()
+    return int(ra), int(rb), int(n)
+
+
+def _merge_pandas_in_memory(
+    ta: pd.DataFrame, tb: pd.DataFrame
+) -> tuple[pd.DataFrame, int, int, int, int]:  # u, m, la, lb, len_u
+    m = len(ta) + len(tb)
+    u = pd.concat([ta, tb], ignore_index=True)
+    u = u.drop_duplicates(subset=TRADES_KEYS, keep="first")
+    u = _sort_t(u)
+    return u, m, len(ta), len(tb), len(u)
+
+
+def merge_staging_pair(staging_a: Path, staging_b: Path, out: Path) -> int:
+    """将两份 staging 合并为 out；返回 0/1（业务失败）。"""
+    for lab, p in (("A", staging_a), ("B", staging_b)):
+        t = p / "trades_fix_gap.parquet"
+        if not t.is_file():
+            print(f"缺少 {lab}/trades_fix_gap: {t}", flush=True)
+            return 1
+
+    sys.path.insert(0, str(REPO))
+    from polymarket.processors.cleaner import clean_trades_df, clean_users_df  # noqa: E402
+
+    poly = Path(os.environ.get("POLY_ROOT", str(REPO.parent / "poly_data"))).resolve()
+    pa_t = staging_a / "trades_fix_gap.parquet"
+    pb_t = staging_b / "trades_fix_gap.parquet"
+    use_pandas = os.environ.get("POLY_GAP_MERGE_USE_PANDAS", "").lower() in ("1", "true", "yes")
+
+    out.mkdir(parents=True, exist_ok=True)
+    temp_merged: Path | None = None
+    if use_pandas:
+        ta = pd.read_parquet(pa_t, engine="pyarrow")
+        tb = pd.read_parquet(pb_t, engine="pyarrow")
+        u, m, la, lb, lu = _merge_pandas_in_memory(ta, tb)
+        del ta, tb
+        gc.collect()
+        print(f"合并(pandas): concat={m} → 去重 {lu} (A={la} B={lb})", flush=True)
+    else:
+        try:
+            fd, tmp = tempfile.mkstemp(suffix="_merged_trades_tmp.parquet", dir=out)
+            os.close(fd)
+            temp_merged = Path(tmp)
+            la, lb, lu = _merge_trades_duckdb_to_file(pa_t, pb_t, temp_merged, poly)
+            m = la + lb
+            # 大表仅保留一份在 pandas
+            u = pd.read_parquet(temp_merged, engine="pyarrow")
+            if temp_merged.is_file():
+                temp_merged.unlink()
+            temp_merged = None
+            gc.collect()
+            print(
+                f"合并(duckdb): A={la} B={lb} concat={m} → 去重 {lu} (中间外排, POLY_DUCKDB_TEMP/内存见环境)",
+                flush=True,
+            )
+        except Exception as e:  # noqa: BLE001
+            print(f"DuckDB 合并失败, 可设 POLY_GAP_MERGE_USE_PANDAS=1 重试: {e}", flush=True)
+            if temp_merged and temp_merged.is_file():
+                try:
+                    temp_merged.unlink()
+                except OSError:
+                    pass
+            return 1
+
+    quant = clean_trades_df(u)
+    users = clean_users_df(u)
+    pq.write_table(pa.Table.from_pandas(u, preserve_index=False), out / "trades_fix_gap.parquet", compression="zstd")
+    pq.write_table(
+        pa.Table.from_pandas(quant, preserve_index=False), out / "quant_fix_gap.parquet", compression="zstd"
+    )
+    pq.write_table(
+        pa.Table.from_pandas(users, preserve_index=False), out / "users_fix_gap.parquet", compression="zstd"
+    )
+    mrows = m
+    (out / "merge_gap_staging_pair_report.txt").write_text(
+        f"rows_a={la} rows_b={lb} concat={mrows} dedup={len(u)} quant={len(quant)} users={len(users)}\n",
+        encoding="utf-8",
+    )
+    del u, quant, users
+    gc.collect()
+    print(f"written {out}", flush=True)
+    return 0
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--staging-a", type=Path, required=True)
+    ap.add_argument("--staging-b", type=Path, required=True)
+    ap.add_argument("--out", type=Path, required=True)
+    args = ap.parse_args()
+    return merge_staging_pair(args.staging_a, args.staging_b, args.out)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gap_supplement/code/prepare_hf_gap_bundle.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+在 Polymarket_data/hf_push/gap_supplement/ 内补充：
+- GAP_DATASET_README.md（根据 gap_full_pipeline_report.json）
+- MERGE_GAP_SKILL.md（复制自 docs/MERGE_GAP_SKILL.md）
+- code/ 下本目录全部 .py 源码快照
+
+不删除已有 parquet（由 gap_to_trades_quant_users_hf.py 生成）。
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[2]
+STAGING = REPO / "hf_push" / "gap_supplement"
+REPORT = STAGING / "gap_full_pipeline_report.json"
+MERGE_SRC = REPO / "docs" / "MERGE_GAP_SKILL.md"
+SCRIPT_DIR = REPO / "scripts" / "gap_recovery"
+
+
+def _fmt_int(v: object, default: int = 0) -> str:
+    try:
+        return f"{int(v):,}"
+    except (TypeError, ValueError):
+        return str(v)
+
+
+def _readme(rep: dict) -> str:
+    n_small = 1017230
+    return f"""# Polymarket_data_fixed — gap_supplement 说明
+
+**源码与上传物均来自本 Git 仓库 `Polymarket_data`（路径 `hf_push/gap_supplement/`），不包含其他项目目录。**
+
+## 本目录内容
+
+| 文件 | 说明 |
+|------|------|
+| `trades_fix_gap.parquet` | 全量 `gap_*.parquet` → `extract_trades` + 四键去重 |
+| `quant_fix_gap.parquet` | `clean_trades_df` |
+| `users_fix_gap.parquet` | `clean_users_df` |
+| `gap_full_pipeline_report.json` | 逐文件统计 |
+| `MERGE_GAP_SKILL.md` | 与基线 parquet 合并教程 |
+| `code/` | `scripts/gap_recovery/` 内相关脚本快照 |
+
+## 当前生成统计
+
+- 非空 gap 文件：**{_fmt_int(rep.get("gap_files"), 0)}**  
+- OrderFilled 行：**{_fmt_int(rep.get("gap_event_rows"), 0)}**  
+- Trades：去重前 {_fmt_int(rep.get("trades_rows_before_dedupe"), 0)} → **{_fmt_int(rep.get("trades_rows"), 0)}**（去重 {_fmt_int(rep.get("trades_dedupe_removed"), 0)}）  
+- Quant：**{_fmt_int(rep.get("quant_rows"), 0)}**；Users：**{_fmt_int(rep.get("users_rows"), 0)}**  
+- markets 映射：**{"是" if rep.get("markets_mapping_used") else "否"}** `{rep.get("markets_parquet", "")}`
+
+## HF 相邻块「小空洞」2～50 缺失区块
+
+- 脚本：`code/verify_hf_orderfilled_gaps_2_50_duckdb.py`，汇总见 poly_data 下 `data/hf_orderfilled_gaps_2_50_summary.json`。  
+- **区间总数约 {n_small:,}**（统计对象为空档段，非本目录单文件）。  
+- `--rpc-sample N` 为**随机抽检**，**不保证**小空档内 100% 无遗漏。  
+
+## detected_gaps 大区间的链上补救
+
+- 脚本：`code/run_recent_recovery_parallel.py`：初始终批次 **50** 区块 `eth_getLogs`，成功扩大至最多 **100**；失败则 **÷5** 细分重试；单块失败记入 `permanently_failed_blocks.txt` 并前进；多节点轮换与超时见源码。  
+- 与 `MIN_BLOCK`～`MAX_BLOCK` 相交的待补区间共 **322** 段，跨度均 **≥50**；**本批 parquet 对应这些区间的汇总**，未对全部小空洞逐段补链上。
+
+## 合并基线
+
+见 `MERGE_GAP_SKILL.md`。
+
+---
+*由 `scripts/gap_recovery/prepare_hf_gap_bundle.py` 生成/更新。*
+"""
+
+
+def main() -> int:
+    if not REPORT.is_file():
+        print(f"缺少 {REPORT}，请先运行: python3 scripts/gap_recovery/gap_to_trades_quant_users_hf.py", flush=True)
+        return 1
+    rep = json.loads(REPORT.read_text(encoding="utf-8"))
+    STAGING.mkdir(parents=True, exist_ok=True)
+    (STAGING / "GAP_DATASET_README.md").write_text(_readme(rep), encoding="utf-8")
+
+    if MERGE_SRC.is_file():
+        shutil.copy2(MERGE_SRC, STAGING / "MERGE_GAP_SKILL.md")
+    else:
+        (STAGING / "MERGE_GAP_SKILL.md").write_text("请补全仓库 docs/MERGE_GAP_SKILL.md\n", encoding="utf-8")
+
+    code = STAGING / "code"
+    code.mkdir(exist_ok=True)
+    for src in sorted(SCRIPT_DIR.glob("*.py")):
+        shutil.copy2(src, code / src.name)
+
+    print(json.dumps({"staging": str(STAGING), "code_files": [p.name for p in code.glob("*.py")]}, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gap_supplement/code/run_recent_recovery_parallel.py

@@ -0,0 +1,365 @@
+import json
+import time
+import os
+import argparse
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+import sys
+from pathlib import Path
+import functools
+import requests
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+print = functools.partial(print, flush=True)
+
+# 本脚本位于 Polymarket_data/scripts/gap_recovery/；poly_data 默认同级目录，可用 POLY_ROOT 覆盖
+_REPO_ROOT = Path(__file__).resolve().parents[2]
+_POLY = Path(os.environ.get("POLY_ROOT", str(_REPO_ROOT.parent / "poly_data")))
+project_root = _REPO_ROOT
+sys.path.insert(0, str(project_root))
+from polymarket.processors import EventDecoder
+
+MIN_BLOCK = 70229300
+MAX_BLOCK = 84923445
+
+DATA_DIR = _POLY / "data"
+CHUNKS_DIR = DATA_DIR / 'recovered_chunks'
+CHUNKS_DIR.mkdir(exist_ok=True)
+STATE_FILE = DATA_DIR / 'recent_recovery_state.json'
+
+CONTRACTS = [
+    '0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E',
+    '0xC5d563A36AE78145C45a50134d48A1215220f80a'
+]
+TOPIC = '0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6'
+decoder = EventDecoder()
+
+# 与 decode 后 format_batch 列一致；补救模式下无链上日志时也落盘 0 行 parquet，便于与 state 对齐、NFS 汇合识别
+_EMPTY_GAP_COLUMNS = (
+    "transaction_hash",
+    "block_number",
+    "log_index",
+    "timestamp",
+    "contract",
+    "event_name",
+    "datetime",
+    "order_hash",
+    "maker",
+    "taker",
+    "maker_asset_id",
+    "taker_asset_id",
+    "maker_amount_filled",
+    "taker_amount_filled",
+    "maker_fee",
+    "taker_fee",
+    "protocol_fee",
+)
+
+
+def _write_empty_gap_parquet(out_file: Path) -> None:
+    df = pd.DataFrame({c: pd.Series(dtype="string") for c in _EMPTY_GAP_COLUMNS})
+    table = pa.Table.from_pandas(df, preserve_index=False)
+    pq.write_table(table, out_file, compression="snappy")
+
+
+# 我们准备了更多的免费 RPC 节点，用于分散请求压力
+RPC_NODES = [
+    'https://polygon.drpc.org',
+    'https://1rpc.io/matic',
+    'https://polygon-bor-rpc.publicnode.com',
+    'https://polygon-mainnet.public.blastapi.io',
+    'https://polygon.meowrpc.com',
+    'https://polygon.llamarpc.com'
+]
+
+def get_gaps():
+    with open(DATA_DIR / 'detected_gaps.json', 'r') as f:
+        all_gaps = json.load(f)
+    recent = []
+    for g in all_gaps:
+        if g['end'] >= MIN_BLOCK and g['start'] <= MAX_BLOCK:
+            recent.append({
+                'start': max(g['start'], MIN_BLOCK),
+                'end': min(g['end'], MAX_BLOCK)
+            })
+    return recent
+
+def load_state():
+    if STATE_FILE.exists():
+        with open(STATE_FILE, 'r') as f:
+            return set(json.load(f))
+    return set()
+
+def save_state(state):
+    with open(STATE_FILE, 'w') as f:
+        json.dump(list(state), f)
+
+def fetch_logs_for_chunk(start_b, end_b, attempt_offset=0):
+    payload = {
+        "jsonrpc": "2.0",
+        "method": "eth_getLogs",
+        "params": [{
+            "fromBlock": hex(start_b),
+            "toBlock": hex(end_b),
+            "address": CONTRACTS,
+            "topics": [TOPIC]
+        }],
+        "id": 1
+    }
+    
+    # 每个任务尝试 5 次，每次换不同的节点
+    for attempt in range(5):
+        node_url = RPC_NODES[(attempt + attempt_offset) % len(RPC_NODES)]
+        try:
+            response = requests.post(node_url, json=payload, timeout=15)
+            if response.status_code == 400:
+                raise Exception("HTTP 400: Block range too large or too many logs")
+            if response.status_code == 429:
+                time.sleep(5)
+                raise Exception("HTTP 429")
+            if response.status_code != 200:
+                raise Exception(f"HTTP {response.status_code}")
+            
+            result = response.json()
+            if 'error' in result:
+                if 'pruned' in str(result['error']).lower() or 'missing trie node' in str(result['error']).lower():
+                    raise Exception(f"RPC Error Pruned: {result['error']}")
+                raise Exception(f"RPC Error: {result['error']}")
+                
+            return result.get('result', [])
+            
+        except Exception as e:
+            err_str = str(e).lower()
+            if "400" in err_str or "405" in err_str or "timeout" in err_str or "aborted" in err_str or "pruned" in err_str or "missing trie node" in err_str:
+                if attempt == 4:
+                    raise e
+            elif attempt == 4:
+                raise e
+            time.sleep(1)
+            
+def fetch_timestamp(block_num):
+    payload = {"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":[hex(block_num), False],"id":1}
+    for attempt in range(3):
+        try:
+            resp = requests.post('https://polygon.drpc.org', json=payload, timeout=5).json()
+            return int(resp['result']['timestamp'], 16)
+        except Exception:
+            if attempt == 2:
+                return 0
+            time.sleep(1)
+
+def process_gap_parallel(gap, worker_id, remedy_write_empty: bool = False):
+    start_b = gap['start']
+    end_b = gap['end']
+    gap_id = f"{start_b}_{end_b}"
+    out_file = CHUNKS_DIR / f"gap_{gap_id}.parquet"
+    if out_file.is_file():
+        return gap_id, -1
+
+    all_logs = []
+    current = start_b
+    batch_size = 50 
+    
+    while current <= end_b:
+        chunk_end = min(current + batch_size - 1, end_b)
+        try:
+            # 传入 worker_id 作为偏移量，让不同的线程优先使用不同的节点，实现负载均衡
+            logs = fetch_logs_for_chunk(current, chunk_end, attempt_offset=worker_id)
+            all_logs.extend(logs)
+            current = chunk_end + 1
+            batch_size = min(100, batch_size * 2)
+            time.sleep(0.2) 
+        except Exception as e:
+            # print(f"    [!] 区块 {current}-{chunk_end} 失败 ({e})")
+            if batch_size > 1:
+                batch_size = max(1, batch_size // 5) 
+            else:
+                # 记录彻底失败的单区块
+                with open(DATA_DIR / 'permanently_failed_blocks.txt', 'a') as f:
+                    f.write(f"{current}\n")
+                current += 1
+    
+    if not all_logs:
+        if remedy_write_empty:
+            _write_empty_gap_parquet(out_file)
+            return gap_id, 0
+        return gap_id, None
+
+    blocks = set(int(l['blockNumber'], 16) for l in all_logs)
+    timestamps = {}
+    for b in blocks:
+        timestamps[b] = fetch_timestamp(b)
+                
+    records = []
+    for l in all_logs:
+        bn = int(l['blockNumber'], 16)
+        records.append({
+            'contract': 'CTF_EXCHANGE',
+            'address': l['address'],
+            'block_number': bn,
+            'transaction_hash': l['transactionHash'],
+            'log_index': int(l['logIndex'], 16),
+            'timestamp': timestamps.get(bn, 0),
+            'topics': l['topics'],
+            'data': l['data'],
+            'event_name': 'OrderFilled'
+        })
+        
+    decoded = decoder.decode_batch(records)
+    formatted = decoder.format_batch(decoded)
+    
+    # 直接在这里保存 parquet
+    if formatted:
+        df = pd.DataFrame(formatted)
+        for col in df.columns:
+            df[col] = df[col].astype(str)
+        table = pa.Table.from_pandas(df, preserve_index=False)
+        pq.write_table(table, out_file, compression='snappy')
+        return gap_id, len(formatted)
+
+    if remedy_write_empty:
+        _write_empty_gap_parquet(out_file)
+        return gap_id, 0
+
+    return gap_id, None
+
+def main():
+    parser = argparse.ArgumentParser(description="多线程恢复 OrderFilled gap（细分区块 + 多 RPC）")
+    parser.add_argument(
+        "--remedy-state-no-parquet",
+        action="store_true",
+        help="仅补救：已在 recent_recovery_state.json 中标记完成、但 recovered_chunks 下仍无 gap_*.parquet 的区间；"
+        "已有 parquet 的区间一律跳过，避免重复下载。",
+    )
+    parser.add_argument(
+        "--backward",
+        action="store_true",
+        help="将待处理区间按区块 end 从高到低排序（从链上较新/较高端向回补）。",
+    )
+    parser.add_argument(
+        "--stop-if-parquet-exists",
+        action="store_true",
+        help="与 --backward 配合：按顺序逐个处理；每段开始前若发现 gap_*.parquet 已存在（例如 NFS 上另一进程已写入），"
+        "或存在停止哨兵文件 data/.gap_recovery_stop，则立即结束本进程，避免与「对向」补救重复。此模式下为顺序执行（单线程）。",
+    )
+    args = parser.parse_args()
+    remedy_state_no_parquet = args.remedy_state_no_parquet
+    backward = args.backward
+    stop_if_parquet_exists = args.stop_if_parquet_exists
+
+    print("=== 启动【最近一年】多节点并发防弹恢复脚本 ===")
+    if remedy_state_no_parquet:
+        print("模式: --remedy-state-no-parquet（只处理 state 有记录且尚无 parquet 的区间；已有 parquet 跳过）")
+    if backward:
+        print("模式: --backward（待处理按 end 降序）")
+    if stop_if_parquet_exists:
+        print("模式: --stop-if-parquet-exists（遇已有 parquet 或停止哨兵则退出；单线程顺序）")
+    gaps = get_gaps()
+    state = load_state()
+
+    pending_gaps = []
+    skipped_has_parquet = 0
+    for g in gaps:
+        gid = f"{g['start']}_{g['end']}"
+        out = CHUNKS_DIR / f"gap_{gid}.parquet"
+        if out.is_file():
+            skipped_has_parquet += 1
+            continue
+        if remedy_state_no_parquet:
+            if gid not in state:
+                continue
+        else:
+            if gid in state:
+                continue
+        pending_gaps.append(g)
+
+    if backward:
+        pending_gaps.sort(key=lambda x: (-x["end"], -x["start"]))
+
+    print(f"detected_gaps 窗口内区间总数: {len(gaps)}；state 记录数: {len(state)}")
+    print(f"因已存在 gap_*.parquet 跳过: {skipped_has_parquet}")
+    print(f"本次待处理区间数: {len(pending_gaps)}")
+    
+    if not pending_gaps:
+        print("没有符合条件的待处理断点（可能已全部有 parquet 或已全部在 state 且无遗漏）。")
+        return
+
+    start_time = time.time()
+    completed_count = 0
+
+    STOP_SENTINEL = DATA_DIR / ".gap_recovery_stop"
+
+    def handle_one_result(gap, gap_id, result):
+        nonlocal completed_count
+        completed_count += 1
+        label = f"[{completed_count}/{len(pending_gaps)}]"
+        if result == -1:
+            print(f"{label} ○ 断点 {gap['start']}-{gap['end']} 跳过（已存在 parquet）。")
+            return
+        if result == 0:
+            print(f"{label} ✓ 断点 {gap['start']}-{gap['end']} 完成，已落盘空分片（0 条）。")
+        elif result is not None:
+            print(f"{label} ✓ 断点 {gap['start']}-{gap['end']} 完成，保存了 {result} 条交易。")
+        else:
+            print(f"{label} ✓ 断点 {gap['start']}-{gap['end']} 完成，无交易。")
+        state.add(gap_id)
+        save_state(state)
+
+    if stop_if_parquet_exists:
+        print("顺序模式（遇 parquet / 哨兵即停），单线程拉取…")
+        for i, gap in enumerate(pending_gaps):
+            if STOP_SENTINEL.exists():
+                print(f"发现停止哨兵 {STOP_SENTINEL}，退出。")
+                break
+            gid = f"{gap['start']}_{gap['end']}"
+            out = CHUNKS_DIR / f"gap_{gid}.parquet"
+            if out.is_file():
+                print(f"遇到已存在文件 {out.name}（与对向补救或历史数据汇合），停止。")
+                break
+            try:
+                gap_id, result = process_gap_parallel(gap, 0, remedy_state_no_parquet)
+                handle_one_result(gap, gap_id, result)
+                if result == -1:
+                    print("（运行中他机写入 parquet）停止。")
+                    break
+            except Exception as exc:
+                print(f"❌ 断点 {gap['start']}-{gap['end']} 异常: {exc}")
+    else:
+        MAX_WORKERS = max(1, int(os.environ.get("RECOVERY_MAX_WORKERS", "5")))
+        print(f"启动 {MAX_WORKERS} 个并发线程，利用 {len(RPC_NODES)} 个免费节点进行负载均衡...")
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+            future_to_gap = {
+                executor.submit(
+                    process_gap_parallel, gap, i % len(RPC_NODES), remedy_state_no_parquet
+                ): gap
+                for i, gap in enumerate(pending_gaps)
+            }
+            for future in as_completed(future_to_gap):
+                gap = future_to_gap[future]
+                try:
+                    gap_id, result = future.result()
+                    handle_one_result(gap, gap_id, result)
+                except Exception as exc:
+                    print(f"❌ 断点 {gap['start']}-{gap['end']} 发生未捕获异常: {exc}")
+
+    skip_merge = os.environ.get("RECOVERY_SKIP_MERGE", "1" if remedy_state_no_parquet else "0").strip() == "1"
+    print("\n=== 所有断点处理完成！===")
+    if skip_merge:
+        print("RECOVERY_SKIP_MERGE=1（补救模式默认）：跳过合并 recovered_orderfilled_recent_year.parquet；"
+              "若需合并请显式设置 RECOVERY_SKIP_MERGE=0 后重新运行本脚本末尾合并逻辑或单独合并。")
+    else:
+        print("开始合并所有 chunk ...")
+        chunk_files = list(CHUNKS_DIR.glob('*.parquet'))
+        if chunk_files:
+            tables = [pq.read_table(f) for f in chunk_files]
+            combined = pa.concat_tables(tables)
+            final_output = DATA_DIR / 'recovered_orderfilled_recent_year.parquet'
+            pq.write_table(combined, final_output, compression='snappy')
+            print(f"合并完成！总记录数: {combined.num_rows}")
+            print(f"最终文件已保存至: {final_output}")
+        else:
+            print("没有找到任何包含交易的 chunk，无需合并。")
+
+if __name__ == '__main__':
+    main()

gap_supplement/code/run_recent_recovery_robust.py

@@ -0,0 +1,211 @@
+import json
+import time
+import os
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+import sys
+from pathlib import Path
+import functools
+import requests
+
+print = functools.partial(print, flush=True)
+
+_REPO_ROOT = Path(__file__).resolve().parents[2]
+_POLY = Path(os.environ.get("POLY_ROOT", str(_REPO_ROOT.parent / "poly_data")))
+project_root = _REPO_ROOT
+sys.path.insert(0, str(project_root))
+from polymarket.processors import EventDecoder
+
+MIN_BLOCK = 70229300
+MAX_BLOCK = 84923445
+
+DATA_DIR = _POLY / "data"
+CHUNKS_DIR = DATA_DIR / 'recovered_chunks'
+CHUNKS_DIR.mkdir(exist_ok=True)
+STATE_FILE = DATA_DIR / 'recent_recovery_state.json'
+
+CONTRACTS = [
+    '0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E',
+    '0xC5d563A36AE78145C45a50134d48A1215220f80a'
+]
+TOPIC = '0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6'
+decoder = EventDecoder()
+
+def get_gaps():
+    with open(DATA_DIR / 'detected_gaps.json', 'r') as f:
+        all_gaps = json.load(f)
+    recent = []
+    for g in all_gaps:
+        if g['end'] >= MIN_BLOCK and g['start'] <= MAX_BLOCK:
+            recent.append({
+                'start': max(g['start'], MIN_BLOCK),
+                'end': min(g['end'], MAX_BLOCK)
+            })
+    return recent
+
+def load_state():
+    if STATE_FILE.exists():
+        with open(STATE_FILE, 'r') as f:
+            return set(json.load(f))
+    return set()
+
+def save_state(state):
+    with open(STATE_FILE, 'w') as f:
+        json.dump(list(state), f)
+
+def fetch_logs_with_retry(start_b, end_b):
+    payload = {
+        "jsonrpc": "2.0",
+        "method": "eth_getLogs",
+        "params": [{
+            "fromBlock": hex(start_b),
+            "toBlock": hex(end_b),
+            "address": CONTRACTS,
+            "topics": [TOPIC]
+        }],
+        "id": 1
+    }
+    
+    nodes = ['https://1rpc.io/matic', 'https://polygon.drpc.org']
+    
+    for attempt in range(4):
+        node_url = nodes[0] if attempt <= 1 else nodes[1]
+        try:
+            # 使用 10 秒超时，防止卡死
+            response = requests.post(node_url, json=payload, timeout=10)
+            if response.status_code == 400:
+                raise Exception("HTTP 400: Block range too large or too many logs")
+            if response.status_code == 429:
+                print(f"    [!] {node_url} HTTP 429: Too Many Requests, sleeping for 10s...")
+                time.sleep(10)
+                # 429 不要抛出异常，直接 continue 换节点或重试
+                continue
+            if response.status_code != 200:
+                raise Exception(f"HTTP {response.status_code}")
+            
+            result = response.json()
+            if 'error' in result:
+                if 'pruned' in str(result['error']).lower() or 'missing trie node' in str(result['error']).lower():
+                    raise Exception(f"RPC Error Pruned: {result['error']}")
+                raise Exception(f"RPC Error: {result['error']}")
+                
+            return result.get('result', [])
+            
+        except Exception as e:
+            err_str = str(e).lower()
+            if "400" in err_str or "405" in err_str or "timeout" in err_str or "aborted" in err_str or "pruned" in err_str or "missing trie node" in err_str:
+                if attempt == 3:
+                    raise e
+            elif attempt == 3:
+                raise e
+            time.sleep(2)
+    raise Exception("Max retries exceeded")
+
+def fetch_timestamp(block_num):
+    payload = {"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":[hex(block_num), False],"id":1}
+    for attempt in range(1, 4):
+        try:
+            resp = requests.post('https://polygon.drpc.org', json=payload, timeout=5).json()
+            return int(resp['result']['timestamp'], 16)
+        except Exception:
+            if attempt == 3:
+                return 0
+            time.sleep(1)
+
+def process_gap(start_b, end_b):
+    all_logs = []
+    current = start_b
+    batch_size = 50 # 动态批次大小，初始 50
+    
+    while current <= end_b:
+        chunk_end = min(current + batch_size - 1, end_b)
+        try:
+            logs = fetch_logs_with_retry(current, chunk_end)
+            all_logs.extend(logs)
+            current = chunk_end + 1
+            batch_size = min(100, batch_size * 2) # 成功则逐渐恢复批次大小
+            time.sleep(0.5) # 平滑请求
+        except Exception as e:
+            print(f"    [!] 区块 {current}-{chunk_end} 失败 ({e})")
+            if batch_size > 1:
+                batch_size = max(1, batch_size // 5) # 失败则大幅缩小批次
+                print(f"    [!] 缩小批次大小至 {batch_size} 重试...")
+            else:
+                print(f"    [!!!] 单区块 {current} 彻底失败，跳过。")
+                # 记录彻底失败的单区块，防止卡死
+                with open(DATA_DIR / 'permanently_failed_blocks.txt', 'a') as f:
+                    f.write(f"{current}\n")
+                current += 1
+    
+    if not all_logs:
+        return None
+        
+    # 批量获取时间戳
+    blocks = set(int(l['blockNumber'], 16) for l in all_logs)
+    timestamps = {}
+    for b in blocks:
+        timestamps[b] = fetch_timestamp(b)
+                
+    records = []
+    for l in all_logs:
+        bn = int(l['blockNumber'], 16)
+        records.append({
+            'contract': 'CTF_EXCHANGE',
+            'address': l['address'],
+            'block_number': bn,
+            'transaction_hash': l['transactionHash'],
+            'log_index': int(l['logIndex'], 16),
+            'timestamp': timestamps.get(bn, 0),
+            'topics': l['topics'],
+            'data': l['data'],
+            'event_name': 'OrderFilled'
+        })
+        
+    decoded = decoder.decode_batch(records)
+    return decoder.format_batch(decoded)
+
+def main():
+    print("=== 启动【最近一年】增量防弹恢复脚本 (双节点交替版) ===")
+    gaps = get_gaps()
+    state = load_state()
+    
+    print(f"总计 {len(gaps)} 个断点区间。已完成 {len(state)} 个。")
+    
+    for i, gap in enumerate(gaps):
+        gap_id = f"{gap['start']}_{gap['end']}"
+        if gap_id in state:
+            continue
+            
+        print(f"[{i+1}/{len(gaps)}] 正在处理断点 {gap['start']} - {gap['end']} (跨度: {gap['end']-gap['start']+1} 区块)")
+        
+        formatted_logs = process_gap(gap['start'], gap['end'])
+        
+        if formatted_logs:
+            df = pd.DataFrame(formatted_logs)
+            for col in df.columns:
+                df[col] = df[col].astype(str)
+            table = pa.Table.from_pandas(df, preserve_index=False)
+            out_file = CHUNKS_DIR / f"gap_{gap_id}.parquet"
+            pq.write_table(table, out_file, compression='snappy')
+            print(f"  ✓ 找到 {len(formatted_logs)} 条交易，已保存至 {out_file.name}")
+        else:
+            print(f"  ✓ 该断点无交易。")
+            
+        state.add(gap_id)
+        save_state(state)
+        
+    print("\n=== 所有断点处理完成！开始合并 ===")
+    chunk_files = list(CHUNKS_DIR.glob('*.parquet'))
+    if chunk_files:
+        tables = [pq.read_table(f) for f in chunk_files]
+        combined = pa.concat_tables(tables)
+        final_output = DATA_DIR / 'recovered_orderfilled_recent_year.parquet'
+        pq.write_table(combined, final_output, compression='snappy')
+        print(f"合并完成！总记录数: {combined.num_rows}")
+        print(f"最终文件已保存至: {final_output}")
+    else:
+        print("没有找到任何包含交易的 chunk，无需合并。")
+
+if __name__ == '__main__':
+    main()

gap_supplement/code/test_merge_trades_memory.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""
+小规模 DuckDB 合并测试：基线 trades 抽样 + gap 全量，测量峰值 RSS 与耗时。
+用于外推全量合并内存需求（见 docs/MERGE_GAP_SKILL.md）。
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import resource
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+import duckdb
+import pyarrow.parquet as pq
+
+
+def _common_trade_columns(base: Path, gap: Path) -> list[str]:
+    sb = set(pq.read_schema(base).names)
+    sg = set(pq.read_schema(gap).names)
+    return sorted(sb & sg)
+
+
+def _max_rss_mb() -> float:
+    rss = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+    if sys.platform == "darwin":
+        return float(rss) / (1024 * 1024)
+    return float(rss) / 1024.0
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--poly-root",
+        type=Path,
+        default=Path(__file__).resolve().parents[3],
+        help="poly_data 根（含 huggingface_data/raw、data/hf_gap_push_staging）",
+    )
+    ap.add_argument(
+        "--base-sample-rows",
+        type=int,
+        default=200_000,
+        help="基线子集行数上限（与 --base-min-block 组合）",
+    )
+    ap.add_argument(
+        "--base-min-block",
+        type=int,
+        default=84_000_000,
+        help="仅扫描 block_number>=该值，加速大文件上的抽样（利用过滤下推）",
+    )
+    ap.add_argument("--memory-limit", type=str, default="8GB")
+    ap.add_argument("--gap-limit", type=int, default=0, help=">0 时仅取 gap 前 N 行（测全量 gap 请设 0）")
+    ap.add_argument("--threads", type=int, default=4)
+    args = ap.parse_args()
+
+    base = args.poly_root / "huggingface_data" / "raw" / "trades.parquet"
+    gap = args.poly_root / "data" / "hf_gap_push_staging" / "trades_fix_gap.parquet"
+    if not base.is_file() or not gap.is_file():
+        print("缺少 parquet 路径", base, gap)
+        return 1
+
+    tmpdir = tempfile.mkdtemp(prefix="duckdb_merge_test_")
+    out = Path(tmpdir) / "merged_sample.parquet"
+
+    cols = _common_trade_columns(base, gap)
+    col_sql = ", ".join(cols)
+    n = int(args.base_sample_rows)
+    gap_sub = f"read_parquet('{gap}')"
+    if int(args.gap_limit) > 0:
+        gap_sub = f"(SELECT {col_sql} FROM read_parquet('{gap}') LIMIT {int(args.gap_limit)})"
+
+    con = duckdb.connect()
+    con.execute(f"PRAGMA memory_limit='{args.memory_limit}'")
+    con.execute(f"PRAGMA temp_directory='{tmpdir}'")
+    con.execute(f"PRAGMA threads={int(args.threads)}")
+    con.execute("SET preserve_insertion_order=false")
+
+    sql = f"""
+    COPY (
+      SELECT * EXCLUDE (_rn) FROM (
+        SELECT
+          *,
+          ROW_NUMBER() OVER (PARTITION BY _ts, _tx, _mk, _tk ORDER BY _ts) AS _rn
+        FROM (
+          SELECT
+            CAST(CAST(timestamp AS VARCHAR) AS BIGINT) AS _ts,
+            lower(CAST(transaction_hash AS VARCHAR)) AS _tx,
+            lower(CAST(maker AS VARCHAR)) AS _mk,
+            lower(CAST(taker AS VARCHAR)) AS _tk,
+            {col_sql}
+          FROM (
+            SELECT {col_sql}
+            FROM read_parquet('{base}')
+            WHERE CAST(block_number AS UBIGINT) >= {int(args.base_min_block)}
+            LIMIT {n}
+          ) AS base_samp
+          UNION ALL
+          SELECT
+            CAST(CAST(timestamp AS VARCHAR) AS BIGINT),
+            lower(CAST(transaction_hash AS VARCHAR)),
+            lower(CAST(maker AS VARCHAR)),
+            lower(CAST(taker AS VARCHAR)),
+            {col_sql}
+          FROM {gap_sub} AS gap_s
+        ) u
+      ) x
+      WHERE _rn = 1
+    ) TO '{out}' (FORMAT PARQUET, COMPRESSION ZSTD);
+    """
+
+    t0 = time.perf_counter()
+    con.execute(sql)
+    elapsed = time.perf_counter() - t0
+    rss_mb = _max_rss_mb()
+
+    n = pq.read_metadata(out).num_rows
+    rep = {
+        "base_sample_rows": args.base_sample_rows,
+        "base_min_block": int(args.base_min_block),
+        "gap_limit": int(args.gap_limit) if args.gap_limit else None,
+        "gap_file": str(gap),
+        "merged_rows": n,
+        "elapsed_sec": round(elapsed, 2),
+        "process_max_rss_mb_estimate": round(rss_mb, 1),
+        "memory_limit_pragma": args.memory_limit,
+        "threads": int(args.threads),
+        "temp_directory": tmpdir,
+        "output": str(out),
+    }
+    print(json.dumps(rep, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gap_supplement/code/verify_fix_gap_3_50.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+"""
+完整验证 *fix_gap.parquet 是否包含 hf_orderfilled_gaps_2_50 元数据中
+missing_block_cnt in [min_mc, max_mc]（默认 3-50）所映到的 recovered 分片在 extract_trades 后产生的四键。
+
+1) 三表存在、行数、主链/时间窗粗检
+2) 路径集 S = gather_paths(min,max)；统计 |S| 与磁盘上是否存在
+3) 深度（默认开）：对 S 随机抽若干分片，重放 extract_trades，四键在 trades_fix_gap 中须全部命中
+
+用法:
+  export POLY_ROOT=/path/to/poly_data
+  cd Polymarket_data
+  python3 scripts/gap_recovery/verify_fix_gap_3_50.py \\
+    --trades .../trades_fix_gap.parquet
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+import re
+import sys
+from pathlib import Path
+
+import pyarrow.parquet as pq
+import pandas as pd
+
+REPO = Path(__file__).resolve().parents[2]
+POLY = Path(os.environ.get("POLY_ROOT", str(REPO.parent / "poly_data"))).resolve()
+SCR = REPO / "scripts" / "gap_recovery"
+TKEYS = ["timestamp", "transaction_hash", "maker", "taker"]
+
+
+def _gap_parquet_overlaps_block_range(p: Path, bmin: int, bmax: int) -> bool:
+    """分片名 gap_低_高 与 merged trades 的块窗有交集才算「可能进过」当前 merged。"""
+    m = re.search(r"^gap_(\d+)_(\d+)\.parquet$", p.name, re.IGNORECASE)
+    if not m:
+        return True
+    a, b = int(m[1]), int(m[2])
+    return a <= bmax and b >= bmin
+
+
+def _pick_default_trades() -> list[Path]:
+    c: list[Path] = [
+        REPO / "hf_push" / "gap_supplement" / "trades_fix_gap.parquet",
+        POLY / "data" / "hf_gap_merged_3_5" / "st_merged" / "trades_fix_gap.parquet",
+        POLY / "data" / "hf_gap_merged_bands" / "st_merged" / "trades_fix_gap.parquet",
+        POLY / "data" / "hf_gap_push_staging" / "trades_fix_gap.parquet",
+        POLY / "data" / "hf_gap_dataset_bundle" / "gap_supplement" / "trades_fix_gap.parquet",
+    ]
+    return [p for p in c if p.is_file()]
+
+
+def _keys_from_gap(p: Path, token_map: dict | None, cap: int) -> pd.DataFrame:
+    sys.path[:0] = [str(REPO), str(SCR)]
+    from gap_to_trades_quant_users_hf import _validate_columns  # noqa: WPS433
+    from polymarket.processors.trades import extract_trades  # noqa: WPS433
+
+    t = pq.read_table(p)
+    cols = list(t.column_names)
+    if _validate_columns(cols):
+        return pd.DataFrame(columns=TKEYS)
+    ev = t.to_pandas().to_dict("records")
+    df = extract_trades(ev, token_map)
+    if df.empty or len(df) == 0:
+        return pd.DataFrame(columns=TKEYS)
+    df = df[[c for c in TKEYS if c in df.columns]]
+    for c in TKEYS:
+        if c not in df.columns:
+            return pd.DataFrame(columns=TKEYS)
+    out = df.drop_duplicates(subset=TKEYS, keep="first").head(int(cap)).copy()
+    return _normalize_trades_keys_for_join(out)
+
+
+def _normalize_trades_keys_for_join(df: pd.DataFrame) -> pd.DataFrame:
+    """与 merged parquet 做等值连接时对齐: timestamp→int64, 三列小写 str。"""
+    if df is None or len(df) < 1:
+        return df
+    k = df.copy()
+    if "timestamp" in k.columns:
+        k["timestamp"] = pd.to_numeric(k["timestamp"], errors="coerce").fillna(0).astype("int64")
+    for c in ("transaction_hash", "maker", "taker"):
+        if c in k.columns:
+            k[c] = k[c].astype("string").str.lower()
+    return k
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--trades", type=Path, default=None)
+    ap.add_argument("--quant", type=Path, default=None)
+    ap.add_argument("--users", type=Path, default=None)
+    ap.add_argument("--min-mc", type=int, default=3)
+    ap.add_argument("--max-mc", type=int, default=50)
+    ap.add_argument(
+        "--interval-table", type=Path, default=POLY / "data" / "hf_orderfilled_gaps_2_50_intervals.parquet"
+    )
+    ap.add_argument("--sample-paths", type=int, default=40, help="从 3-50 路径集随机抽 N 个分片做重放+键级校验，0=跳过")
+    ap.add_argument("--max-keys", type=int, default=2000, help="每个抽中分片最多取多少行 trade 键")
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--write-json", type=Path, default=None, help="在默认报告之外再写一份到该路径")
+    ap.add_argument(
+        "--no-default-json",
+        action="store_true",
+        help="不写入 $POLY_ROOT/data/hf_merge_exec/verify_fix_gap_3_50_report.json",
+    )
+    args = ap.parse_args()
+    it = args.interval_table if args.interval_table.is_absolute() else (POLY / args.interval_table).resolve()
+    if not it.is_file():
+        print(f"无区间表: {it}", flush=True)
+        return 1
+
+    tp = args.trades
+    if tp is None:
+        cands = _pick_default_trades()
+        if not cands:
+            print("未找到 trades_fix_gap.parquet，请 --trades 指定", flush=True)
+            return 2
+        tp = cands[0]
+        print(f"使用: {tp}", flush=True)
+    if not Path(tp).is_file():
+        print(f"无 trades: {tp}", flush=True)
+        return 2
+
+    qp = args.quant or (Path(tp).parent / "quant_fix_gap.parquet")
+    up = args.users or (Path(tp).parent / "users_fix_gap.parquet")
+    n_tr = int(pq.read_metadata(tp).num_rows)
+    nq = int(pq.read_metadata(qp).num_rows) if Path(qp).is_file() else 0
+    nu = int(pq.read_metadata(up).num_rows) if Path(up).is_file() else 0
+    if n_tr > 0 and nq == 0:
+        print("警告: trades 有行而 quant 为空; 与 gap 管线条款不符", flush=True)
+    if n_tr > 0 and nu == 0:
+        print("警告: trades 有行而 users 为空; 与 gap 管线条款不符", flush=True)
+
+    sys.path[:0] = [str(REPO), str(SCR)]
+    from gap_interval_paths import gather_paths_for_mc_range  # noqa: WPS433, E402
+    from polymarket.processors.trades import load_token_mapping  # noqa: WPS433, E402
+
+    paths = gather_paths_for_mc_range(POLY, it, int(args.min_mc), int(args.max_mc))
+    import duckdb  # noqa: WPS433, E402, PLC0415
+
+    tps0 = str(tp).replace("'", "''")
+    con0 = duckdb.connect()
+    br = con0.execute(
+        f"""
+        SELECT
+          min(block_number) AS bmin, max(block_number) AS bmax,
+          min(try_cast("timestamp" AS BIGINT)) AS tmin, max(try_cast("timestamp" AS BIGINT)) AS tmax
+        FROM read_parquet('{tps0}')
+        """
+    ).fetchone()
+    con0.close()
+    bmin, bmax = (int(br[0] or 0), int(br[1] or 0)) if br else (0, 0)
+    paths_merged_window = [p for p in paths if _gap_parquet_overlaps_block_range(p, bmin, bmax)]
+
+    def _build_nonempty_pool(
+        pool_paths: list[Path], need: int, cap_scan: int, r: random.Random
+    ) -> tuple[list[Path], int, int]:
+        """在打乱后的路径上只读元数据，收够非空分片池 (>= need 或到 cap_scan)。返回 (池, 扫描数, 非空数)。"""
+        c = list(pool_paths)
+        r.shuffle(c)
+        out: list[Path] = []
+        scanned = 0
+        for f in c:
+            if scanned >= cap_scan or len(out) >= max(need, int(args.sample_paths) * 3, 20):
+                break
+            scanned += 1
+            if not f.is_file():
+                continue
+            try:
+                if int(pq.read_metadata(f).num_rows) < 1:
+                    continue
+            except OSError:
+                continue
+            out.append(f)
+        return out, scanned, len(out)
+
+    r0 = random.Random(int(args.seed) + 911)
+    sp = int(args.sample_paths)
+    want_pool = sp * 4 if sp > 0 else 0
+    pool_in = paths_merged_window if paths_merged_window else paths
+    non_empty, scanned_meta, n_nonempty = _build_nonempty_pool(
+        pool_in, want_pool, min(12000, max(2000, len(pool_in) or 1)), r0
+    )
+    rep: dict = {
+        "trades": str(tp),
+        "quant": str(qp) if Path(qp).is_file() else None,
+        "users": str(up) if Path(up).is_file() else None,
+        "rows": {"trades": n_tr, "quant": nq, "users": nu},
+        "interval_table": str(it),
+        "min_mc": args.min_mc,
+        "max_mc": args.max_mc,
+        "path_count_3_50": len(paths),
+        "path_count_3_50_in_merged_block_window": len(paths_merged_window),
+        "merged_trades_block_range": [bmin, bmax],
+        "trades_block_range": [bmin, bmax],
+        "trades_ts_range": [int(br[2] or 0), int(br[3] or 0)] if br else [None, None],
+        "shards_scanned_for_nonempty": scanned_meta,
+        "nonempty_found_in_scan": n_nonempty,
+    }
+    if not paths_merged_window and len(paths) > 0:
+        rep["window_note"] = "3-50 在 merged 块号窗下无分片名交集, 用全 3-50 路径作池(部分分片与 merged 块区可能不一致)"
+    tps = tps0
+    mpath = POLY / "huggingface_data" / "raw" / "markets.parquet"
+    tmap = load_token_mapping(mpath) if mpath.is_file() else None
+    rep["markets_for_extract"] = str(mpath) if mpath.is_file() else None
+
+    miss_total = 0
+    n_checked = 0
+    paths_tried = 0
+    files_with_trades = 0
+    if int(args.sample_paths) > 0 and n_nonempty < 1 and paths:
+        rep["warning_empty_shards"] = (
+            f"在随机扫描的 {scanned_meta} 个 3-50 分片元数据中无非空; 可扩大 VERIFY_SCAN_CAP 或查回补"
+        )
+    to_sample = non_empty
+    if int(args.sample_paths) > 0 and to_sample:
+        rng = random.Random(int(args.seed))
+        smp = list(to_sample)
+        rng.shuffle(smp)
+        take = min(int(args.sample_paths), len(smp))
+        smp = smp[:take]
+        con = duckdb.connect()
+        con.execute(
+            f"""
+            CREATE OR REPLACE VIEW v_m AS
+            SELECT
+              try_cast("timestamp" AS BIGINT) AS "timestamp",
+              lower(CAST(transaction_hash AS VARCHAR)) AS transaction_hash,
+              lower(CAST(maker AS VARCHAR)) AS maker,
+              lower(CAST(taker AS VARCHAR)) AS taker
+            FROM read_parquet('{tps}')
+            """
+        )
+        df_self = con.execute("SELECT * FROM v_m LIMIT 2").df()
+        kself = _normalize_trades_keys_for_join(df_self)
+        con.register("kself", kself)
+        self_miss = con.execute(
+            """
+            SELECT COUNT(*)::BIGINT
+            FROM kself k
+            ANTI JOIN v_m m
+              ON m."timestamp" IS NOT DISTINCT FROM k."timestamp"
+             AND m.transaction_hash IS NOT DISTINCT FROM k.transaction_hash
+             AND m.maker IS NOT DISTINCT FROM k.maker
+             AND m.taker IS NOT DISTINCT FROM k.taker
+            """
+        ).fetchone()
+        con.unregister("kself")
+        rep["anti_join_sanity_against_self"] = int(self_miss[0] or 0)
+        for p in smp:
+            if not p.is_file():
+                continue
+            paths_tried += 1
+            kf = _keys_from_gap(Path(p), tmap, int(args.max_keys))
+            if kf is None or len(kf) == 0:
+                continue
+            files_with_trades += 1
+            con.register("kff", kf)
+            m = con.execute(
+                """
+                SELECT COUNT(*)::BIGINT
+                FROM kff k
+                ANTI JOIN v_m m
+                  ON m."timestamp" IS NOT DISTINCT FROM k."timestamp"
+                 AND m.transaction_hash IS NOT DISTINCT FROM k.transaction_hash
+                 AND m.maker IS NOT DISTINCT FROM k.maker
+                 AND m.taker IS NOT DISTINCT FROM k.taker
+                """
+            ).fetchone()
+            n_checked += int(len(kf))
+            miss_total += int(m[0] or 0)
+            try:
+                con.unregister("kff")
+            except (AttributeError, TypeError, ValueError):
+                pass
+        con.close()
+
+    rep["key_check"] = {
+        "sample_paths_requested": int(args.sample_paths),
+        "paths_tried": paths_tried,
+        "files_had_trades": files_with_trades,
+        "keys_compared": n_checked,
+        "keys_missing_in_merged": int(miss_total),
+    }
+    if int(args.sample_paths) > 0 and len(paths) == 0:
+        rep["ok"] = False
+        rep["err"] = "元数据 [min,max] 未映到任何分片 (path_count=0)"
+    elif int(args.sample_paths) > 0 and n_nonempty < 1 and paths:
+        rep["ok"] = False
+        rep["err"] = f"在扫描 {scanned_meta} 个分片后仍无非空文件；无法重放四键 (nonempty_found=0)"
+    elif int(args.sample_paths) > 0 and paths and n_checked == 0 and paths_tried > 0:
+        rep["ok"] = False
+        rep["err"] = "抽中分片均未产出可校键（extract_trades 无行或列不符）；可增大 --sample-paths 或查 markets/分片"
+    elif miss_total:
+        rep["ok"] = False
+        rep["err"] = "在 merged 与 (元数据+块窗) 抽样的 3-50 分片重放四键 未全部命中; 本 trades 或未经含 [3,50] 的合并、或与 gap_to 来源集不一致, 需重跑 build_merge 小档+大档"
+        rep["diagnosis"] = (
+            "当 keys_compared>0 且全未命中: 多为此份 trades_fix_gap 未合入 3-50 表映分片之 OrderFilled, "
+            "或仅为全量/大档 staging, 与 quant/users 可仍有千百万行(来自其它 gap)。"
+        )
+    else:
+        rep["ok"] = n_tr > 0
+        if n_tr <= 0:
+            rep["err"] = "trades_fix_gap 为空"
+        if int(args.sample_paths) == 0:
+            rep["note"] = "未做四键重放校验，请加 --sample-paths 如 50"
+    mrep = Path(tp).parent / "merge_gap_staging_pair_report.txt"
+    if mrep.is_file():
+        rep["merge_report_snippet"] = mrep.read_text(encoding="utf-8")[:800]
+
+    wroot = POLY / "data" / "hf_merge_exec"
+    wroot.mkdir(parents=True, exist_ok=True)
+    to_write: list[Path] = []
+    if not args.no_default_json:
+        to_write.append((wroot / "verify_fix_gap_3_50_report.json").resolve())
+    if args.write_json is not None:
+        wj = Path(args.write_json).expanduser()
+        to_write.append(wj.resolve() if wj.is_absolute() else (Path.cwd() / wj).resolve())
+    seen: set[Path] = set()
+    ded: list[Path] = []
+    for p in to_write:
+        r = p.resolve()
+        if r in seen:
+            continue
+        seen.add(r)
+        ded.append(r)
+    wpaths: list[str] = []
+    for p in ded:
+        p.parent.mkdir(parents=True, exist_ok=True)
+        wpaths.append(str(p))
+        p.write_text(json.dumps(rep, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    if wpaths:
+        rep["report_files"] = wpaths
+    print(json.dumps(rep, ensure_ascii=False, indent=2), flush=True)
+    return 0 if rep.get("ok") and n_tr > 0 and miss_total == 0 else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gap_supplement/code/verify_hf_orderfilled_gaps_2_50_duckdb.py

@@ -0,0 +1,309 @@
+#!/usr/bin/env python3
+"""
+DuckDB + HTTPS 读取 Hugging Face orderfilled_part1..4.parquet，
+按「有数据的区块号」排序后，计算相邻块之间的空档长度 missing_cnt = next - prev - 1，
+筛选 2 <= missing_cnt <= 50（即空档内缺失 2～50 个连续区块号）。
+
+输出：
+- data/hf_orderfilled_gaps_2_50_summary.json  汇总与直方图、与本地 JSON 对照
+- data/hf_orderfilled_gaps_2_50_intervals.parquet  全部空档区间（体量可控）
+- data/hf_orderfilled_gaps_0_5_intervals.parquet  missing_block_cnt 在 0～5 的子表（含单块空档，见 SQL 说明）
+- data/hf_orderfilled_gaps_3_5_intervals.parquet  missing_block_cnt 在 3～5
+- data/hf_orderfilled_gaps_5_10_intervals.parquet  missing_block_cnt 在 5～10
+- data/hf_orderfilled_gaps_10_30_intervals.parquet  missing_block_cnt 仅 10～30 的子集
+- data/hf_orderfilled_gaps_30_50_intervals.parquet  missing_block_cnt 仅 30～50 的子集（小空档专项回补）
+
+可选：--rpc-sample N  对随机 N 个空档做 eth_getLogs（两合约 OrderFilled），若 N>0 而链上
+日志数>0 则记为「HF 相对链上可能遗漏」的样本（全量 RPC 过慢）。
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import sys
+import time
+from pathlib import Path
+
+import duckdb
+import os
+
+import polars as pl
+
+REPO = Path(__file__).resolve().parents[2]
+POLY = Path(os.environ.get("POLY_ROOT", str(REPO.parent / "poly_data")))
+DATA = POLY / "data"
+OUT_SUMMARY = DATA / "hf_orderfilled_gaps_2_50_summary.json"
+OUT_GAPS = DATA / "hf_orderfilled_gaps_2_50_intervals.parquet"
+OUT_GAPS_0_5 = DATA / "hf_orderfilled_gaps_0_5_intervals.parquet"
+OUT_GAPS_3_5 = DATA / "hf_orderfilled_gaps_3_5_intervals.parquet"
+OUT_GAPS_5_10 = DATA / "hf_orderfilled_gaps_5_10_intervals.parquet"
+OUT_GAPS_10_30 = DATA / "hf_orderfilled_gaps_10_30_intervals.parquet"
+OUT_GAPS_30_50 = DATA / "hf_orderfilled_gaps_30_50_intervals.parquet"
+DETECTED_GAPS = DATA / "detected_gaps.json"
+SMALL_GAPS_10_50 = DATA / "small_gaps_10_50.json"
+
+HF_URLS = [
+    "https://huggingface.co/datasets/SII-WANGZJ/Polymarket_data/resolve/main/orderfilled_part1.parquet",
+    "https://huggingface.co/datasets/SII-WANGZJ/Polymarket_data/resolve/main/orderfilled_part2.parquet",
+    "https://huggingface.co/datasets/SII-WANGZJ/Polymarket_data/resolve/main/orderfilled_part3.parquet",
+    "https://huggingface.co/datasets/SII-WANGZJ/Polymarket_data/resolve/main/orderfilled_part4.parquet",
+]
+
+CONTRACTS = [
+    "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E",
+    "0xC5d563A36AE78145C45a50134d48A1215220f80a",
+]
+TOPIC = "0xd0a08e8c493f9c94f29311604c9de1b4e8c8d4c06bd0c789af57f2d65bfec0f6"
+RPC_NODES = [
+    "https://polygon-bor-rpc.publicnode.com",
+    "https://1rpc.io/matic",
+]
+
+
+def _rpc_log_count(start_b: int, end_b: int) -> int:
+    import requests
+
+    payload = {
+        "jsonrpc": "2.0",
+        "method": "eth_getLogs",
+        "params": [
+            {
+                "fromBlock": hex(start_b),
+                "toBlock": hex(end_b),
+                "address": CONTRACTS,
+                "topics": [TOPIC],
+            }
+        ],
+        "id": 1,
+    }
+    for node in RPC_NODES:
+        try:
+            r = requests.post(node, json=payload, timeout=45)
+            if r.status_code != 200:
+                continue
+            j = r.json()
+            if j.get("error"):
+                continue
+            return len(j.get("result") or [])
+        except OSError:
+            continue
+    return -1
+
+
+def _load_detected_small_2_50() -> tuple[int, list[dict]]:
+    """detected_gaps.json 中区段跨度 (end-start+1) 在 [2,50] 的条数（仅统计，不全量载入内存过大时流式）。"""
+    if not DETECTED_GAPS.is_file():
+        return 0, []
+    with open(DETECTED_GAPS, encoding="utf-8") as f:
+        arr = json.load(f)
+    small = [g for g in arr if (int(g["end"]) - int(g["start"]) + 1) <= 50 and (int(g["end"]) - int(g["start"]) + 1) >= 2]
+    return len(small), small[:5000]
+
+
+def _small_gaps_10_50_stats() -> dict:
+    if not SMALL_GAPS_10_50.is_file():
+        return {"exists": False}
+    with open(SMALL_GAPS_10_50, encoding="utf-8") as f:
+        g = json.load(f)
+    # 旧脚本 gap_size = next_block - block_number；缺失块数 = gap_size - 1
+    miss = [int(x["gap_size"]) - 1 for x in g if "gap_size" in x]
+    in_2_50 = sum(1 for m in miss if 2 <= m <= 50)
+    in_10_50 = sum(1 for m in miss if 10 <= m <= 50)
+    return {
+        "exists": True,
+        "records": len(g),
+        "missing_blocks_eq_gap_size_minus_1_in_2_50": in_2_50,
+        "missing_blocks_in_10_50": in_10_50,
+    }
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--rpc-sample", type=int, default=0, help="随机 RPC 校验空档条数（建议<=500）")
+    ap.add_argument("--seed", type=int, default=42)
+    args = ap.parse_args()
+
+    urls = ", ".join(f"'{u}'" for u in HF_URLS)
+    con = duckdb.connect()
+    con.execute("INSTALL httpfs; LOAD httpfs;")
+    con.execute("PRAGMA threads=8")
+
+    t0 = time.time()
+    print(
+        "DuckDB：从 HF 四份 parquet 取 DISTINCT block_number 并计算相邻空档；"
+        "空档 CTE 使用 nb>bn+1 以含「仅缺 1 个块」的窄空档，再按区间写出 2～50 与各子表 …",
+        flush=True,
+    )
+    q = f"""
+    WITH blocks AS (
+      SELECT DISTINCT try_cast(trim(cast(block_number AS VARCHAR)) AS BIGINT) AS bn
+      FROM read_parquet([{urls}])
+      WHERE try_cast(trim(cast(block_number AS VARCHAR)) AS BIGINT) IS NOT NULL
+    ),
+    ord AS (
+      SELECT bn, LEAD(bn) OVER (ORDER BY bn) AS nb FROM blocks
+    ),
+    gaps AS (
+      SELECT
+        bn + 1 AS gap_start,
+        nb - 1 AS gap_end,
+        CAST(nb - bn - 1 AS INTEGER) AS missing_block_cnt
+      FROM ord
+      WHERE nb IS NOT NULL AND nb > bn + 1
+    )
+    SELECT gap_start, gap_end, missing_block_cnt
+    FROM gaps
+    WHERE gap_start <= gap_end
+    ORDER BY gap_start;
+    """
+    gaps_all = con.execute(q).pl()
+    gaps_df = gaps_all.filter(
+        pl.col("missing_block_cnt").is_between(2, 50)  # noqa: PLR2004
+    )
+    dt = time.time() - t0
+    n = gaps_df.height
+    n_all = gaps_all.height
+    print(
+        f"完成：2～50 空档 {n} 条，原始相邻空档（含缺 1 块）{n_all} 条，耗时 {dt:.1f}s",
+        flush=True,
+    )
+
+    hist = (
+        gaps_df.group_by("missing_block_cnt")
+        .len()
+        .sort("missing_block_cnt")
+        .rename({"len": "gap_interval_count"})
+    )
+    gap_min = int(gaps_df["gap_start"].min()) if n else None
+    gap_max = int(gaps_df["gap_end"].max()) if n else None
+
+    detected_n, _ = _load_detected_small_2_50()
+    sg = _small_gaps_10_50_stats()
+
+    rpc_hits: list[dict] = []
+    if args.rpc_sample > 0 and n > 0:
+        random.seed(args.seed)
+        idx = list(range(n))
+        random.shuffle(idx)
+        take = min(args.rpc_sample, n)
+        print(f"RPC 抽样校验 {take} 个空档 …", flush=True)
+        for i in idx[:take]:
+            row = gaps_df.row(i, named=True)
+            gs, ge = int(row["gap_start"]), int(row["gap_end"])
+            c = _rpc_log_count(gs, ge)
+            if c > 0:
+                rpc_hits.append(
+                    {
+                        "gap_start": gs,
+                        "gap_end": ge,
+                        "missing_block_cnt": int(row["missing_block_cnt"]),
+                        "rpc_orderfilled_logs": c,
+                    }
+                )
+            time.sleep(0.12)
+
+    summary = {
+        "hf_urls": HF_URLS,
+        "duckdb_elapsed_sec": round(dt, 2),
+        "hf_consecutive_block_gaps_missing_blocks_between_2_and_50": {
+            "interval_count": n,
+            "gap_block_number_min": gap_min,
+            "gap_block_number_max": gap_max,
+            "histogram_missing_block_cnt": hist.to_dicts() if n else [],
+        },
+        "local_detected_gaps_json": {
+            "path": str(DETECTED_GAPS),
+            "intervals_with_span_2_to_50_blocks": detected_n,
+            "note": "detected_gaps 为另一套检测口径（与 HF 相邻块空档非一一对应），仅并列统计。",
+        },
+        "local_small_gaps_10_50_json": {**sg, "path": str(SMALL_GAPS_10_50)},
+        "rpc_sample": {
+            "requested": args.rpc_sample,
+            "intervals_with_chain_orderfilled_gt_0": len(rpc_hits),
+            "hits_sample": rpc_hits[:50],
+            "interpretation": (
+                "若 hits>0：这些区块在链上两合约确有 OrderFilled，但 HF 相邻块空档内无对应区块数据，"
+                "可视为 HF 快照相对链上的稀疏/遗漏信号（仍可能部分在其他数据源）。"
+            ),
+        },
+        "intervals_parquet": str(OUT_GAPS),
+    }
+
+    DATA.mkdir(parents=True, exist_ok=True)
+    n_0_5 = 0
+    n_3_5 = 0
+    n_5_10 = 0
+    n_10_30 = 0
+    n_30_50 = 0
+    if n:
+        gaps_df.write_parquet(OUT_GAPS, compression="zstd")
+    if n_all:
+        g_0_5 = gaps_all.filter(
+            pl.col("missing_block_cnt").is_between(0, 5)  # noqa: PLR2004
+        )
+        n_0_5 = g_0_5.height
+        if n_0_5:
+            g_0_5.write_parquet(OUT_GAPS_0_5, compression="zstd")
+        g_3_5 = gaps_all.filter(
+            pl.col("missing_block_cnt").is_between(3, 5)  # noqa: PLR2004
+        )
+        n_3_5 = g_3_5.height
+        if n_3_5:
+            g_3_5.write_parquet(OUT_GAPS_3_5, compression="zstd")
+        g_5_10 = gaps_all.filter(
+            pl.col("missing_block_cnt").is_between(5, 10)  # noqa: PLR2004
+        )
+        n_5_10 = g_5_10.height
+        if n_5_10:
+            g_5_10.write_parquet(OUT_GAPS_5_10, compression="zstd")
+        g_10_30 = gaps_all.filter(
+            pl.col("missing_block_cnt").is_between(10, 30)  # noqa: PLR2004
+        )
+        n_10_30 = g_10_30.height
+        if n_10_30:
+            g_10_30.write_parquet(OUT_GAPS_10_30, compression="zstd")
+        g_30_50 = gaps_all.filter(
+            pl.col("missing_block_cnt").is_between(30, 50)  # noqa: PLR2004
+        )
+        n_30_50 = g_30_50.height
+        if n_30_50:
+            g_30_50.write_parquet(OUT_GAPS_30_50, compression="zstd")
+    summary["hf_gaps_missing_blocks_0_to_5_only"] = {
+        "interval_count": int(n_0_5),
+        "path": str(OUT_GAPS_0_5),
+        "note": "子集：missing_block_cnt∈[0,5]（0 在相邻块空档中通常无行），run_recent: --hf-missing-min 0 --hf-missing-max 5",
+    }
+    summary["hf_gaps_missing_blocks_3_to_5_only"] = {
+        "interval_count": int(n_3_5),
+        "path": str(OUT_GAPS_3_5),
+        "note": "子集：missing_block_cnt∈[3,5]，--hf-missing-min 3 --hf-missing-max 5",
+    }
+    summary["hf_gaps_missing_blocks_5_to_10_only"] = {
+        "interval_count": int(n_5_10),
+        "path": str(OUT_GAPS_5_10),
+        "note": "子集：missing_block_cnt∈[5,10]（与 0～5 在 5 处重叠，同一区间只下一份片），--hf-missing-min 5 --hf-missing-max 10",
+    }
+    summary["hf_gaps_missing_blocks_10_to_30_only"] = {
+        "interval_count": int(n_10_30),
+        "path": str(OUT_GAPS_10_30),
+        "note": "子集：missing_block_cnt∈[10,30]，供专项下载（run_recent_recovery_parallel --use-hf-intervals --hf-missing-min 10 --hf-missing-max 30）",
+    }
+    summary["hf_gaps_missing_blocks_30_to_50_only"] = {
+        "interval_count": int(n_30_50),
+        "path": str(OUT_GAPS_30_50),
+        "note": "子集：missing_block_cnt∈[30,50]，供小空档专项下载（run_recent_recovery_parallel --use-hf-intervals）",
+    }
+    OUT_SUMMARY.write_text(
+        json.dumps(summary, indent=2, ensure_ascii=False, default=str),
+        encoding="utf-8",
+    )
+    print(json.dumps({k: v for k, v in summary.items() if k != "rpc_sample"}, indent=2, ensure_ascii=False)[:4000])
+    print(f"… 完整见 {OUT_SUMMARY}", flush=True)
+    if rpc_hits:
+        print(f"RPC 发现链上有日志的空档样例数: {len(rpc_hits)}", flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gap_supplement/merge_gap_staging_pair_report.txt

@@ -0,0 +1 @@
+rows_a=1374592 rows_b=7938947 concat=9313539 dedup=9302609 quant=5719281 users=11438562

gap_supplement/quant_fix_gap.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c64d5cc24a8e79a4632450aa6ccdd3aff31beb8f4b0206c331c362835d7e1cf
+size 378968888

gap_supplement/trades_fix_gap.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:363ca4ffcca309313d4a57c982c45f4a1a8d18d2744e1b88d2cb1aeae8f97984
+size 586646178

gap_supplement/users_fix_gap.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1cecc21b8d513d64319b91074aad776fc125f323c20eefaee621d0fc69d99fb
+size 252273446