Papers for

smart contract developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Large language models help detect Solana bridge vulnerabilities accurately

LLMs as Validators for Cross-Chain Bridges: Evaluating Source-Level and Transaction-Level Attack Detection on Solana

Abstract: Cross-chain bridges have suffered substantial asset losses due to vulnerabilities in their on-chain programs. On Solana, missing validation checks can enable exploits even when the underlying blockchain operates correctly. The ability of large language models (LLMs) to diagnose these flaws from source code or transaction records, rather than merely raise alarms, remains insufficiently understood. We implement a native Rust lock-and-mint bridge on a local Solana validator with four exploitable variants: two model flaws from the Cashio and Wormhole incidents, while the other two represent vulnerability classes documented in Solana security audits. Paired vulnerable and secure programs, together with successful attacks, benign sessions, and blocked attempts, allow us to distinguish correct diagnoses from unsupported alarms. We evaluate six configurations of five open-weight models across 16,800 responses, compare source inputs with and without comments, and grade 7,200 answers on vulnerable inputs using two blinded LLM graders. The results reveal substantial differences across conditions: without comments, models diagnose 24% of vulnerable source inputs while frequently flagging the secure bridge. Transaction diagnosis is high for the missing-signer scenario but averages 6% across the other three scenarios. Original comments, some of which describe the flaw, increase source diagnosis to 60%. These findings highlight the importance of distinguishing correct vulnerability diagnoses from unsupported alarms in bridge security review.

Mon 16 NovCryptography and SecurityArtificial Intelligence
The gist
Cross-chain bridges that connect different blockchains sometimes lose assets due to hidden software bugs. This paper studies how large language models (LLMs) can find these bugs by analyzing the program’s source code or transaction data on Solana, a blockchain platform. The authors created different versions of a bridge with known bugs and safe versions to test the models. They found that LLMs do better at spotting bugs when source code comments explain the problem, and that diagnosing transactions is very effective for some bug types but poor overall. This work shows that careful use of LLMs could improve bridge security by distinguishing real bugs from false alarms.
Open → 2611.21777v1

Type confusion attacks limited to typed security guarantees in software

Type-Confusion Security

Abstract: Type systems are a lightweight way to obtain formal assurance that code upholds security properties. However, decentralized systems, such as smart contracts and Model Context Protocol ecosystems, have limited ability to constrain the behavior of untrusted code. In such systems, attackers may attempt to confuse trusted code by supplying values that do not behave according to their advertised types, an attack that we call type confusion. Well-known attacks such as confused deputy attacks, reentrancy attacks, and control-flow hijacking can be understood as instances of type confusion. We define type confusion security as the property that unrestricted attackers who need not follow the type system have no more power than limited attackers who fully obey it. We formally define type confusion security as a real--ideal emulation, and in the context of an information-flow-typed core calculus that statically enforces security against well-typed attackers, prove that its run-time checks also enforce security against ill-typed attackers. In this system, programmers can write code while reasoning about security only against well-typed attackers; the security guarantees enforced by the type system still hold. We mechanize a proof of type confusion security in Lean.

Sun 15 NovProgramming LanguagesCryptography and Security
The gist
Sometimes hackers try to trick computer programs by giving them information that doesn’t match the expected type, like pretending a number is something else, causing security problems. The authors call this trick type confusion and show it underlies many known attacks. They prove that programs designed to be safe when attackers follow type rules remain safe even if attackers break those rules. They built a formal mathematical proof and a computer-checked verification to support this.
Open → 2611.20298v1

Weaver speeds up blockchain by parallelizing transactions smarter

Weaver: Unlocking Blockchain Transaction Parallelism through State-Decoupled Symbolic Execution

Abstract: Transaction execution remains a major performance bottleneck in blockchains. Existing parallel execution engines are still blocked by slow state accesses on each transaction's critical path, creating a hidden loss of parallelism. This paper presents Weaver, a state-decoupled transaction processing paradigm that enables execution flow to proceed in the absence of concrete state values. Weaver represents states as lightweight symbolic references and records subsequent computation as symbolic expressions while concrete values are fetched on the fly. To handle state-dependent control flow, Weaver predicts the most likely branch direction through hierarchical symbolic pattern matching. Weaver further introduces expression-granular scheduling that evaluates each symbolic expression as soon as its state dependencies are resolved, rather than waiting for the transaction's entire read set, fully exploiting fine-grained intra-transaction parallelism. Evaluation on real Ethereum blocks and synthetic workloads spanning four representative dApps shows that Weaver delivers 41%-63% higher throughput than state-of-the-art parallel execution engines and up to 7.5 times the throughput of serial execution.

