Pith. sign in

REVIEW 4 major objections 6 minor 59 references

Trap tokens in ERC-20 contracts can be caught by a three-stage pipeline that normalizes code, lets an LLM judge intent, and replays suspicious paths on a forked chain, reaching 81.8% precision and 85.4% recall.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

TrapHunter detects six categories of malicious ERC-20 'trap token' logic by combining Abstract Behavior Trees, Augmented Path Graphs, LLM intent reasoning, and fork-based validation, reaching 81.8% precision / 85.4% recall.

T0 review reviewed 2026-08-01 challenge →

load-bearing objection A useful taxonomy and a serious pipeline, but the headline precision claim overstates what the paper's own per-category numbers show. the 4 major comments →

arxiv 2607.18753 v1 pith:6SSYRRL7 submitted 2026-07-21 cs.SE

TrapHunter: Exposing Covert Pathways in Trap Token Contracts

Yin Wu , Yixuan Liu , Yi Li , Chenyang Peng , Hao Wu , Ming Fan , Ting Liu , Haijun Wang This is my paper
classification cs.SE
keywords trap tokensERC-20smart contract securityintent deviation analysisAbstract Behavior TreeAugmented Path GraphLLM reasoningfork-based validation
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Trap tokens are ERC-20 contracts that look standard but carry hidden logic that freezes sales, inflates supply, or fakes events to steal from users. The paper argues that the right target is not a bug but an intent deviation: a semantic departure from a trusted reference implementation of the token standard. To expose that departure, TrapHunter first converts each function into a normalized behavioral tree and links functions through hidden state dependencies, then asks a large language model to judge whether a given path is malicious, and finally replays suspicious paths on a forked blockchain to confirm they are actually triggerable. On 501 labeled samples from 269 real contracts the authors report average precision of 81.8% and recall of 85.4%, with better F1 than existing tools; on 48 fresh on-chain contracts they report perfect recall and 0.806 precision. If the pipeline works as claimed, trap detection becomes a tractable, automatable part of token vetting instead of a manual forensic exercise.

Core claim

The central claim is that "deceptive adherence"—strict syntactic compliance with token standards combined with covert semantic deviation—can be detected automatically. The authors define trap tokens as contracts that maintain a standard interface while embedding logic that defrauds legitimate users, and they organize the threat into six categories mapped to the token lifecycle: Infinite Mint and Transfer Restriction, Tax Manipulation, Balance Tampering, Infinite Burn, and Fake Logs. For each category they give a formal detection predicate, and TrapHunter implements the full chain: ABT+APG representation, LLM intent reasoning, and fork-based execution to confirm that a candidate satisfies the

What carries the argument

The load-bearing machinery is the pair of intermediate representations plus the validation layer. Abstract Behavior Trees (ABTs) reduce a function body to a normalized Root-Stem-Leaf skeleton, so comparisons to a reference implementation ignore naming and syntactic noise. Augmented Path Graphs (APGs) resolve inheritance and add ternary traces—explicit records of a state variable read by one function and written by another attacker-accessible function—which surfaces the trigger-to-trap link that plain call graphs miss. Path-Level Inconsistency Analysis then feeds these paths to an LLM alongside the reference's paths and asks whether the deviation is malicious. Fork-based validation replays th

Load-bearing premise

The load-bearing premise is that any execution satisfying the paper's formal trap predicates is genuinely malicious; but legitimate fee-on-transfer and rebase tokens can produce identical observable deviations, so behavior alone may not encode intent.

What would settle it

Collect a set of 50 clearly legitimate fee-on-transfer and rebase tokens with public audits, run TrapHunter, and count how many are confirmed as Fake Logs or Balance Tampering traps by the fork validator. If even a handful are confirmed—or if the pattern seen on the on-chain sample (12 of 13 FL detections false positives) persists—the predicates cannot separate malicious intent from legitimate customization, and the zero-validator-FP claim fails.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • All six trap categories can be caught by one pipeline, including Tax Manipulation and Fake Logs that prior pattern-based tools do not cover.
  • Because the three tested LLMs all land above 0.79 precision and recall, the approach does not depend on one proprietary model; a cheaper, six-times-faster model is viable for routine screening.
  • Fork validation confirms 85.6% of LLM-flagged paths as concretely exploitable, so the final output is tied to executable behavior rather than to model confidence alone.
  • On unseen on-chain contracts the method maintained perfect recall, implying that newly deployed traps can be surfaced even when they have not yet caused a loss.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • A natural testable extension is to apply the same lifecycle-trace reasoning to ERC-721 or ERC-1155 standards; if the four lifecycle phases generalize, the pipeline transfer cost should be low.
  • The Fake Logs result on the on-chain sample (12 of 13 detections were false positives from fee-on-transfer tokens) suggests the formal predicates encode observable deviation, not intent; adding a signal that recognizes common legitimate fee patterns would likely raise precision more than further LLM prompting.
  • The 14.4% of paths rejected by fork validation were all attributed to LLM mistakes; building a feedback loop that feeds rejected paths back into the reasoning stage could reduce the LLM's false-positive rate over time without changing the predicates.
  • Because fork validation is state-dependent, traps that require a rare future state (e.g., a time-lock or external oracle) may be missed; searching for reachability of trigger states across time rather than only at one fork height would test this boundary.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

