Initial release: 23,471 quality-filtered + deduped Solidity files (~86M tokens)

README.md

@@ -0,0 +1,193 @@
+---
+license: cc-by-4.0
+language:
+  - en
+  - code
+tags:
+  - solidity
+  - smart-contracts
+  - blockchain
+  - ethereum
+  - code
+  - continued-pretraining
+  - quality-filtered
+size_categories:
+  - 10K<n<100K
+task_categories:
+  - text-generation
+  - fill-mask
+pretty_name: Solidity CPT Top-10% Quality-Filtered Corpus
+configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path: top10.parquet
+---
+
+# Solidity CPT Top-10% Quality-Filtered Corpus
+
+A curated, deduplicated corpus of **23,471 modern Solidity source files (~86M tokens)** intended for continued-pretraining (CPT) of code LLMs on smart-contract code.
+
+It's the top 10% slice (by composite quality score) of a larger raw corpus that combined:
+
+- [`ASSERT-KTH/DISL`](https://huggingface.co/datasets/ASSERT-KTH/DISL) — 514 k unique deployed Solidity files, deduped at file level
+- 30 hand-picked GitHub blue-chip protocols (OpenZeppelin, Uniswap v2/v3/v4, Aave v3, Compound, Morpho, EigenLayer, Pendle, Solady, Seaport, LayerZero, ENS, Optimism, Arbitrum, Polygon L1, etc.)
+
+After scoring all 234 877 raw rows on a 0–115 quality scale (see *Quality filter* below) and keeping the top 10 %, the result is **23 487 source files**. After cross-source SHA-256 deduplication of whitespace-normalised text, **23 471 unique files** remain. This is what's published here.
+
+## At a glance
+
+| | |
+|---|---|
+| Rows | 23,471 |
+| Total characters | 342,858,470 |
+| Approx. tokens (Qwen3.6 tokenizer, ~4 chars/tok) | **~86M** |
+| Average chars per row | 14,607 |
+| Source: `disl` (Etherscan-verified) | 20,975 (89 %) |
+| Source: `github/<protocol>` (audited blue-chips) | 2,496 (11 %) |
+| File format | parquet (snappy) + jsonl |
+
+## Schema
+
+Each row is one Solidity source file:
+
+| Field | Type | Description |
+|---|---|---|
+| `text` | string | Raw Solidity source code |
+| `source` | string | `disl` (Etherscan-verified contract) or `github/<repo-slug>` |
+| `address` | string | Ethereum mainnet address (DISL only) |
+| `name` | string | Contract name |
+| `compiler` | string | Solc version e.g. `v0.8.20+commit.a1b2c3d4` (DISL only) |
+| `license` | string | License from Etherscan (often empty) |
+| `path` | string | Path inside the GitHub repo (GitHub rows only) |
+| `n_chars` | int | Length of `text` in characters |
+
+## Quality filter (composite 0–115 score)
+
+Every raw row was scored independently on each signal; rows scoring **≥ 55 (top-10% threshold)** were kept.
+
+| Signal | Points |
+|---|---:|
+| Pragma 0.8.20+ (modern compiler) | +30 |
+| Pragma 0.8.13–19 | +20 |
+| Pragma 0.8.x (any) | +10 |
+| Has SPDX license header | +10 |
+| Has `@notice` / `@dev` NatSpec | +10 |
+| Has `@param` / `@return` NatSpec | +10 |
+| Comment density 5–30 % | +10 |
+| Uses custom errors (`error X();`) | +5 |
+| Uses `unchecked { ... }` blocks | +5 |
+| No SafeMath import (avoids old patterns) | +5 |
+| Size 500–8000 chars | +10 |
+| Source: GitHub blue-chip | +20 |
+
+**Pre-scoring filters** (applied to all sources before scoring):
+- Pragma must be 0.8.x (0.4–0.7 dropped — incompatible with `forge-std/Test.sol >=0.8.13`)
+- Not flagged as `proxy=True` in DISL (drops EIP-1167/1967 minimal proxies)
+- Has at least one `contract X` declaration (drops interface-only / library-only files)
+- 200 ≤ length ≤ 50000 chars (drops stubs and mega-flatteners)
+- For GitHub: vendored `lib/openzeppelin-contracts`, `lib/forge-std`, `out/`, `cache/`, `typechain-types/` stripped
+
+**Post-quality dedup**: SHA-256 of the whitespace-collapsed text. Caught 16 cross-source duplicates.
+
+## Score distribution of the top-10% slice
+
+The 23 471 surviving rows have scores in [55, 115]. The mode falls in the 55–69 band (typical "modern, idiomatic, audited" Solidity). The long tail (90+) skews heavily toward GitHub blue-chips and DISL contracts that cite their license + use NatSpec extensively.
+
+## Suggested use
+
+This corpus is sized for **adapter-based CPT** (LoRA / DoRA) on a 7B–30B+ code LM. Per [Biderman et al. 2024 ("LoRA Learns Less and Forgets Less")](https://arxiv.org/abs/2405.09673), useful adapter-CPT plateaus around 200M–1B tokens — this 86M corpus is on the lower end of that range and works well as a fast first-iteration validation slice.
+
+For larger adapter-CPT runs, the same pipeline produces:
+- **top30** tier (~70 k rows, ~229M tokens)
+- **top60** tier (~141 k rows, ~458M tokens)
+
+(Not yet published. Open an issue if you'd like them released.)
+
+## Loading
+
+### `datasets` library (recommended)
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("samscrack/solidity-cpt-top10-quality", split="train")
+print(ds)               # ~23 471 rows
+print(ds[0]["text"][:500])
+```
+
+### Direct parquet
+
+```python
+import pyarrow.parquet as pq
+table = pq.read_table("top10.parquet")
+df = table.to_pandas()
+print(df.head())
+```
+
+### Streaming (for low-RAM environments)
+
+```python
+ds = load_dataset(
+    "samscrack/solidity-cpt-top10-quality",
+    split="train",
+    streaming=True,
+)
+for row in ds.take(3):
+    print(row["source"], row["name"], row["compiler"])
+```
+
+## Suggested CPT recipe (Qwen3.6-27B reference)
+
+This corpus was built for the [Qwopus3.6-27B-solidity-cpt-stageA](https://huggingface.co/samscrack/Qwopus3.6-27B-solidity-cpt-stageA) pipeline. The recipe used:
+
+- LoRA r=64, α=64, target modules: `q_proj` `k_proj` `v_proj` `o_proj` `gate_proj` `up_proj` `down_proj` `out_proj`
+- Megatron-style packing into 8192-token sequences with EOS separators
+- LR 5e-5 (cosine), bf16 + 4-bit base (QLoRA), 1 epoch
+- Tokenized with the Qwen3.6 tokenizer (vocab 152 k)
+
+A Stage-A CPT over a 1500-sequence (~12M token) subset of this corpus showed loss drop from a warmup peak of 0.67 to a stable 0.36–0.41 plateau in ~40 steps — clear evidence the data is high-signal for adapter-CPT.
+
+## License & legal notes
+
+This dataset is released under **CC BY 4.0**, inheriting the most-restrictive upstream license (DISL is CC BY 4.0).
+
+**Per-row provenance varies**:
+- DISL rows: derived from Etherscan public-verified contracts. The dataset (and DISL itself) are CC BY 4.0; **the underlying contract source has whatever license the deployer chose** — often empty / "unspecified" / all-rights-reserved by default. Suitable for research and adapter-style CPT, not necessarily safe for redistribution-as-source.
+- GitHub blue-chip rows: each repo has its own SPDX header. Most are MIT or Apache-2.0; some Uniswap pieces are BUSL/GPL. Inspect the `path` field and the upstream repo if license matters for your use case.
+
+If you need stronger commercial-use guarantees, restrict to rows where:
+- `source` starts with `github/`, AND
+- `text` contains an explicit MIT or Apache-2.0 SPDX line near the top.
+
+## Citation
+
+```bibtex
+@misc{solidity_cpt_top10_2026,
+  title  = {Solidity CPT Top-10\% Quality-Filtered Corpus},
+  author = {samscrack},
+  year   = {2026},
+  url    = {https://huggingface.co/datasets/samscrack/solidity-cpt-top10-quality}
+}
+```
+
+If you use this data, please also cite the upstream sources:
+
+```bibtex
+@misc{disl_2024,
+  title  = {DISL: Fueling Research with A Large Dataset of Solidity Smart Contracts},
+  author = {Storhaug, Andreas et al.},
+  year   = {2024},
+  url    = {https://arxiv.org/abs/2403.16861}
+}
+```
+
+## Acknowledgements
+
+- [ASSERT-KTH](https://huggingface.co/ASSERT-KTH) for releasing DISL
+- The OpenZeppelin, Uniswap, Aave, Compound, Morpho, EigenLayer, Pendle, Solady, Seaport, LayerZero, ENS, Optimism, Arbitrum, and Polygon teams for keeping their protocol code public and auditable
+- The Foundry team for forge-std (used as the `>=0.8.13` floor for pragma filtering)
+
+## Changelog
+
+- **2026-05-03** — initial release; 23 471 rows, ~86M tokens, top 10% by composite quality score

top10.parquet

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