Wed 4 NovDistributed, Parallel, and Cluster Computing
The gist
Blockchain transaction processing is often slow because transactions need to wait for data from the blockchain's state. The authors present Weaver, a system that lets transactions run using symbolic placeholders instead of waiting for actual data, making execution faster. Weaver predicts which parts of a transaction will happen next and runs computations as soon as their data is ready, allowing many parts of transactions to run at the same time. This approach improves transaction throughput significantly compared to existing methods and serial processing.
Open → 2611.06462v1

Failure types and severity ranking for Ethereum smart contracts

A Failure Mode Taxonomy and Severity Model for Ethereum Smart Contracts

Abstract: Smart contracts are a core component of blockchain systems, but their immutability makes failures in deployed code catastrophic and irreversible. Existing work classifies vulnerabilities, defects, and attacks, yet the observable failures of smart contracts, the deviations from intended behavior or the expected ledger state seen once a contract is deployed, have been largely disregarded. In this paper, we design and validate a failure mode taxonomy for Ethereum smart contracts, together with a severity model that ranks failures by their observable impact. Using a literature review as input, we follow the taxonomy development method of Nickerson et al. to derive the failure modes and their dimensions, and we subject the resulting taxonomy to a saturation exercise over a systematic literature review, the OpenSCV vulnerability catalog, and smart contract incidents reported after the search cutoff. Each failure mode is characterized along five dimensions, namely root cause, violated security property, impact (recorded as primary, secondary, and other), affected component, and nature, and is given a standardized name targeting the observable malfunction rather than the underlying vulnerability. From the taxonomy, we derive CIPER, a five-level severity model that groups failure modes by their observable impact. The saturation exercise produced no new failure modes or dimensions. The taxonomy offers a shared vocabulary for describing what smart contracts do wrong when they fail, and CIPER links that vocabulary to the severity of each observable outcome.

Fri 30 OctSoftware Engineering
The gist
Smart contracts on blockchains like Ethereum can break in ways that cause serious problems because their code cannot be changed after deployment. The authors created a detailed classification system to name and describe these failures based on what actually goes wrong when a contract malfunctions. They also developed a severity model that ranks failures by how much damage they cause. This work provides a common language for talking about smart contract failures and helps prioritize fixing the most impactful issues.
Open → 2610.41685v1

Verifying Ethereum bytecode exactly with tested executable EVM semantics

Verifying deployed bytecode against executable EVM semantics, with exact gas and no added axioms

Abstract: Much of Ethereum's most consequential code is immutable bytecode: old output of unverified compilers, and protocol logic run as contract code. We show that such bytecode can be verified as it is, without trusting what produced it, without simplifying the machine it runs on, and with no axioms beyond Lean's own. Blanc, a Lean 4 verification stack, reads fixed runtime bytes via kernel-checked certificates and states every theorem against Jaune, an executable semantics of the EVM and block processing that passes all 34,205 blockchain-test cases of Ethereum's fixture release v20.0.2 that involve only forks that have governed mainnet since May 2025. Eight artifacts, deployed from 2017 to 2026, come from seven compiler versions and an assembler. For the EIP-7002 contract, we prove that the end-of-block call to it, whose failure would invalidate the block, succeeds whatever its storage holds, and that each block's withdrawal requests are exactly the oldest pending submissions; mainnet met these theorems' starting premises when Prague began. For a Uniswap V2 pair, we prove that after any valid history whose hashed slots stay apart, from any checkpoint representing its Solidity model's state, the storage represents that model replayed over exactly the committed calls, a balanced liquidity ledger stays balanced, and, under a premise on token answers, geometric-mean reserves per share fall only through the protocol fee. Exact gas makes liveness provable: a tracked WETH9 holder without code can withdraw by a transaction whose gas has a closed form, matching all 3,748 comparable mainnet receipts of its shape in 30,000 blocks. On Curve pool bytes compiled with the lock bug exploited in 2023, Jaune executes such a reentrancy from deployment; for bytes from a fixed compiler, we prove the lock excludes it. AI agents wrote the proofs in fifteen days under one author's direction, atop an existing stack.

