samscrack/solidity-cpt-top10-quality

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 — 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"), 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)

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

import pyarrow.parquet as pq
table = pq.read_table("top10.parquet")
df = table.to_pandas()
print(df.head())

Streaming (for low-RAM environments)

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 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

@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:

@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 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