betaFeedback

WorksComputer Science

TxBench: Verifying Public Incident Data to Benchmark Smart-Contract Attack Detectors

Abstract

Malicious transactions on smart contracts cause billions of dollars in losses. To evaluate their detectors, most datasets copy the attack transactions that public incident databases cite and pair them with random transactions. However, these databases never check their citations against execution, and random transactions rarely resemble attacks. We present TXBENCH, a benchmark that verifies both attacks and legitimate transactions against their execution. TXBENCH labels a cited transaction as an attack only when its execution takes value from others and independent evidence ties it to its incident. Its legitimate transactions perform the same operations as attacks and carry positive evidence of legitimacy. Applying these checks to two public databases, we find that they share only 10.6% of their 1,850 cited transactions and that only 1,012 are verifiable attacks, worth $868.2 million. A blind manual review confirms 98/100 sampled attacks and 100/100 legitimate transactions.

Introduction

Attacks on smart contracts, the programs that hold Decentralized Finance (DeFi) assets, cause billions of dollars in losses. DeFiLlama [1] records 967 hacks worth $9.29 billion, each carried out by one or more malicious transactions [2]. Code analyzers [3, 4] help prevent these attacks but flag far more contracts than attackers exploit. For example, attackers exploit only 2% of the 23,327 contracts that six analyzers flag as vulnerable [5]. Hence, recent detectors inspect each transaction’s execution trace to replay it against rules [6, 7], lift it to DeFi actions [8, 9, 10], or learn models of it [11, 12, 13].

These transaction-level detectors lack verified labels, because existing benchmarks label code, not executed transactions [4, 14, 15]. Hence, each detector paper builds its own evaluation set. Horus [7] labels the attacks that its own analyses find, making the evaluation circular. Other papers copy attacks from public incident databases [16, 17]. Similar to other mined software data [18], these databases may contain label errors that every dataset built on them inherits. A benchmark also needs legitimate transactions to measure false positives, a main barrier to adopting analyzers in practice [3]. However, datasets leave them unverified [17], and random transactions rarely do as much computation as attacks.

The Euler Finance exploit [19] shows both problems. BlockSec [20] lists 6 drain transactions and a loss of $200 million, while the EVM Hack Registry [21] lists 1 transaction and a loss of $197 million. Their execution traces show that BlockSec’s transactions take $198.1 million, while the registry’s transaction takes only $8.7 million. Hence, a dataset built from the registry credits one transaction with all losses and misses the other drain transactions. Moreover, the attacker uses only calls that legitimate users also make (e.g., a donation to the protocol’s reserves, a liquidation). Therefore, to show that a detector recognizes the attack rather than its calls, a benchmark needs legitimate transactions that make these calls too.

To give transaction-level detectors verified labels, we present TxBENCH, a benchmark that checks every label against the execution trace of its transaction, covering 7 Ethereum Virtual Machine (EVM) chains. Figure 1 shows the pipeline that we use to build TxBENCH from free public data. We first collect the 1,850 transactions that BlockSec and the EVM Hack Registry cite (①), and rebuild their traces (②). We then accept 1,012 of them as attacks, requiring that each one takes value from accounts outside the attacker’s control and has evidence beyond its citation (③). For legitimate transactions, we sample each chain’s traffic within 30 days of its attacks and keep 2,024 transactions with evidence of legitimacy (④). Finally, we manually review a blind sample of both classes (⑤). No step uses a detector to decide a label.

An overview of the TxBench pipeline

Figure 1. An overview of the TxBench pipeline. Numbers count transactions.

Building TxBENCH reveals how far the two databases are from a ground truth. They share only 197/1,850 cited transactions, and only 72.2% of the cited transactions with a complete trace take at least $100 from accounts outside the attacker’s control. Random transactions also make poor legitimate examples, because only 1% of them use more than a million gas (the unit of computation that a transaction pays for), compared to 54.5% of the attacks. We release TxBENCH, its pipeline, and its caches on Zenodo [22].

From Incident Citations to Accepted Attacks

Sourcing TxBench From Two Public Incident Databases