4 major / 6 minor

Summary. The paper introduces TrapHunter, a framework for detecting 'trap tokens' — ERC-20 contracts that adhere to standard interfaces but embed hidden malicious logic. The authors construct a taxonomy of six trap categories (TR, IM, IB, TM, BT, FL) from 269 real-world incident contracts via card sorting mapped onto a token lifecycle, and then use Abstract Behavior Trees and Augmented Path Graphs to represent contract semantics, LLM-based Path-Level Inconsistency Analysis to flag deviations from reference implementations, and fork-based dynamic validation to confirm suspicious paths. The reported evaluation on 501 labeled samples with three LLMs gives average precision 81.8%, recall 85.4%, and F1 83.5%, and claims to outperform CRPWarner and Pied-Piper. A fresh on-chain evaluation of 48 contracts reports overall F1 0.893.

Significance. If the results held uniformly, this would be a valuable contribution to smart-contract security: it combines a structured semantic representation, LLM reasoning, and dynamic validation into an end-to-end pipeline. Strengths include a reproducible replication package, three-LLM evaluation, ablation studies, cost analysis, and a fresh on-chain validation set. However, the paper's own category-level numbers undercut the headline claim: BT average precision is 0.282 and FL is 0.519 on the curated set, and on fresh on-chain contracts FL precision is 0.077 with all 13 detections 'validated' by the fork layer. The framework is better framed as a high-recall triage tool for logic-based trap patterns than as a high-precision detector for all six categories as claimed in the abstract.

major comments (4)
  1. [Abstract; §5.2 Table 5; §5.6 Table 11] The headline claim 'detects all six categories ... average precision 81.8% and recall 85.4%' is an aggregate that hides two categories with poor precision. Table 5 gives BT average precision 0.282 and FL 0.519; Table 11 gives FL precision 0.077 (1 TP, 12 FP) and TM precision 0.545 on fresh on-chain contracts. The on-chain set contains no BT sample and only one FL sample, so the overall F1 of 0.893 is driven by TR and IM. Please either revise the abstract to scope the claim to categories with adequate support, or provide category-specific evidence for FL/TM (e.g., more on-chain samples or targeted tuning).
  2. [§4.4.1, Table 3; §5.5; §5.6, Table 11] The validation predicates check state effects (balance changes, fee-rate changes, event/balance mismatch), not intent. The paper's own data show these effects are not discriminating: §5.6 reports 12 FL false positives from legitimate fee-on-transfer tokens, and Table 11 shows all 13 FL detections were 'validated' (100%). Thus the validator confirms FL false positives on-chain, directly contradicting §5.5's 'zero validator-induced FPs' claim. Similarly, §5.5 admits BT-flagged legitimate DeFi balance modifications and TM-flagged authorized fee adjustments. The predicates in Table 3 are therefore not an execution-grounded confirmation of malicious intent; the validation layer is a state-effect checker, and statements about intent filtering must be removed or re-evidenced.
  3. [§3.1; §4.3; §5.1.1] The evaluation has a circularity problem. The six categories are induced by open-card sorting from the same 269 incident contracts (§3.1), and the LLM prompt embeds exactly these six categories as the system prompt (§4.3, Figure 5). The ground-truth labels are then assigned to the same cards using the finalized category definitions. RQ1 therefore measures the models' ability to re-detect a taxonomy created from—and for—that dataset. The fresh 48-contract set mitigates this only partially: it is small, contains a single FL trap and no BT trap, and its labels are produced by the same authors with the same taxonomy. Please add an independent or external-label validation, or explicitly discuss this circularity as a threat to validity.
  4. [§5.3, Table 6] The comparison with baselines is not like-for-like. CRPWarner and Pied-Piper cover at most three categories, and the table footnote says overall scores are 'averaged over available categories only.' Thus the abstract's 'significantly outperforming' statement is based on non-comparable aggregates: a tool that ignores two categories is not tested on the same objective. Additionally, no confidence intervals or statistical significance tests are reported for the F1 differences. Please report performance on the common subset of categories and provide significance testing.