Wed 14 OctProgramming LanguagesLogic in Computer Science
The gist
Ethereum runs important programs as bytecode, but many such programs come from unverified compilers and can be complex to trust. The authors show a way to verify these bytecodes directly and exactly, without simplifying the Ethereum Virtual Machine or relying on extra assumptions. They built tools in the Lean 4 proof system that can check real Ethereum code and prove important properties like correct contract calls and gas usage. Their system passed extensive tests on thousands of blockchain examples and proved key safety and liveness aspects for major Ethereum contracts, even finding known bugs in deployed code.
Open → 2610.19764v1

Cross-chain bridge verification flaws revealed through large vulnerability study

Understanding Verification Vulnerabilities in Cross-chain Bridges: An Empirical Study

Abstract: With the rapid development of blockchain technology, numerous heterogeneous blockchains have emerged, each featuring distinct architectures, consensus mechanisms, and application ecosystems. Cross-chain bridges have consequently become a critical infrastructure component, typically relying on smart contracts to facilitate message passing and asset transfers across heterogeneous blockchains. Unlike single-chain contracts, bridge contracts introduce additional verification logic to validate external-chain data, such as state proofs, message sender identities, and signatures. However, correctly implementing such logic is challenging. We refer to vulnerabilities that violate the security guarantees of cross-chain verification as Cross-chain Verification Vulnerabilities (CVVs). To characterize CVVs, we conduct the first systematic empirical study of this vulnerability class. By analyzing 588 security audit reports from 36 real-world cross-chain bridge projects, we derive 11 CVV patterns and organize them into 5 high-level categories according to the affected verification properties. Following this taxonomy, we construct a CVV dataset containing 830 vulnerability instances across 786 contract files. The dataset establishes mappings among audit reports, audited source-code versions, affected source files, and CVV-pattern labels. We then assess existing detection approaches. Current tools provide limited documented coverage of CVV patterns, while only two of four evaluated LLMs outperform an all-pattern constant baseline of 29.3% Macro-F1; the best reaches 51.2%. Together, the limited tool coverage and inconsistent LLM gains motivate detection methods tailored to cross-chain verification semantics.

Fri 9 OctCryptography and SecuritySoftware Engineering
The gist
Blockchains are like separate computer networks, and bridges connect them to share information and value. These bridges need to carefully check outside data, but the study finds it's very hard to get this checking right. The authors analyzed many security reports and identified common security problems in how these checks are done. They also tested current tools to detect these issues and found that many vulnerabilities still slip through.
Open → 2610.13170v1

Agent skills improve smart contract audits with model impact

Demystifying Agent Skills for Smart Contract Auditing: Design, Effectiveness, Behavioral Impact

Abstract: LLM agents, notably Claude Code and OpenAI Codex, are emerging as versatile tools beyond coding agents only. These agents can be enhanced with skills---reusable artifacts that package domain knowledge, workflows, and tool-use instructions. To date, however, little is known about how such skills are designed or how they affect agent effectiveness and behavior in practice. In this paper, we investigate these questions in smart contract security auditing, a domain in which agents have shown substantial promise. We systematically collect 83 smart contract audit skills from the wild and evaluate them on EVMBench across seven agent--model configurations. Our study examines three dimensions: (i) the design characteristics of audit skills, including their structure, knowledge representations, workflows, and tool dependencies; (ii) their effectiveness in improving vulnerability detection; and (iii) their influence on agent execution trajectories. We find that audit skills are mostly lightweight but heterogeneous in design, covering a broad yet imbalanced range of vulnerability types. Their effectiveness is determined primarily by the model rather than the agent harness: Codex/GPT-5.5 achieves the largest gains, improving detection score by 22.8% and captured award by 43.2%. We further find that skill triggering is a key bottleneck. When triggered, skills preserve a shared six-stage audit workflow while exhibiting distinct loading patterns and differential effects on agent behavior across configurations. We release our skill corpus and artifacts to support future research.

Thu 24 SeptSoftware Engineering
The gist
Smart contracts are digital agreements that need to be checked for security risks. The authors studied how special tools called 'skills' help AI agents find vulnerabilities in these contracts. They gathered many real audit skills and tested them with different AI models. They found that the AI model itself matters more than the skill design, and that activating these skills correctly is challenging. The results provide a better understanding of how AI skills work in smart contract security.
Open → 2609.29454v1

Universal fractal engine enables fast natural language decisions on edge devices

Universal Fractal Natural Language Decision Map: Real-Time Edge Triage Across Heterogeneous Domains