To cover more incidents than any single database, we collect the attack transactions that two public databases cite (①). The first database is BlockSec’s Security Incidents Library [20], which documents incidents with their transactions, attackers, root causes, and losses. Our snapshot of that library holds 308 incidents, dated from 2023-01-03 to 2026-07-24. The second database is the EVM Hack Registry [21], which extends DeFiHackLabs [23] with 932 dated incidents from 2017 to 2026 at commit 5e310fc. Each registry incident comes with a report that cites its transactions and parties, and with a Foundry [24] proof of concept that reproduces the attack on a copy of the chain. To combine both databases, we match them on the transaction hash (i.e., the identifier of each transaction). We then keep the 7 chains with more than 10 incidents in their union: Ethereum, BNB Smart Chain (BSC), Arbitrum, Base, Optimism, Polygon, and Avalanche. Every other chain has at most 4 incidents. Attacks on these chains alone account for 75.4% of the DeFi losses that DeFiLlama records [1]. This step results in 1,850 cited transactions: 197 in both databases, 780 only in BlockSec, and 873 only in the registry. Table I breaks down these counts per chain, along with the attacks and legitimate transactions that later steps keep. Of the cited transactions, 1,840 succeed on chain, and 5 revert (i.e., they fail and the chain undoes their effects). We drop the remaining 5 that match no transaction on these chains.

Chain#Incidents#Cited#AttacksValue#Legitimate
Ethereum405904544692.41,088
BSC40656030967.8618
Arbitrum671834330.486
Base631076512.5130
Optimism21432542.350
Polygon28361710.834
Avalanche1417912.018
Total–1,8501,012868.22,024

Table I. TxBench per chain. Value is in $ million. Incidents have no total, because an incident may span several chains.

Weaknesses in a Shared Taxonomy

To compare the weakness labels of both databases, and to let researchers measure recall per weakness, we map each incident to OWASP Smart Contract Weakness Enumeration (SCWE) [25], a taxonomy of 156 weaknesses (1). To achieve that, we use Claude Opus 5.5 (Claude) to read the root cause of each incident from the registry’s report, a post-mortem, the traces, or BlockSec’s label, under a fixed codebook that we include in the artifact. All transactions of an incident then share that incident’s SCWE entry. Overall, 1,166/1,850 transactions map to a specific entry, and 228 transactions belong to attacks that exploit no contract flaw (e.g., key compromises). To validate these readings, one of the authors reads 30 incidents blindly under the same codebook, and assigns the same entry as Claude for 26/30 (κ=0.83\kappa= 0.83).

Execution Records from Free Data Sources

The receipt that chains store for a transaction lists its events but not the internal calls where an attack happens. Therefore, we build an enriched transaction trace that holds its receipt, decoded call and events, and internal call frames (2). To enable free reproduction, our trace builder reads only public endpoints, free Application Programming Interface (API) tiers and tracers, Sourcify [26], and public signature databases. Since BSC and Arbitrum offer no free tracer, the trace builder replays each of their blocks in a local Anvil fork [24], keeping the replay only when its status and logs equal those of the chain. Of the 1,845 transactions on chain, 1,797 have the complete call trees that the value oracle needs (3).

A Value Oracle Instead of a Detector

Each database specifies who the attacker and victim of a transaction are and how much its incident loses. Therefore, we judge each transaction by its own execution rather than by these claims (3). To achieve that, we design a value oracle that computes each address’s net change per asset from the trace, and prices it in USD an hour before the block [27]. This approach prevents the attack from pricing its own gains. The oracle then measures what the attacker side takes from accounts outside it. We call an attack a key compromise when it uses stolen private keys, and a contract exploit otherwise. The attacker side holds the named attackers, the sender of a contract exploit, their created contracts, and wallets that only receive from them. Of the 1,797 judged transactions, 1,297 take at least $100, a floor that filters dust transfers.

We then check each value-taking transaction against 3 database claims: the sender of a contract exploit is a named attacker, a named victim loses value, and the incident’s value is within 10×10\times the reported loss to account for free-text losses priced at different times. Of these transactions, 123 fail at least one check, leaving 1,174. The loss check fails most often (62), because a database may report all attack losses but cite only some of its transactions. However, the sender and loss checks pass almost by construction. This is because BlockSec usually names the sender itself as the attacker, and a database usually computes its reported loss from the cited transactions. Therefore, we accept a transaction as an attack only if it also has one of the following evidence types: both databases cite it, the registry’s proof of concept replays the attack from a block within an hour, the registry names its sender an attacker, a victim that the registry names loses value, or a database names the thief who gains from a key compromise. These checks yield 1,012 attacks: 846 contract exploits and 166 key compromises. The other 162 transactions lack enough evidence and come from BlockSec alone. To measure how far the evidence requirement favors the registry’s incidents, we ship them as a secondary set.