minor comments (6)
  1. [§5.2, Table 5] Please clarify that the overall 0.818 precision is a micro average over 501 samples; the unweighted average of the six per-category averages is 0.709. This distinction matters because readers may interpret 'average' as unweighted.
  2. [§4.4.2] The 'pre-specified validation parameters' (fork block height, input seeds, boundary values) are named but never enumerated. Please list them or point to the relevant part of the replication package.
  3. [§4.3] The temperature-varied majority voting uses exactly three temperatures (0.3, 0.7, 1.0) with no sensitivity analysis. The aggregation rule (threshold for majority) is also not defined; please specify it precisely.
  4. [§5.4] The w/o PIA ablation uses more than 5M transactions per contract; runtime for this configuration is not reported, so the practical cost of the structural baseline is unclear.
  5. [Table 4] The Backdoor row appears to contain a typo ('0367' instead of '367') and an unclear '0' column alignment. Please clean the table formatting.
  6. [§5.6] The on-chain dataset covers approximately 6,000 blocks. A single short time window may not be representative; please justify the window or extend the evaluation.

Circularity Check

2 steps flagged

Evaluation and validation are partially self-referential: the six-category taxonomy is induced from the same 269 contracts later used as ground truth and is embedded in the LLM prompt, while the fork validator defines 'confirmed trap' as satisfaction of its own Table 3 predicates.

specific steps
  1. self definitional [§3.1 (Taxonomy Construction), §4.3 (PIA System Prompt), §5.2 (RQ1 evaluation)]
    "This process yielded six distinct trap categories. The remaining dataset was then labeled based on these finalized definitions. … System Prompt: Defines the role (Vulnerability detection assistant) and the taxonomy of the six trap categories. … we analyzed its performance across six trap categories … achieving an average precision of 0.818 and recall of 0.854."

    The six trap categories are inductively derived from the same 269-contract corpus via Open Card Sorting, and that corpus is then labeled using those exact categories and used as the ground truth for RQ1. The LLM prompt is given the same six-category taxonomy as its classification scheme. The reported precision/recall therefore measures how well the LLM re-applies the authors' own category scheme to the contracts from which the scheme was derived; it does not independently establish that those categories are real, externally validated trap classes. The 48-contract on-chain set in RQ5 is manually labeled by the same authors under the same taxonomy, so it provides only limited independence.

  2. self definitional [§4.4.3 (Execution Replay and Trap Validation), §5.5 (RQ4)]
    "A smart contract is labeled as a confirmed trap if at least one execution satisfies the conditions of a detection rule under the pre-specified validation parameters. … Notably, we observed no instances where replayed executions contradicted our formal detection predicates, indicating that the validation stage effectively reduces false positives without introducing new ones."

    The validator's output 'confirmed trap' is defined as satisfying the Table 3 predicates, so the observation that replayed executions never contradict those predicates is true by construction. The claim of 'zero validator-induced FPs' restates the labeling rule rather than showing that the predicates discriminate malicious intent from benign DeFi behavior. Indeed, RQ5 itself shows FL precision 0.077 and TM precision 0.545, with false positives from legitimate fee-on-transfer tokens and non-malicious administrative fee adjustments—contracts that satisfy the same formal predicates.

full rationale

Two load-bearing steps are self-referential rather than independently grounded. First, the taxonomy is derived from the same incident corpus that later supplies the ground-truth labels, and the same taxonomy is fed into the LLM as the classification scheme, so the headline precision/recall is partly a measure of re-applying the authors' own categorization. Second, the fork validator defines 'confirmed trap' as satisfaction of its own Table 3 predicates and then reports zero validator-induced false positives; that is tautological. The paper does include an on-chain evaluation on 48 fresh contracts and comparisons against external baselines and the Backdoor dataset, which supply some independent content, so the circularity is partial rather than total. No load-bearing self-citation chain or imported uniqueness theorem was found.

Axiom & Free-Parameter Ledger

4 free parameters · 7 axioms · 0 invented entities

The paper contains no mathematical derivation; its claim is empirical. Listed are the hand-chosen thresholds and modeling assumptions the reported precision/recall numbers depend on. No new physical or theoretical entities are postulated; ABT/APG are artifacts of the framework, not independent entities.