Abstract: Deploying Large Language Models for runtime operational triage incurs prohibitive latency (>100-500 ms), high VRAM requirements (>4-8 GB), and excessive energy dissipation. Extending Mandelbrot Fractal Neural Synthesis (Dagli et al., 2026), this paper presents the Universal Fractal Natural Language Decision Map, realized via the werr machine-native edge reflex runtime and the production answerr platform (https://answerr.me). Operating entirely without stored weight tensors (0 Bytes VRAM), the engine synthesizes deterministic decisions---noul (Boolean), choice (categorical), and score (ordinal)---by dynamically modulating 24-byte coordinate seeds along the chaotic boundary of the Mandelbrot set and evaluating 4-quadrant escape dynamics. Drawing inspiration from biological System-One reflex arcs, the engine introduces: (i) an Auto-Seed Router with domain projector Phi_D yielding a +28.8% accuracy gain over linear baselines; (ii) an Information-Theoretic Acoustic Damping Filter grounded in token entropy and phonetic spectral density that insulates against prompt injections (0.0% empirical bypass; 95% Wilson CI: [0.0%, 30.8%]) while pruning escape iterations by 45.8% (accelerating throughput 2.5x to 3.31 ms latency); and (iii) an Organic Dynamic Calibration framework using O(1) Exponential Moving Average (EMA, alpha=0.03) and quadrant phase rotation to eliminate positional bias. Benchmarked on bare-metal infrastructure (api.answerr.me:4431) across 1,150+ verified decisions (3,200+ questions) and ranked World #1 on the independent JevBench suite (81.65%), the framework achieves 92.6% macro-accuracy (95% CI: [90.8%, 94.1%]) with 7.08 ms median CPU latency. We provide an OpenAI-compatible API (/v1/chat/completions) and demonstrate feasibility on microcontrollers and 32-byte EVM smart contracts.

Mon 21 SeptNeural and Evolutionary ComputingArtificial IntelligenceComputation and Language
The gist
Using big language models to make quick decisions can require lots of memory and time, which is hard for small devices. This paper shows how to use a new fractal-based method to make natural language decisions instantly and without storing large models. The authors designed a system that mimics fast reflexes in biology, improving accuracy and safety while running in just milliseconds on small hardware. This makes it possible to do smart language tasks even on tiny devices like microcontrollers and smart contracts.
Open → 2609.25498v1

EVM Ahead-of-time compilation speeds up contract execution broadly

SkelOT: Reusing AOT Compilation Across EVM Contract Families

Abstract: Ahead-of-time (AOT) compilers (e.g., revmc, evmone, and DTVM) for the Ethereum Virtual Machine (EVM) reuse compilation artifacts at contract-code-hash granularity. This granularity is poorly matched to real EVM workloads dominated by \emph{contract families}: factory-, proxy-, and template-driven deployments that share instruction structure but differ in a small set of embedded constants. Across four EVM chains (Base, Ethereum, BSC, and Arbitrum), we find that 23.1--47.6\% of unique compilable bytecodes map to shared family skeletons within 10K-block windows. Per-hash AOT therefore redundantly recompiles structurally equivalent code, inflating compile time and artifact footprint while reducing workload coverage under finite compile budgets. We present \textsc{SkelOT}, an AOT framework that lifts the unit of compilation reuse from code hash to family skeleton. \textsc{SkelOT} compiles one native artifact per family, bakes invariant constants into the artifact, and reads variant constants from a per-contract runtime table. Built on revmc/LLVM and evaluated on a 10K-block Base mainnet corpus (3.52M transactions), \textsc{SkelOT} reduces compilation units by 47.5\%, artifact footprint by 57.4\%, and compile time by $2.19\times$, while preserving byte-identical execution outcomes versus per-hash AOT. At runtime, \textsc{SkelOT} delivers a $1.31\times$ median per-contract speedup across family members. Under a compile budget targeting 75\% execution-time coverage, \textsc{SkelOT} needs far fewer artifacts than per-hash AOT, and the advantage holds at every coverage target.

Mon 21 SeptCryptography and SecurityDistributed, Parallel, and Cluster ComputingEmerging Technologies
The gist
Ethereum contract code often comes in families that share most of their instructions but differ slightly in embedded constants. Current methods compile these contracts individually, wasting time by repeating work on very similar code. The authors introduce SkelOT, which compiles once per family and reuses that compilation, plugging in the differing constants as needed. This approach reduces compile time and storage while speeding up contract execution without changing how they run.
Open → 2609.24404v1