Verified Legitimate Transactions

To let researchers measure precision as well as recall, we supplement TxBench with legitimate transactions that perform the same kinds of operations as attacks (4). Such transactions test whether a detector recognizes the attack itself rather than surface features that attacks share with legitimate activity. This section describes how we discover candidates, verify their legitimacy, and sample among the verified ones.

Targets and Discovery

TXBENCH targets two legitimate transactions per accepted attack on each chain (2,024 in total), a ratio that keeps the tracing within free API tiers. Of the accepted attacks, 18.4% deploy a contract and then attack from its constructor (i.e., the code that runs once when the contract is created). Hence, each chain’s legitimate transactions include two contract deployments per such attack. The remaining legitimate transactions split 50/30/20 over 3 categories: behaviorally hard (e.g., swaps and liquidations), financially hard (i.e., values at or above the 25th percentile of the chain’s attack values), and verified ordinary (e.g., transfers and approvals). This split gives the most weight to operations that attacks also use. To collect candidates, we draw seeded random windows within 30 days of each chain’s attacks. Most windows are single random blocks. The rest target blocks with liquidations and contract creations, which random blocks rarely hold. These 8,091 windows hold 316,235 on-chain candidate transactions. We then trace 14,994 of them with the same trace builder as the attacks [2], decoding all but one.

Positive Evidence of Legitimacy

Calling well-known protocols does not make a transaction legitimate, because attackers also use them to swap stolen funds [28] or borrow funds [29]. Absence from the incident databases does not make it legitimate either, because the databases may miss some incidents. Therefore, we require positive evidence of legitimacy, and sort candidates into three tiers by that evidence. Only tier-1 candidates enter TXBENCH.

A candidate is tier 1 only when (1) it succeeds with a complete call tree; (2) no third party loses unexplained value beyond the larger of 1% of the transaction’s volume and $100; (3) every venue that emits a market event in it is one of 300 deployments of 48 protocols that we check on chain, or a pool/market that such a deployment lists; (4) its sender gains at most the larger of 5% of the volume and $100, or 15% of the volume for a liquidation, margins that legitimate arbitrage and liquidations rarely exceed; and (5) it involves no cited transaction, no named or oracle-found attacker, and no incident’s main victim from one day before to 30 days after the incident. A candidate that lacks evidence is tier 2, and we ship these separately. A candidate that contradicts a rule is tier 3. Of the 14,993 traced candidates, 7,715 are tier 1.

Sampling under Diversity Caps

We sample only tier-1 candidates, in cells of chain, category, and year. We draw each behavioral and financial cell evenly across the quartiles of the chain’s attack gas use. We then cap the legitimate transactions at 2 per sender, 20 per called contract, and 3 per block, with no protocol > 25% of a chain and category. Since 43.9% of attacks come from fresh senders (i.e., senders with < 10 prior transactions), each cell also takes fresh senders in the same share. This process yields 2,024 legitimate transactions: 372 deployments, 826 behavioral, 496 financial, and 330 ordinary. These transactions resemble attacks more than random traffic does. Of them, 13.3% use over a million gas (5.9% without deployments), compared to 1% of random transactions and 54.5% of attacks. Hence, gas use alone nearly identifies attacks in random traffic, while TXBENCH forces a detector to look beyond.

Measuring Label Quality before Trusting It

TXBENCH assigns every label by rule. Hence, a wrong label distorts every metric that a detector reaches on TXBENCH. To estimate how often the rules err, one of the authors manually reviews a sample of attacks and legitimate transactions [5]. Before drawing the sample, we fix the decision rules for the review by recording their cryptographic hash, preventing any change after the reviewer sees the data. These rules ask one question of each transaction: does it take, or directly enable taking, assets or control from a victim without consent, through a contract flaw, a stolen key or signature, or deception? The reviewer answers attack_yes, attack_no, or unsure.

The reviewed sample consists of 100 accepted attacks and 100 legitimate transactions, in 18 strata by chain and period, interleaved without labels, keeping the review blind. To measure consistency, the reviewer reads a seeded fifth of the transactions again at least seven days later, without seeing the first decision. The two readings agree on 87.5% of the 40 re-read transactions (κ=0.75\kappa= 0.75, 95% Confidence Interval (CI) of 0.55–0.95). Adjudication settles the five disagreements. The review confirms 98/100 attacks and 100/100 legitimate transactions, counting unsure as not confirmed. Weighting each stratum by its share of TXBENCH, 97.7% of the accepted attacks carry the right label, with a CI of 92.5–99.3%. For legitimate transactions, the estimate is 100%, with a CI of 96.3–100%. The review rejects 2 attacks, a key-compromise transfer and a deployment that performs a transfer. Both retain their rule-assigned labels, keeping the estimate valid for every label in TXBENCH. The artifact ships every review decision, enabling users to drop such transactions.

