Chong Chen, Jiachi Chen, Lingfeng Bao, David F. Lo · 10 authors
Smart contract vulnerabilities, particularly improper Access Control that allows unauthorized execution of restricted functions, have caused billions of dollars in losses. GitHub hosts numerous smart contract repositories containing source code, documentation, and configuration files-these serve as intermediate development artifacts that must be compiled and packaged before deployment. Third-party developers often reference, reuse, or fork code from these repositories during custom development. However, if the referenced code contains vulnerabilities, it can introduce significant security risks. Existing tools for detecting smart contract vulnerabilities are limited in their ability to handle complex repositories, as they typically require the target contract to be compilable to generate an abstract representation for further analysis. This paper presents TRACE, a tool designed to secure non-compilable smart contract repositories against access control vulnerabilities. TRACE employs LLMs to locate sensitive functions involving critical operations (e.g., transfer) within the contract and subsequently completes function snippets into a fully compilable contract. TRACE constructs a function call graph from the abstract syntax tree (AST) of the completed contract. It uses the control flow graph (CFG) of each function as node information. The nodes of the sensitive functions are then analyzed to detect Access Control vulnerabilities. Experimental results demonstrate that TRACE outperforms state-of-the-art tools on an open-sourced CVE dataset, detecting 14 out of 15 CVEs. In addition, it achieves 89.2% precision on 5,000 recent on-chain contracts, far exceeding the best existing tool at 76.9%. On 83 real-world repositories, TRACE achieves 87.0% precision, significantly surpassing DeepSeek-R1's 14.3%.
Hadis Rezaei, Ahmed Afif Monrat, Karl Andersson, Francesco Palmieri
The deterministic nature of blockchain technology creates fundamental difficulties in producing secure random numbers within smart contracts, a limitation that exposes vulnerabilities in applications such as decentralized finance (DeFi) protocols and blockchain-based gaming platforms. From our observations, the current state-of-the-art detection tools suffer from inadequate precision while dealing with random number vulnerabilities. To address this problem, we propose TaintSentinel, a novel path-sensitive vulnerability detection system designed to analyze smart contracts at the execution path level and gradually analyze taint with domain-specific rules. This paper discusses a solution that incorporates a multifaceted approach, integrating rule-based taint analysis to track data flow, a dual-stream neural network to identify complex vulnerability signatures, and evidence-based parameter initialization to minimize false positives. The two-phase operation of the system involves the construction of semantic graphs and the analysis of taint propagation, followed by pattern recognition using PathGNN and global structural analysis via GlobalGCN. Our experiments on 4,844 contracts demonstrate the superior performance of TaintSentinel relative to existing tools, yielding an F1-score of 0.892, an AUC-ROC of 0.94, and a PRA accuracy of 97%.
The increasing prevalence of Maximal Extractable Value (MEV) in blockchain networks has highlighted critical challenges in achieving fair and predictable transaction ordering. On Ethereum, where block builders possess unrestricted control over transaction sequencing, users face significant risks from frontrunning and sandwich attacks, particularly within decentralized finance (DeFi) applications interacting with shared contract states. To address this issue, this paper proposes a hybrid MEV mitigation method employing Lamport-style logical clocks, designed to establish a local causal ordering mechanism within individual smart contracts. The proposed approach equips each smart contract, such as a decentralized exchange liquidity pool, with a local logical timestamp counter. Transactions submitted to the contract carry logical timestamps, enabling the enforcement of a causally consistent execution order. A key benefit of this method is that it does not necessitate alterations to Ethereum’s global consensus mechanism, thus ensuring compatibility with the current Ethereum ecosystem, as well as rollups and modular app-chain architectures. The study details the protocol design, explores various implementation strategies for both on-chain and off-chain execution environments, and addresses resilience against adversarial attempts such as timestamp manipulation and denial-of-service attacks. The primary advantage of this approach lies in its effectiveness in mitigating intra-contract MEV extraction by strictly controlling transaction reordering for conflicting state interactions, while preserving concurrency for non-conflicting transactions. Findings indicate that the use of local Lamport clocks provides a practical, low-overhead solution for MEV-sensitive applications, including decentralized exchanges and rollup sequencing systems.
Cross-chain interoperability is essential for the next generation of decentralized finance applications, yet existing bridges suffer from security weaknesses, high latency, and fragmented trust models. This paper introduces SnapBridge, a protocol that transfers assets across heterogeneous blockchains using cryptographic state snapshots combined with optimistic verification. A snapshot aggregator collects Merkleized proofs of account states and transaction histories from the source chain. Instead of verifying all proofs on-chain, SnapBridge relies on optimistic execution: transfers proceed immediately but can be challenged within a fraud-proof window. Fraud detection is performed by light clients using succinct verification rules. We implement SnapBridge across Ethereum, Polygon, and Avalanche testnets and benchmark transfer throughput, failure handling, and gas consumption. Results show up to 3× improvement in transfer latency and a 40% reduction in on-chain verification cost compared to multisig-based bridges. The paper evaluates adversarial scenarios such as corrupted aggregators, delayed snapshots, and chain reorgs. SnapBridge provides a modular, safer alternative for cross-chain liquidity flows.
Maximal Extractable Value (MEV) refers to a class of attacks to decentralized applications where the adversary profits by manipulating the ordering, inclusion, or exclusion of transactions in a blockchain. Decentralized Finance (DeFi) protocols are a primary target of these attacks, as their logic depends critically on transaction sequencing. To date, MEV attacks have already extracted billions of dollars in value, underscoring their systemic impact on blockchain security. Verifying the absence of MEV attacks requires determining suitable upper bounds, i.e. proving that no adversarial strategy can extract more value (if any) than expected by protocol designers. This problem is notoriously difficult: the space of adversarial strategies is extremely vast, making empirical studies and pen-and-paper reasoning insufficiently rigorous. In this paper, we present the first mechanized formalization of MEV in the Lean theorem prover. We introduce a methodology to construct machine-checked proofs of MEV bounds, providing correctness guarantees beyond what is possible with existing techniques. To demonstrate the generality of our approach, we model and analyse the MEV of two paradigmatic DeFi protocols. Notably, we develop the first machine-checked proof of the optimality of sandwich attacks in Automated Market Makers, a fundamental DeFi primitive.
Smart contracts have emerged as key components within decentralized environments, enabling the automation of transactions through self-executing programs. While these innovations offer significant advantages, they also present potential drawbacks if the smart contract code is not carefully designed and implemented. This paper investigates the capability of large language models (LLMs) to detect OWASP-inspired vulnerabilities in smart contracts beyond the Ethereum Virtual Machine (EVM) ecosystem, focusing specifically on Solana and Algorand. Given the lack of labeled datasets for non-EVM platforms, we design a synthetic dataset of annotated smart contract snippets in Rust (for Solana) and PyTeal (for Algorand), structured around a vulnerability taxonomy derived from OWASP. We evaluate LLMs under three configurations: prompt engineering, fine-tuning, and a hybrid of both, comparing their performance on different vulnerability categories. Experimental results show that prompt engineering achieves general robustness, while fine-tuning improves precision and recall on less semantically rich languages such as TEAL. Additionally, we analyze how the architectural differences of Solana and Algorand influence the manifestation and detectability of vulnerabilities, offering platform-specific mappings that highlight limitations in existing security tooling. Our findings suggest that LLM-based approaches are viable for static vulnerability detection in smart contracts, provided domain-specific data and categorization are integrated into training pipelines.
Jonas Gebele, Timm Mutzel, Burak Oez, Florian Matthes
Sealed-bid auctions ensure fair competition and efficient allocation but are often deployed on centralized infrastructure, enabling opaque manipulation. Public blockchains eliminate central control, yet their inherent transparency conflicts with the confidentiality required for sealed bidding. Prior attempts struggle to reconcile privacy, verifiability, and scalability without relying on trusted intermediaries, multi-round protocols, or expensive cryptography. We present a sealed-bid auction protocol that executes sensitive bidding logic on a Trusted Execution Environment (TEE)-backed confidential compute blockchain while retaining settlement and enforcement on a public chain. Bidders commit funds to enclave-generated escrow addresses, ensuring confidentiality and binding commitments. After the deadline, any party can trigger resolution: the confidential blockchain determines the winner through verifiable off-chain computation and issues signed settlement transactions for execution on the public chain. Our design provides security, privacy, and scalability without trusted third parties or protocol modifications. We implement it on SUAVE with Ethereum settlement, evaluate its scalability and trust assumptions, and demonstrate deployment with minimal integration on existing infrastructure.
Xihan Xiong, Zhipeng Wang, Qin Wang, William Knottenbelt
Decentralized communication is becoming an important use case within Web3. On Ethereum, users can repurpose the transaction input data field to embed natural-language messages, commonly known as Input Data Messages (IDMs). However, as IDMs gain wider adoption, there has been a growing volume of toxic content on-chain. This trend is concerning, as Ethereum provides no protocol-level support for content moderation. We propose two moderation frameworks for Ethereum IDMs: (i) BUILDERMOD, where builders perform semantic checks during block construction; and (ii) USERMOD, where users proactively obtain moderation proofs from external classifiers and embed them in transactions. Our evaluation reveals that BUILDERMOD incurs high block-time overhead, which limits its practicality. In contrast, USERMOD enables lower-latency validation and scales more effectively, making it a more practical approach in moderation-aware Ethereum environments. Our study lays the groundwork for protocol-level content governance in decentralized systems, and we hope it contributes to the development of a decentralized communication environment that is safe, trustworthy, and socially responsible.
Zilga Heritiana Randriamiarison, Hajarisena Razafimahatratra, Nicolas Raft Razafindrakoto, Yassine Rhazali
A smart contract is a program deployed on a blockchain network and becomes immutable once deployed. Reentrancy bugs are among the most significant vulnerabilities in blockchain technology. Numerous approaches have been proposed to detect and analyze them. However, minimizing reentrancy errors in smart contracts remains a challenge. The aim of this paper is to optimize the handling of reentrancy bugs in smart contracts across different versions of Solidity. It also proposes a new method for syntactic and lexical code detection. Our approach is based on static analysis, and the tool can detect different versions of smart contract code. We used regex to identify external calls in the contract and Control Flow Graph (CFG) to identify the components of the code. A detection algorithm was developed to identify reentrancy vulnerabilities. This approach enhances contract reliability and reduces risk prior to deployment. Our method has been evaluated using True Positive Rate (TPR) and False Positive Rate (FPR) metrics. We tested it on the SmartBugs benchmark suite and contracts from Etherscan. The contracts analyzed include two solidity versions: 0.4.x and 0.8.x. Thanks to the integration of multiple tools, our solution supports testing across different solidity versions.
Ziyang Liu, Kenneth MacKenzie, Roman Kireev, Michael Peyton Jones · 6 authors
The Cardano blockchain is the first to use proof of stake, offers native support for multiple currencies and is evolving toward a distributed governance model. It supports smart contracts through Plutus, a language based on System Fω with recursion. About half a dozen languages compile into Plutus, the first of which is Plinth (formerly Plutus Tx) — a language that reuses a subset of the Haskell syntax, and has been in commercial use since 2021.
Zero-knowledge proof (ZKP) applications require translating high-level programs into arithmetic circuits–a process that demands both correctness and efficiency. While recent DSLs improve usability, they often yield suboptimal circuits, and hand-optimized implementations remain difficult to construct and verify. We present Tabby, a synthesis-aided compiler that automates the generation of high-performance ZK circuits from highlevel code. Tabby introduces a domain-specific intermediate representation designed for symbolic reasoning and applies sketch-based program synthesis to derive optimized low-level implementations. By decomposing programs into reusable components and verifying semantic equivalence via SMT-based reasoning, Tabby ensures correctness while achieving substantial performance improvements. We evaluate Tabby on a suite of real-world ZKP applications and demonstrate significant reductions in proof generation time and circuit size against mainstream ZK compilers.
Decentralized applications (dApps) in Decentralized Finance (DeFi) face a fundamental tension between regulatory compliance requirements like Know Your Customer (KYC) and maintaining decentralization and privacy. Existing permissioned DeFi solutions often fail to adequately protect private attributes of dApp users and introduce implicit trust assumptions, undermining the blockchain's decentralization. Addressing these limitations, this paper presents a novel synthesis of Self-Sovereign Identity (SSI), Zero-Knowledge Proofs (ZKPs), and Attribute-Based Access Control to enable privacy-preserving on-chain permissioning based on decentralized policy decisions. We provide a comprehensive framework for permissioned dApps that aligns decentralized trust, privacy, and transparency, harmonizing blockchain principles with regulatory compliance. Our framework supports multiple proof types (equality, range, membership, and time-dependent) with efficient proof generation through a commit-and-prove scheme that moves credential authenticity verification outside the ZKP circuit. Experimental evaluation of our KYC-compliant DeFi implementation shows considerable performance improvement for different proof types compared to baseline approaches. We advance the state-of-the-art through a holistic approach, flexible proof mechanisms addressing diverse real-world requirements, and optimized proof generation enabling practical deployment.
We present a cross-market algorithmic trading system that balances execution quality with rigorous compliance enforcement. The architecture comprises a high-level planner, a reinforcement learning execution agent, and an independent compliance agent. We formulate trade execution as a constrained Markov decision process with hard constraints on participation limits, price bands, and self-trading avoidance. The execution agent is trained with proximal policy optimization, while a runtime action-shield projects any unsafe action into a feasible set. To support auditability without exposing proprietary signals, we add a zero-knowledge compliance audit layer that produces cryptographic proofs that all actions satisfied the constraints. We evaluate in a multi-venue, ABIDES-based simulator and compare against standard baselines (e.g., TWAP, VWAP). The learned policy reduces implementation shortfall and variance while exhibiting no observed constraint violations across stress scenarios including elevated latency, partial fills, compliance module toggling, and varying constraint limits. We report effects at the 95% confidence level using paired t-tests and examine tail risk via CVaR. We situate the work at the intersection of optimal execution, safe reinforcement learning, regulatory technology, and verifiable AI, and discuss ethical considerations, limitations (e.g., modeling assumptions and computational overhead), and paths to real-world deployment.
Jeongin Lee, Geunyeong Choi, Jihyo Han, Jungheum Park
Monero, a privacy-preserving cryptocurrency, employs advanced cryptographic techniques to obfuscate transaction participants and amounts, thereby achieving strong untraceability. However, digital forensic approach can still reveal sensitive information by examining off-chain artifacts such as memory and wallet files. In this work, we conduct an in-depth forensic analysis of Monero's wallet application, focusing on the handling of public and private keys and the wallet's data storage formats. We reveal how these keys are managed in memory and develop a memory scanning algorithm capable of identifying key-related data structures. Furthermore, we analyze the wallet keys and cache files, presenting a method for decrypting and interpreting serialized keys and transaction data encrypted with a user-specified passphrase. Our approach is implemented as an open-source Volatility3 plugin and a set of decryption scripts. Finally, we discuss the applicability of our methodology to multi-cryptocurrency wallets that incorporate Monero components, thereby validating the generalizability of our techniques.
With the advent of Web3, there has been an unprecedented number of smart contracts being executed on decentralized networks like Bitcoin and Ethereum. While recent studies offer vulnerability detection frameworks and mitigation recommendations, little research addresses the pipeline from vulnerability detection to meaningful patch generation. We introduce VulnPatch, a generalized smart contract auditing and patching framework that employs multiple, fine-tuned LLM agents with distinct roles: detecting vulnerable functions, explaining their causes, and generating patched code. We have demonstrated empirically that having these sub-tasks delegated to different agents significantly improves performance across these sub-tasks rather than having one single agent that will handle all the tasks together. VulnPatch operates in three stages: first, fine-tuning the LLM on vulnerable and safe Solidity contracts; second, pinpointing vulnerability causes; and third, producing a report detailing vulnerable code and corresponding patches. Compared to state-of-the-art LLMs, VulnPatch achieves $\mathbf{9 3. 3 \%}$ accuracy and F1 score, generating reports for 84.44% of vulnerabilities, with explanations and patches showing $90 \%$ sound reasoning and $84 \%$ patch validity.
Umna Iftikhar, Hafiz Muhammad Attaullah, Inam Ullah Khan, Muhammad Mansoor Alam · 6 authors
Verification of a qualification, achievement, quality, or aspect of a person’s background is one of the biggest problems nowadays as we have seen many platforms where students can get fake credentials. Every organization must select professional and academically qualified employees to give quality service. As a result, corporations rely on academic certifications to confirm and measure their prospective employees’ academic qualifications. On the other hand, these employers lack a standardized process for confirming the legitimacy of academic certificates or degrees. Because the present procedures for verifying educational certifications are time-consuming, exhausting, and costly, just a few employers verify certificates for prospective employees. This research examines the issues that are related to the smart verification of someone’s credentials. To make the process of verifying digital credentials quicker, simpler, and more cost-effective, we suggest decentralized architecture. We present the prototype, design, and implementation of the proposed framework.
Bug reproduction is becoming an important task in the security analysis of Solidity smart contracts. By simulating attacks, developers and auditors can better understand how a vulnerability is triggered in practice. To reproduce a bug, one often needs to define an attacker contract and a specific sequence of interactions that exploit the vulnerability. However, in smart contracts, there are rarely automated tools that can generate such contracts and sequences and validate their correctness. Existing security tools, such as formal verifiers, are effective at detecting bugs, but they are not designed for bug reproduction. They often omit execution traces or produce incomplete ones. Moreover, their reports rarely reflect the behaviour patterns of attacker contracts. This gap motivates our work. We propose VeriExploit, a framework that combines formal methods and large language models to automatically generate, validate, and refine reproduction contracts and execution steps. Given a vulnerable contract and its counterexample, VeriExploit produces a contract that re-triggers the same bug and outputs a concrete trace showing how the exploit works. Experiments show that VeriExploit is effective at automating bug reproduction, achieving a success rate of 85.60% on our benchmark dataset.
Nayantara Thomas, Liya Treesa Philip, Pampana Jahnavi, R. Sujatha · 5 authors
The increasing complexity and globalization of the semiconductor supply chain, particularly in Field-Programmable Gate Arrays (FPGAs), has introduced significant vulnerabilities including counterfeiting, unauthorized modifications, and malicious hardware insertions. To address these challenges, this project proposes a novel security framework that integrates Zero Trust Architecture (ZTA), blockchain technology, and Arbiter Physical Unclonable Functions (PUFs) to enhance the authenticity, traceability, and resilience of the FPGA supply chain. The framework employs PUFs to generate unique hardware identities for FPGA components, which are authenticated through smart contracts and immutably recorded on a permissioned blockchain. By adopting ZTA principles, the system ensures continuous verification of all entities and components across the supply chain. The proposed architecture supports real-time monitoring, automated anomaly detection, and role-based access control, creating a tamper-proof and transparent ledger of FPGA transactions. This approach significantly strengthens supply chain integrity, mitigates risks of counterfeit insertion, and establishes a secure foundation for deploying FPGAs in mission-critical applications such as defense, telecommunications, and AI systems.
Physical Unclonable Functions (PUFs) and Hardware Security
Ensuring the integrity of business processes without disclosing confidential business information is a major challenge in inter-organizational processes. This paper introduces a zero-knowledge proof (ZKP)-based approach for the verifiable execution of business processes while preserving confidentiality. We integrate ZK virtual machines (zkVMs) into business process management engines through a comprehensive system architecture and a prototypical implementation. Our approach supports chained verifiable computations through proof compositions. On the example of product carbon footprinting, we model sequential footprinting activities and demonstrate how organizations can prove and verify the integrity of verifiable processes without exposing sensitive information. We assess different ZKP proving variants within process models for their efficiency in proving and verifying, and discuss the practical integration of ZKPs throughout the Business Process Management (BPM) lifecycle. Our experiment-driven evaluation demonstrates the automation of process verification under given confidentiality constraints.
Adversarial smart contracts, mostly on EVM-compatible chains like Ethereum and BSC, are deployed as EVM bytecode to exploit vulnerable smart contracts for financial gain. Detecting such malicious contracts at the time of deployment is an important proactive strategy to prevent losses from victim contracts. It offers a better cost-benefit ratio than detecting vulnerabilities on diverse potential victims. However, existing works are not generic with limited detection types and effectiveness due to imbalanced samples, while the emerging LLM technologies, which show their potential in generalization, have two key problems impeding its application in this task: hard digestion of compiled-code inputs, especially those with task-specific logic, and hard assessment of LLM's certainty in its binary (yes-or-no) answers. Therefore, we propose a generic adversarial smart contracts detection framework FinDet, which leverages LLM with two enhancements addressing the above two problems. FinDet takes as input only the EVM bytecode contracts and identifies adversarial ones among them with high balanced accuracy. The first enhancement extracts concise semantic intentions and high-level behavioral logic from the low-level bytecode inputs, unleashing the LLM reasoning capability restricted by the task input. The second enhancement probes and measures the LLM uncertainty to its multi-round answering to the same query, improving the LLM answering robustness for binary classifications required by the task output. Our comprehensive evaluation shows that FinDet achieves a BAC of 0.9374 and a TPR of 0.9231, significantly outperforming existing baselines. It remains robust under challenging conditions including unseen attack patterns, low-data settings, and feature obfuscation. FinDet detects all 5 public and 20+ unreported adversarial contracts in a 10-day real-world test, confirmed manually.
Mohamed Abdessamed Rezazi, Mouhamed Amine Bouchiha, A. Bendada, Yacine Ghamri-Doudane
Roaming settlement in 5G and beyond networks demands secure, efficient, and trustworthy mechanisms for billing reconciliation between mobile operators. While blockchain promises decentralization and auditability, existing solutions suffer from critical limitations-namely, data privacy risks, assumptions of mutual trust, and scalability bottlenecks. To address these challenges, we present B5GRoam, a novel on-chain and zero-trust framework for secure, privacy-preserving, and scalable roaming settlements. B5GRoam introduces a cryptographically verifiable call detail record (CDR) submission protocol, enabling smart contracts to authenticate usage claims without exposing sensitive data. To preserve privacy, we integrate non-interactive zero-knowledge proofs (zkSNARKs) that allow on-chain verification of roaming activity without revealing user or network details. To meet the high-throughput demands of 5G environments, B5GRoam leverages Layer 2 zk-Rollups, significantly reducing gas costs while maintaining the security guarantees of Layer 1. Experimental results demonstrate a throughput of over 7,200 tx/s with strong privacy and substantial cost savings. By eliminating intermediaries and enhancing verifiability, B5GRoam offers a practical and secure foundation for decentralized roaming in future mobile networks.
Marine carbon dioxide removal (mCDR) projects are increasingly recognized as a strategic pillar in climate change mitigation. However, their effectiveness and credibility critically depend on the ability to implement secure and verifiable Monitoring, Reporting, and Verification (MRV) procedures, particularly in remote, adversarial, and resource-constrained environments like underwater ecosystems. Despite growing interest in mCDR, current MRV frameworks remain inadequate for such challenging contexts, lacking essential mechanisms to ensure secure device identity, reliable data provenance, and verifiable auditability, as mandated by standards such as ISO 14064-2 and ISO 14064-3. This thesis addresses these limitations by first focusing on the fundamental security challenges that arise in underwater untrusted environments. To overcome these barriers, it introduces a set of modular, composable building blocks that integrate: i) decentralized identifiers (DIDs) for self-sovereign identity management, ii) physically unclonable functions (PUFs) to cryptographically bind secrets to hardwaredevices, iii) non-interactive zero-knowledge proofs (NIZKPs) to enable lightweight and privacy-preserving authentication, and iv) distributed ledger technologies (DLTs) to ensure immutable and verifiable data anchoring. These solutions are designed to be modular, interoperable, and composable, providing the necessary foundation to build secure, transparent, and standards-compliant MRV frameworks suitable for deployment in underwater and blue carbon ecosystems. Crucially, the proposed work does not merely adapt to MRV requirements but proactively resolves critical security gaps that existing MRV models overlook, thus enabling trustworthy data collection, secure identity management, and verifiable certification in these complex environments. The individual building blocks have been implemented and validated on constrained embedded platforms (e.g., ESP32-C3), demonstrating their feasibility under the constraints of underwater sensing. Formal security guarantees are established using symbolic analysis, while empirical evaluations quantify the computational and communication overhead of each component under realistic conditions. By starting from low-level cryptographic primitives and addressing core security challenges, this thesis delivers a foundational contribution to the development of secure, verifiable, and scalable MRV infrastructures for underwater and blue carbon applications. The proposed approach supports the creation of trustworthy, standards-aligned MRV frameworks, enabling verifiable environmental accountability even in hostile and resource-constrained deployment scenarios.
Smart contracts power a vast array of blockchain applications, securing billions of dollars on decentralized finance, but their immutable nature turns every vulnerability into a permanent exploitable liability. Although automated security tools can efficiently detect many issues, their high false positive rates and lack of trust still require manual audits, which are costly and introduce deployment delays. In this paper, we present an end to end AI augmented auditing framework that leverages a multi-agent pipeline for comprehensive vulnerability detection and automated exploit generation. First, we review existing approaches such as static analysis, fuzzing, symbolic execution, formal verification, and machine learning methods, highlighting their strengths, limitations, and real world deployment experience. Building on this survey, we introduce a multi agent architecture composed of a Distributor Agent, an Attack Planner Agent, an Exploit Generator Agent, and an Audit Report Generator Agent. The pipeline ingests smart contract source code, documen-tation, and test suites to outline stepwise attack strategies and synthesize ready to compile Solidity exploit code. Exploits are compiled and validated in a containerized environment, enabling automated verification of attack effectiveness. We outline a validation strategy for future work, more specifically, applying the pipeline to capture the flag challenges and online bug bounty platforms, and we describe plans for prompt fine tuning, retrieval augmented generation, and formal verification integration to further enhance detection accuracy and exploit reliability. Our proposed framework promises a more comprehensive, scalable, and cost effective approach to smart contract security verification.