free parameters (4)
  • Temperature gradient for majority voting = 0.3, 0.7, 1.0
    Three inference runs per candidate path at these temperatures; chosen by hand to balance determinism and sensitivity (§4.3). No sensitivity analysis is reported.
  • Maximum ternary traces per augmented path = 1
    Each augmented path includes at most one ternary trace to avoid combinatorial explosion (§4.2.3); multi-condition traps are split into separate paths, an ad hoc modeling choice that could miss combined conditions.
  • Majority-vote threshold = 2 of 3 runs
    Final classification aggregates three LLM outcomes via majority voting (§4.3).
  • Fork validation parameters = not enumerated
    Fork block height, chain ID, and input sources are 'pre-specified validation parameters' (§4.4.2) that gate exploitability, but their concrete values are not reported, making results hard to reproduce.
axioms (7)
  • domain assumption OpenZeppelin reference implementation is the benign behavioral baseline
    TrapHunter aligns target functions with reference paths; any systematic deviation is a candidate trap (§4.3). If a reference implementation itself contains traps or legitimate tokens deviate in a standard way, precision drops.
  • domain assumption The six-category lifecycle taxonomy is complete
    Derived by card-sorting 269 incidents (§3.1) and then used to label ground truth and to prompt the LLM (§4.3, Figure 5). Completeness is assumed; traps outside these categories would go undetected.
  • domain assumption Formal predicates in Table 3 separate malicious traps from legitimate customizations
    Fork validation applies these predicates as ground truth for exploitability (§4.4.1). RQ5 contradicts this for FL/TM (precision 0.077/0.545), so the predicates are not a sharp separator.
  • domain assumption LLM majority voting is a reliable intent oracle
    PIA depends on LLM interpretations of ABT/APG paths; no calibration against independent human intent labels is reported (§4.3).
  • ad hoc to paper At most one ternary trace per augmented path preserves trap-relevant dependencies
    §4.2.3 deliberately limits injection to avoid combinatorial explosion; traps requiring simultaneous conditions are analyzed per-path, and combined conditions may be missed.
  • ad hoc to paper Ternary traces are discarded when the writer is not externally invocable
    §4.2.3 assumes attackers can only manipulate state via externally callable functions; this excludes traps triggerable through delegatecall, constructors, or cross-contract paths.
  • domain assumption Fork replay at a pre-specified block height and chain ID reproduces the relevant on-chain state
    §4.4.2 uses 'pre-specified validation parameters'; the concrete values and state-preparation details are not given, so exploitability confirmation is not fully auditable.

reviewed 2026-08-01 · how reviews work

0 comments
Cite this review

Pith. "Pith review of TrapHunter: Exposing Covert Pathways in Trap Token Contracts." pith.science (2026). https://pith.science/paper/6SSYRRL7

@misc{pith2026260718753,
  author       = {Pith},
  title        = {Pith review of: TrapHunter: Exposing Covert Pathways in Trap Token Contracts},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/6SSYRRL7}},
  note         = {Machine review of arXiv:2607.18753}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Standardized token contracts (e.g., ERC-20) form the foundation of digital assets. However, attackers increasingly abuse this standardization to disguise malicious trap tokens. Unlike obvious violations, these contracts employ a strategy of "deceptive adherence": they strictly adhere to standard protocols to evade detection while embedding covert logic to defraud users. To address this, we first systematize the trap landscape by proposing a novel taxonomy derived from the intrinsic functional lifecycle of tokens (Generation, Circulation, Persistence, and Observation). We then propose TrapHunter, a framework designed to identify these traps and expose covert pathways within these deceptive contracts via intent deviation analysis. Specifically, TrapHunter introduces a unified semantic representation combining Abstract Behavior Trees (ABTs) and Augmented Path Graphs (APGs) to normalize intra-procedural syntax and reveal hidden execution paths driven by inter-procedural state dependencies. Crucially, it bridges the semantic gap by leveraging LLMs to reason about the behavioral intent of deviations from reference implementations, followed by fork-based dynamic validation to confirm exploitability. Experimental evaluation on 269 real-world contracts with three LLMs (DeepSeek, GPT, and Gemini) demonstrates that TrapHunter effectively detects all six categories of traps, achieving an average precision of 81.8% and recall of 85.4%, significantly outperforming state-of-the-art tools.

Figures

Figures reproduced from arXiv: 2607.18753 by Chenyang Peng, Haijun Wang, Hao Wu, Ming Fan, Ting Liu, Yi Li, Yin Wu, Yixuan Liu.