Zero-Shot LLMs Miss Most Attacks

To show how challenging TXBENCH is for detectors that need no training data, we ask four zero-shot Large Language Models (LLMs) about the reviewed transactions. We then score their answers against the review’s final decisions. Each prompt holds a transaction’s trace file as formatted JSON and asks whether the transaction is an attack. To keep an LLM from recognizing a known incident by its identity, we replace every address with a consistent placeholder, and remove the hashes, block, and entity labels. The test holds the 193 reviewed transactions whose prompts fit every LLM context window: 91 attacks (77 contract exploits and 14 key compromises) and 102 legitimate transactions. The rest (7) are contract exploits with thousands of internal calls. We run each LLM once at temperature zero. Since the answers may still vary between runs, we release them all with TXBENCH. The answers that run out of output tokens (13) count as misses.

tbl:2 shows that zero-shot LLMs flag attacks precisely but miss most of them. Since 47% of the test transactions are attacks, flagging every transaction (Flag All) already reaches an F1 of 0.64, above every LLM. Therefore, we compare the LLMs by AUC and recall. All LLMs rank attacks above legitimate transactions better than chance (AUC 0.68–0.76, against 0.50 for Flag All). However, they miss most attacks (recall 0.04–0.43), while rarely flagging a legitimate transaction (false-positive rate 0.02–0.06). As expected, no LLM catches a key compromise, because most are plain transfers that no trace can reveal. Even the best LLM, Gemini 3.1 Flash Lite, finds only 51% of the contract exploits. Hence, TXBENCH leaves most attacks for future detectors to find.

Storage, Use, and Research Directions

TXBENCH consists of 3 files: accepted attacks, legitimate transactions, and a combination of both in combined.csv. Each row of combined.csv carries a transaction’s label, category, and 5 train/test splits, where no group appears on both sides of a split. A data dictionary defines every column. To keep file paths from revealing the class, all enriched traces sit in one flat folder, named by transaction hash. Contract exploits form the primary evaluation, and key compromises form a separate track. The script evaluate.py scores a detector’s predictions per track and split, weighting incidents equally to keep large incidents from dominating the score. It also reweights precision for the real-traffic share of attacks, which TXBENCH’s 2 legitimate transactions per attack do not reflect.

All outputs, including the traces and the caches, take 5.4 GB. From these caches, run_pipeline.py --offline rebuilds every output in standard-library Python, showing that the pipeline is deterministic. An online rerun requeries the incident databases and chains, and needs only free Node-Real and Alchemy API keys and Foundry’s Anvil (see the README). Beyond evaluation, TXBENCH supports four lines of research: precision against legitimate transactions with the same operations as attacks, generalization across time and chains, recall per weakness and weighted by USD, and the reliability of public incident data. For the last one, the oracle checks record where each database contradicts the chain. As a new resource, TXBENCH has no usage history.

Limitations and Improvements

a) Internal Validity: I1. One author reviews every sampled transaction, and the agreement between the two readings measures only that reviewer’s consistency. With 100 transactions per class, the attacks’ interval also stays wide (92.5–99.3%), although the hashed rules and released decisions let others repeat the review. I2. A list of 300 protocol deployments decides which venues TXBENCH recognizes. No tier-1 legitimate transaction trades through an unrecognized venue, while 210 accepted attacks (20.8%) do, letting a detector learn the list instead of the attacks. The tier-2 transactions include such venues, enabling users to test for this shortcut.

b) External Validity: TXBENCH holds only the attacks that the two incident databases cite. BlockSec’s library starts in 2023, leaving only 77 accepted attacks from earlier years.

c) Construct Validity: C1. Of the 166 key compromises, 121 are plain transfers that no trace can reveal. BtcTurk alone contributes 153 attacks (15.1%). Hence, TXBENCH evaluates key compromises separately and weights incidents equally. C2. The 372 deployments are easy to detect by counting calls, because 77.2% of them make no calls (AUC 0.99). Hence, users should report results with and without them.

d) Improvements: TXBENCH can improve by adding legitimate transactions that pay their sender, multi-transaction attacks, more protocols, and harder deployments.