Figure 1
Figure 1. Figure 1: Example of a card Proc. ACM Softw. Eng., Vol. 3, No. ISSTA, Article ISSTA015. Publication date: October 2026 [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Taxonomy of Trap Tokens mapped to the standard Functional Lifecycle [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Example of Transfer Restriction (TR) in a token contract. [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Workflow of trap contract identification [PITH_FULL_IMAGE:figures/full_fig_p006_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Prompt Architecture • Behavioral Evidence: Feeds the tree_ABT (intra-procedural logic) and path_APG (inter-procedural dependencies). • System Prompt: Defines the role (Vulnerability detection assistant) and the taxonomy of the six trap categories. • Reasoning Task: Asks the LLM to deduce the intent of the deviation. Each question receives a binary (“YES”/“NO”) outcome and according reason. Proc. ACM Softw.… view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

59 extracted references · 5 linked inside Pith

  1. [1]

    Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. 2023. Gpt-4 technical report.arXiv preprint arXiv:2303.08774 (2023)

    Pith/arXiv arXiv 2023

  2. [2]

    Toufique Ahmed, Kunal Suresh Pai, Premkumar Devanbu, and Earl Barr. 2024. Automatic semantic augmentation of language model prompts (for code summarization). InProceedings of the IEEE/ACM 46th international conference on software engineering. 1–13

    2024

  3. [3]

    BlockSec. 2026. MetaSuites: The Swiss Army Knife for Builders. https://blocksec.com/metasuites. Accessed: January, 2026

    2026

  4. [4]

    Ramiro Camino, Christof Ferreira Torres, Mathis Baden, and Radu State. 2020. A data science approach for detecting honeypots in ethereum. In2020 IEEE international conference on blockchain and cryptocurrency (ICBC). IEEE, 1–9

    2020

  5. [5]

    Federico Cernera, Massimo La Morgia, Alessandro Mei, and Francesco Sassi. 2023. Token spammers, rug pulls, and sniper bots: An analysis of the ecosystem of tokens in ethereum and in the binance smart chain (BNB). In32nd USENIX Security Symposium (USENIX Security 23). 3349–3366

    2023

  6. [6]

    Jiachi Chen, Jiang Hu, Xin Xia, David Lo, John Grundy, Zhipeng Gao, and Ting Chen. 2024. Angels or demons: investigating and detecting decentralized financial traps on ethereum smart contracts.Automated Software Engineering 31, 2 (2024), 63

    2024

  7. [7]

    Jiachi Chen, Mingyuan Huang, Zewei Lin, Peilin Zheng, and Zibin Zheng. 2025. To healthier ethereum: A comprehensive and iterative smart contract weakness enumeration.Blockchain: Research and Applications6, 2 (2025), 100258

    2025

  8. [8]

    Ting Chen, Yufei Zhang, Zihao Li, Xiapu Luo, Ting Wang, Rong Cao, Xiuzhuo Xiao, and Xiaosong Zhang. 2019. Tokenscope: Automatically detecting inconsistent behaviors of cryptocurrency tokens in ethereum. InProceedings of the 2019 ACM SIGSAC conference on computer and communications security. 1503–1520

    2019

  9. [9]

    Weili Chen, Xiongfeng Guo, Zhiguang Chen, Zibin Zheng, Yutong Lu, and Yin Li. 2020. Honeypot contract risk warning on ethereum smart contracts. In2020 IEEE International Conference on Joint Cloud Computing. IEEE, 1–8

    2020

  10. [10]

    Wei Chen, Xinjun Jiang, Tian Lan, and Leyuan Liu. 2025. Ethereum fraud smart contract detection using heterogeneous semantic graph.Automated Software Engineering32, 2 (2025), 1–19

    2025

  11. [11]

    ConsenSys Diligence. 2026. SÅńrya, The Sun God: A Solidity Inspector. https://github.com/ConsenSysDiligence/surya. Accessed: January, 2026

    2026

  12. [12]

    De.Fi. 2026. REKT-Database. https://de.fi/rekt-database. Accessed: January, 2026

    2026

  13. [13]

    EthereumContractBackdoor. 2026. PiedPiperBackdoor: Ethereum Contract Backdoor. https://github.com/ EthereumContractBackdoor/PiedPiperBackdoor. Accessed: January, 2026

    2026

  14. [14]

    Etherscan. 2026. Token Tracker (ERC-20). https://etherscan.io/tokens. Accessed: January, 2026

    2026

  15. [15]

    Tong Gu, Min Han, Songlin He, and Xiaotong Chen. 2023. Trap contract detection in blockchain with improved transformer. InGLOBECOM 2023-2023 IEEE Global Communications Conference. IEEE, 5141–5146

    2023

  16. [16]

    Maneesha Gunathilaka, Sandareka Wickramanayake, and HMN Dilum Bandara. 2024. DeFiTrust: A transformer-based framework for scam DeFi token detection using event logs and sentiment analysis.Expert Systems with Applications 251 (2024), 123913

    2024

  17. [17]

    Kazuki Hara, Takeshi Takahashi, Motoya Ishimaki, and Kazumasa Omote. 2021. Machine-learning approach using solidity bytecode for smart-contract honeypot detection in the ethereum. In2021 IEEE 21st International Conference on Software Quality, Reliability and Security Companion (QRS-C). IEEE, 652–659

    2021

  18. [18]

    Everett Hildenbrandt, Manasvi Saxena, Nishant Rodrigues, Xiaoran Zhu, Philip Daian, Dwight Guth, Brandon Moore, Daejun Park, Yi Zhang, Andrei Stefanescu, et al. 2018. Kevm: A complete formal semantics of the ethereum virtual machine. In2018 IEEE 31st Computer Security Foundations Symposium (CSF). IEEE, 204–217

    2018

  19. [19]

    Chao Hu, Yitian Chai, Hao Zhou, Fandong Meng, Jie Zhou, and Xiaodong Gu. 2024. How Effectively Do Code Language Models Understand Poor-Readability Code?. InProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering. 795–806. Proc. ACM Softw. Eng., Vol. 3, No. ISSTA, Article ISSTA015. Publication date: October 2026. ISSTA01...

    2024

  20. [20]

    Huiwen Hu, Qianlan Bai, and Yuedong Xu. 2022. Scsguard: Deep scam detection for ethereum smart contracts. InIEEE INFOCOM 2022-IEEE Conference on Computer Communications Workshops (INFOCOM WKSHPS). IEEE, 1–6

    2022

  21. [21]

    Zewei Lin, Jiachi Chen, Jiajing Wu, Weizhe Zhang, Yongjuan Wang, and Zibin Zheng. 2024. Crpwarner: Warning the risk of contract-related rug pull in defi smart contracts.IEEE Transactions on Software Engineering50, 6 (2024), 1534–1547

    2024

  22. [22]

    Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al. 2024. Deepseek-v3 technical report.arXiv preprint arXiv:2412.19437(2024)

    Pith/arXiv arXiv 2024

  23. [23]

    Han Liu, Daoyuan Wu, Yuqiang Sun, Haijun Wang, Kaixuan Li, Yang Liu, and Yixiang Chen. 2024. Using my functions should follow my checks: understanding and detecting insecure OpenZeppelin code in smart contracts. In33rd USENIX Security Symposium (USENIX Security 24). USENIX Association, 3585–3601

    2024

  24. [24]

    Yi Liu and Lizhi Cai. 2023. Honeytoken-Detector: A symbolic execution-based honeypot token detection tool. In2023 26th ACIS International Winter Conference on Software Engineering, Artificial Intelligence, Networking and Parallel/Dis- tributed Computing (SNPD-Winter). IEEE, 134–139

    2023

  25. [25]

    Yixuan Liu, Yuxin Dong, Ye Liu, Xiapu Luo, and Yi Li. 2025. Phantom Events: Demystifying the Issues of Log Forgery in Blockchain.arXiv preprint arXiv:2502.13513(2025)

    Pith/arXiv arXiv 2025

  26. [26]

    Yixuan Liu, Xinlei Li, and Yi Li. 2025. DeepTx: Real-Time Transaction Risk Analysis via Multi-Modal Features and LLM Reasoning. In2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 4025–4028

    2025

  27. [27]

    Ye Liu, Yixuan Liu, Yi Li, and Cyrille Artho. 2025. Specification mining for smart contracts with trace slicing and predicate abstraction. In2025 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 147–158

    2025

  28. [28]

    Ye Liu, Yue Xue, Daoyuan Wu, Yuqiang Sun, Yi Li, Miaolei Shi, and Yang Liu. 2024. Propertygpt: Llm-driven formal verification of smart contracts through retrieval-augmented property generation.arXiv preprint arXiv:2405.02580 (2024)

    Pith/arXiv arXiv 2024

  29. [29]

    Fuchen Ma, Meng Ren, Lerong Ouyang, Yuanliang Chen, Juan Zhu, Ting Chen, Yingli Zheng, Xiao Dai, Yu Jiang, and Jiaguang Sun. 2023. Pied-piper: Revealing the backdoor threats in ethereum erc token contracts.ACM Transactions on Software Engineering and Methodology32, 3 (2023), 1–24

    2023

  30. [30]

    Wei Ma, Daoyuan Wu, Yuqiang Sun, Tianwen Wang, Shangqing Liu, Jian Zhang, Yue Xue, and Yang Liu. 2025. Combining fine-tuning and llm-based agents for intuitive smart contract auditing with justifications. In2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE, 1742–1754

    2025

  31. [31]

    OpenZeppelin. 2026. OpenZeppelin Docs. https://docs.openzeppelin.com/. Accessed: January, 2026

    2026

  32. [32]

    Anton Permenev, Dimitar Dimitrov, Petar Tsankov, Dana Drachsler-Cohen, and Martin Vechev. 2020. Verx: Safety verification of smart contracts. In2020 IEEE symposium on security and privacy (SP). IEEE, 1661–1677

    2020

  33. [33]

    2009.Card sorting: Designing usable categories

    Donna Spencer. 2009.Card sorting: Designing usable categories. Rosenfeld Media

    2009

  34. [34]

    Liya Su, Xinyue Shen, Xiangyu Du, Xiaojing Liao, XiaoFeng Wang, Luyi Xing, and Baoxu Liu. 2021. Evil under the sun: Understanding and discovering attacks on ethereum decentralized applications. In30th USENIX Security Symposium (USENIX Security 21). 1307–1324

    2021

  35. [35]

    Yuqiang Sun, Daoyuan Wu, Yue Xue, Han Liu, Haijun Wang, Zhengzi Xu, Xiaofei Xie, and Yang Liu. 2024. Gptscan: Detecting logic vulnerabilities in smart contracts by combining gpt with program analysis. InProceedings of the IEEE/ACM 46th international conference on software engineering. 1–13

    2024

  36. [36]

    Gemini Team, Rohan Anil, Sebastian Borgeaud, Jean-Baptiste Alayrac, Jiahui Yu, Radu Soricut, Johan Schalkwyk, Andrew M Dai, Anja Hauth, Katie Millican, et al. 2023. Gemini: a family of highly capable multimodal models.arXiv preprint arXiv:2312.11805(2023)

    Pith/arXiv arXiv 2023

  37. [37]

    Christof Ferreira Torres, Mathis Steichen, et al. 2019. The art of the scam: Demystifying honeypots in ethereum smart contracts. In28th USENIX Security Symposium (USENIX Security 19). 1591–1607

    2019

  38. [38]

    Fabian Vogelsteller and Vitalik Buterin. 2015. EIP-20: ERC-20 Token Standard. https://eips.ethereum.org/EIPS/eip-20. Accessed: January, 2026

    2015

  39. [39]

    Bin Wang, Xiaohan Yuan, Li Duan, Hongliang Ma, Chunhua Su, and Wei Wang. 2022. DeFiScanner: Spotting DeFi attacks exploiting logic vulnerabilities on blockchain.IEEE Transactions on Computational Social Systems11, 2 (2022), 1577–1588

    2022

  40. [40]

    Haijun Wang, Yurui Hu, Hao Wu, Dijun Liu, Chenyang Peng, Yin Wu, Ming Fan, and Ting Liu. 2024. Skyeye: Detecting imminent attacks via analyzing adversarial smart contracts. InProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering. 1570–1582

    2024

  41. [41]

    Haijun Wang, Yi Li, Shang-Wei Lin, Lei Ma, and Yang Liu. 2019. VULTRON: Catching vulnerable smart contracts once and for all. In2019 IEEE/ACM 41st international conference on software engineering: New ideas and emerging results (ICSE-NIER). IEEE, 1–4

    2019

  42. [42]

    Haijun Wang, Ye Liu, Yi Li, Shang-Wei Lin, Cyrille Artho, Lei Ma, and Yang Liu. 2020. Oracle-supported dynamic exploit generation for smart contracts.IEEE Transactions on Dependable and Secure Computing19, 3 (2020), 1795–1809. Proc. ACM Softw. Eng., Vol. 3, No. ISSTA, Article ISSTA015. Publication date: October 2026. TrapHunter: Exposing Covert Pathways i...

    2020

  43. [43]

    Lijin Wang, Jingjing Wang, Tianshuo Cong, Xinlei He, Zhan Qin, and Xinyi Huang. 2025. From purity to peril: Backdooring merged models from âĂIJharmlessâĂİ benign components. InUSENIX Security Symposium (USENIX Security)

    2025

  44. [44]

    Cong Wu, Jing Chen, Jian Shen, Guowen Xu, Yueming Wu, Haijun Wang, Hongwei Li, Yang Liu, and Yang Xiang. 2026. Catching Scam Tokens with Temporal Graph Learning in Decentralized Finance.IEEE Transactions on Dependable and Secure Computing(2026)

    2026

  45. [45]

    Cong Wu, Jing Chen, Ziming Zhao, Kun He, Guowen Xu, Yueming Wu, Haijun Wang, Hongwei Li, Yang Liu, and Yang Xiang. 2024. Tokenscout: Early detection of ethereum scam tokens via temporal graph learning. InProceedings of the 2024 on ACM SIGSAC Conference on Computer and Communications Security. 956–970

    2024

  46. [46]

    Yin Wu, Xiaofei Xie, Chenyang Peng, Dijun Liu, Hao Wu, Ming Fan, Ting Liu, and Haijun Wang. 2024. Advscanner: Generating adversarial smart contracts to exploit reentrancy vulnerabilities using llm and static analysis. InProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering. 1019–1031

    2024

  47. [47]

    Zhiying Wu, Jieli Liu, Jiajing Wu, Zibin Zheng, Xiapu Luo, and Ting Chen. 2023. Know your transactions: Real-time and generic transaction semantic representation on blockchain & web3 ecosystem. InProceedings of the ACM Web Conference 2023. 1918–1927

    2023

  48. [48]

    Zhiying Wu, Jiajing Wu, Hui Zhang, Zibin Zheng, and Weiqiang Wang. 2025. Hunting in the Dark Forest: A Pre-trained Model for On-chain Attack Transaction Detection in Web3. InTHE WEB CONFERENCE 2025

    2025

  49. [49]

    Pengcheng Xia, Haoyu Wang, Bingyu Gao, Weihang Su, Zhou Yu, Xiapu Luo, Chao Zhang, Xusheng Xiao, and Guoai Xu. 2021. Trade or trick? detecting and characterizing scam tokens on uniswap decentralized exchange.Proceedings of the ACM on Measurement and Analysis of Computing Systems5, 3 (2021), 1–26

    2021

  50. [50]

    Maoyi Xie, Ming Hu, Ziqiao Kong, Cen Zhang, Yebo Feng, Haijun Wang, Yue Xue, Hao Zhang, Ye Liu, and Yang Liu

  51. [51]

    Yinxing Xue, Jiaming Ye, Wei Zhang, Jun Sun, Lei Ma, Haijun Wang, and Jianjun Zhao. 2022. xfuzz: Machine learning guided cross-contract fuzzing.IEEE Transactions on Dependable and Secure Computing21, 2 (2022), 515–529

    2022

  52. [52]

    Bosi Zhang, Ningyu He, Xiaohui Hu, Kai Ma, and Haoyu Wang. 2025. Following Devils’ Footprint: Towards Real-time Detection of Price Manipulation Attacks. In34th USENIX Security Symposium (USENIX Security 25). 4127–4145

    2025

  53. [53]

    Jiashuo Zhang, Jiachi Chen, Yiming Shen, Tao Zhang, Yanlin Wang, Ting Chen, Jianbo Gao, and Zhong Chen. 2025. When Crypto Fails: Demystifying Cryptographic Defects in Ethereum Smart Contracts.IEEE Transactions on Software Engineering(2025)

    2025

  54. [54]

    Jian Zhang, Chong Wang, Anran Li, Wenhan Wang, Tianlin Li, and Yang Liu. 2024. Vuladvisor: Natural language suggestion generation for software vulnerability repair. InProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering. 1932–1944

    2024

  55. [55]

    Lyuye Zhang, Kaixuan Li, Kairan Sun, Daoyuan Wu, Ye Liu, Haoye Tian, and Yang Liu. 2025. ACF ix: Guiding LLMs with Mined Common RBAC Practices for Context-Aware Repair of Access Control Vulnerabilities in Smart Contracts. IEEE Transactions on Software Engineering(2025)

    2025

  56. [56]

    Yichi Zhang, Zixi Liu, Yang Feng, and Baowen Xu. 2024. Leveraging large language model to assist detecting rust code comment inconsistency. InProceedings of the 39th IEEE/ACM international conference on automated software engineering. 356–366

    2024

  57. [57]

    Jianfei Zhou, Tianxing Jiang, Haijun Wang, Meng Wu, and Ting Chen. 2023. Dapphunter: Identifying inconsistent behaviors of blockchain-based decentralized applications. In2023 IEEE/ACM 45th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP). IEEE, 24–35

    2023

  58. [58]

    Chenguang Zhu, Ye Liu, Xiuheng Wu, and Yi Li. 2022. Identifying solidity smart contract api documentation errors. In Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering. 1–13. Received 2026-01-30; accepted 2026-06-25 Proc. ACM Softw. Eng., Vol. 3, No. ISSTA, Article ISSTA015. Publication date: October 2026

    2022

  59. [2024]

    InProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis

    Defort: Automatic detection and analysis of price manipulation attacks in defi applications. InProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. 402–414

This paper was first reviewed by deepseek-v4-flash on August 1, 2026.