TXBENCH builds on work in three areas. First, benchmarks for smart-contract security, such as SmartBugs [4], DAppSCAN [14], and EVMbench [15], label code rather than executed transactions. Unlike TXBENCH, they cannot measure whether a detector flags an attack in the transactions that carry it out. Second, incident databases [20, 21, 23] cite the transactions behind each reported attack without checking them against execution. As a result, transaction-level detectors [6, 7, 8, 9, 10, 11, 12, 13] each assemble their own dataset, labeled by the detector itself, copied from such databases, or paired with random legitimate transactions. TXBENCH gives these detectors one shared dataset that verifies every cited transaction against its execution and pairs the attacks with evidence-backed legitimate transactions. Third, prior research shows that mined labels are often wrong, for both defect reports [30] and security defects [18]. TXBENCH brings the same scrutiny to incident data, measuring the error that remains.

Conclusion

TXBENCH is a benchmark of 1,012 attacks and 2,024 evidence-backed legitimate transactions on 7 EVM chains, where execution and evidence decide every label. Building it shows that the two incident databases share only 10.6% of their 1,850 cited transactions. Hence, datasets that copy these citations inherit their errors. Since TXBENCH builds on free public data, it may grow with each new incident. We archive the dataset, pipeline, tests, and review protocol on Zenodo [22], with the code under MIT and our annotations under CC BY 4.0. Third-party material keeps its terms.

References

  1. [1]DeFiLlama, “DeFiLlama hacks: DeFi hacks and exploits database,” https://defillama.com/hacks, 2026.
  2. [2]L. Zhou, X. Xiong, J. Ernstberger, S. Chaliasos, Z. Wang, Y. Wang, K. Qin, R. Wattenhofer, D. Song, and A. Gervais, “SoK: Decentralized finance (DeFi) attacks,” in IEEE Symposium on Security and Privacy (S&P). IEEE, 2023, pp. 2444–2461.arxiv.org/abs/2208.13035
  3. [3]T. Abdelaziz, S. Alsaghir, and K. Ali, “Where do smart contract security analyzers fall short?” in International Conference on Mining Software Repositories (MSR). ACM, 2026, pp. 49–61.DOI
  4. [4]T. Durieu, J. Ferreira, R. Abreu, and P. Cruz, “Empirical review of automated analysis tools on 47,587 Ethereum smart contracts,” in International Conference on Software Engineering (ICSE). ACM, 2020, pp. 530–541.
  5. [5]D. Perez and B. Livshits, “Smart contract vulnerabilities: Vulnerable does not imply exploited,” in USENIX Security Symposium. USENIX Association, 2021, pp. 1325–1341.
  6. [6]M. Zhang, X. Zhang, Y. Zhang, and Z. Lin, “TXSPECTOR: Uncovering attacks in Ethereum from transactions,” in USENIX Security Symposium. USENIX Association, 2020, pp. 2775–2792.
  7. [7]C. Ferreira Torres, A. K. Iannillo, A. Gervais, and R. State, “The eye of Horus: Spotting and analyzing attacks on Ethereum smart contracts,” in International Conference on Financial Cryptography and Data Security (FC), ser. Lecture Notes in Computer Science, vol. 12674. Springer, 2021, pp. 33–52.
  8. [8]S. Wu, Z. Yu, D. Wang, Y. Zhou, L. Wu, H. Wang, and X. Yuan, “DeFiRanger: Detecting DeFi price manipulation attacks,” IEEE Transactions on Dependable and Secure Computing (TDSC), vol. 21, no. 4, pp. 4147–4161, 2024.DOI
  9. [9]M. Xie, M. Hu, Z. Kong, C. Zhang, Y. Feng, H. Wang, Y. Xue, H. Zhang, Y. Liu, and Y. Liu, “DeFort: Automatic detection and analysis of price manipulation attacks in DeFi applications,” in International Symposium on Software Testing and Analysis (ISSTA). ACM, 2024, pp. 402–414.DOI
  10. [10]J. Zhong, D. Wu, Y. Liu, M. Xie, Y. Liu, Y. Li, and N. Liu, “Detecting various DeFi price manipulations with LLM reasoning,” in International Conference on Automated Software Engineering (ASE). IEEE, 2025, pp. 1781–1793.arxiv.org/abs/2502.11521
  11. [11]Z. Wu, J. Wu, H. Zhang, Z. Zheng, and W. Wang, “Hunting in the dark forest: A pre-trained model for on-chain attack transaction detection in Web3,” in ACM Web Conference (WWW). ACM, 2025, pp. 4519–4530.DOI
  12. [12]D. Meng, F. Gritti, R. McLaughlin, N. Ruaro, I. Grishchenko, C. Kruegel, and G. Vigna, “HOUSTON: Real-time anomaly detection of attacks against Ethereum DeFi protocols,” in Network and Distributed System Security Symposium (NDSS). The Internet Society, 2026.DOI
  13. [13]T. Abdelaziz and K. Ali, “TxLens: Scalable real-time detection of malicious Ethereum transactions,” in IEEE International Conference on Blockchain and Cryptocurrency (ICBC). IEEE, 2026, pp. 1–10.DOI
  14. [14]Z. Zheng, J. Su, J. Chen, D. Lo, Z. Zhong, and M. Ye, “DAppSCAN: Building large-scale datasets for smart contract weaknesses in DApp projects,” IEEE Transactions on Software Engineering (TSE), vol. 50, no. 6, pp. 1360–1373, 2024.DOI
  15. [15]J. Wang, A. Bigger, X. Xu, J. W. Lin, A. Applebaum, T. Patwardhan, A. Yukseloglu, and O. Watkins, “EVM-bench: Evaluating AI agents on smart contract security,” CoRR, vol. abs/2603.04915, 2026.arxiv.org/abs/2603.04915
  16. [16]A. Alhaidari, B. Palanisamy, and P. Krishnamurthy, “On-chain decentralized learning and cost-effective inference for DeFi attack mitigation,” in Conference on Advances in Financial Technologies (AFT), ser. LIPIcs, vol. 354. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2025, pp. 35:1–35:27.DOI
  17. [17]J. Wu, K. Lin, D. Lin, B. Zhang, Z. Wu, and J. Su, “Safeguarding blockchain ecosystem: Understanding and detecting attack transactions on cross-chain bridges,” in ACM Web Conference (WWW). ACM, 2025, pp. 4902–4912.DOI
  18. [18]R. Croft, M. A. Babar, and H. Chen, “Noisy label learning for security defects,” in International Conference on Mining Software Repositories (MSR). ACM, 2022, pp. 435–447.arxiv.org/abs/2203.04468
  19. [19]Chainalysis, “Euler finance flash loan attack explained,” https://www.chainalysis.com/blog/euler-finance-flash-loan-attack/, 2023.
  20. [20]BlockSec, “Security incidents library,” https://blocksec.com/security-incident, downloaded 2026-10-11, 2026.
  21. [21]Alexander Biryukov, “evm-hack-registry,” https://github.com/sanbir/evm-hack-registry, commit 5e310fc, 2026.
  22. [22]T. Abdelaziz and K. Ali, “TxBench: Verifying public incident data to benchmark smart-contract attack detectors,” Dataset, Oct. 2026. [Online]. Available: https://doi.org/10.5281/zenodo.23758032
  23. [23]SunWeb3Sec, “DeFiHackLabs: Reproduce DeFi hacked incidents using Foundry,” https://github.com/SunWeb3Sec/DeFiHackLabs, 2026.
  24. [24]Foundry, “Foundry: A blazing fast, portable and modular toolkit for ethereum application development,” https://github.com/foundry-rs/foundry, 2024.
  25. [25]OWASP Smart Contract Security Project, “Smart contract weakness enumeration (SCWE), version 1.0,” https://scs.owasp.org/SCWE/, commit fefd476, 2026.
  26. [26]Sourcify, “Sourcify: Source code verification for ethereum smart contracts,” https://sourcify.dev/, 2026.
  27. [27]DefiLlama, “DefiLlama coins API: Historical token prices,” https://api-docs.defillama.com, 2026.
  28. [28]H. Adams, N. Zinsmeister, M. Salem, R. Keefer, and D. Robinson, “Uniswap v3 core,” Uniswap rep., 2021.
  29. [29]E. Frangella and L. Herskind, “Aave v3 technical paper,” Tech. rep., Aave, 2022.
  30. [30]K. Herzig, S. Just, and A. Zeller, “It’s not a bug, it’s a feature: how misclassification impacts bug prediction,” in International Conference on Software Engineering (ICSE). IEEE Computer Society, 2013, pp. 392–401.DOI

Paper details

vlnc:W_wjn5wyh5
Version
v2 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 14

downloads · 1

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents