Deep Learning for Blockchain Security: A Concise Survey, Taxonomy, and Open Problems

There are few important components that constitute a blockchain system which together, provide a secure and transparent decentralized system of storing data. Combined, these elements form a decentralized, secure, and tamper-proof network that has the potential to be the foundation for multiple blockchain use cases like digital currencies, supply chain tracking, and digital identity verification [7].

A blockchain is made up of a few key parts that work together to keep it running, secure, and decentralized. Blocks are the basic pieces: each one holds a list of transactions, a time stamp, and the cryptographic hash of the block before it. This creates a tamper-evident chain. Because blockchains are decentralized, there’s no single company or server in charge, computers (nodes) in a peer-to-peer network handle transaction directly with each other. To keep everyone’s copy of the ledger in sync, the network uses a consensus method, an algorithm that checks and agrees on which transactions are valid. Blockchains can also run smart contracts, which are small programs that automatically execute agreements written in code, enabling decentralized apps (dApps). Security relies on cryptography hash functions (like SHA-256 or Keccak-256) and digital signatures to protect data and verify identities [8]. Figure 1 shows a simple overview of how a blockchain works.

Figure 1.

Blockchain process.

Blockchain security relies on a few core ideas. Immutability means that once information is written to a block, changing it later is extremely hard, which protects the ledger’s integrity. Transparency and auditability let everyone see the transactions, so it’s easy to check and track what happened [9]. Decentralization removes any single point of failure, making the network harder to attack and more reliable. Finally, consensus algorithms let many independent nodes agree on which transactions are valid, keeping the blockchain consistent and trustworthy [10].

Consensus sits at the heart of blockchains: it’s how distributed nodes agree on the ledger without a central authority. Different methods come with different trade-offs. Proof of Work (PoW) asks miners to solve hard puzzles very secure, but energy-hungry. Proof of Stake (PoS) picks validators based on how much they “stake,” cutting energy use but risking centralization and “nothing-at-stake” issues. Delegated Proof of Stake (DPoS) relies on a small group of elected validators, which boosts speed and scalability but increases centralization. Practical Byzantine Fault Tolerance (PBFT) uses multiple voting rounds to handle malicious nodes, but it doesn’t scale well to very large networks. All of these approaches balance security, efficiency, decentralization, and scalability in different ways, and each has its own weaknesses (for example, 51% attacks, Sybil attacks, and collusion). These risks must be weighed carefully when designing a secure, trustworthy blockchain system [11]. A quick summary of the main consensus mechanisms appears in Table 1.

Deep Learning (DL), it is a subfield of machine learning that uses artificial neural networks to separate high level features from data sources. DL has significantly changed the cybersecurity landscape by increasing the accuracy of fraud detection, anomaly detection, intrusion detection and malware classification. The DL model contains several hidden layers between input and output layer for learning the hierarchical features of the data. The main elements of DL models can be summarized as follows [16]:

• Neurons: each of these units, which transfer information in a way that is similar to biological neurons, calculates the data and then pass it to the next layer.

• Activation Functions: These are required to introduce non-linearity in the neural network such as ReLU, Sigmoid, and Tanh help neural networks capture complex patterns.

• Backpropagation: An algorithm used to modify the network weights in order to reduce the errors made during predictions.

• Optimization Algorithms: Techniques like Stochastic Gradient Descent (SGD), Adam, and RMSprop optimize model training.

Several deep learning architectures have been adopted to enhance blockchain security as shown in table 2.

Deep Learning is well-suited for blockchain security due to its ability to [19]:

• Detect Fraud & Anomalies: DL models have the ability to identify fraudulent patterns in blockchain transactions, reducing risk.

• Analyze Smart Contracts for Vulnerabilities: NLP deep learning models search Solidity code for issues.

• Prevent Malware Attacks: CNN-based smart contract malware classifier to detect out the dangerous smart contracts.

• Enhance Intrusion Detection Systems: Autoencoders and LSTMs identify suspicious network activity in blockchain nodes.

Several recent surveys touch on the intersection of deep learning and blockchain, but each leaves clear gaps. Earlier reviews on blockchain security either treat machine learning as a single homogeneous block or focus narrowly on one threat class such as smart-contract vulnerabilities or DDoS in IoT. Reviews of deep learning in cybersecurity, in turn, rarely engage with the unique constraints of decentralized ledgers — gas costs, on-chain inference budgets, mempool latency, and the off-chain/on-chain integration boundary. As a result, readers must consult several disjoint sources to obtain a unified view.

This survey differs from prior work along four dimensions. Scope: we cover six threat classes (fraud, smart-contract bugs, intrusion, consensus/MEV, privacy, malware) within a single framework. Taxonomy: we organize the literature along five orthogonal axes — threat class, integration locus, deep-learning family, data modality, and deployment setting. Deployment realism: we record the on-chain/off-chain integration locus for every surveyed work and discuss gas and latency consequences of on-chain inference. Critical lens: we discuss reproducibility, dataset shift under time-ordered splits, robustness gaps, and the absence of cost-aware metrics rather than catalogue accuracies.

Contributions. This survey makes four contributions that, to our knowledge, no prior review in this intersection has combined:

• A unified five-axis taxonomy covering six threat classes — fraud, smart-contract bugs, intrusion, consensus/MEV, privacy, and malware — rather than one in isolation.

• Explicit on-chain / off-chain / hybrid integration labelling for every surveyed work, with a quantitative discussion of gas and latency consequences.

• A code/data availability audit across the surveyed papers, turning the reproducibility critique from rhetorical into evidential.

• A critical analysis that contrasts random-split benchmark performance with time-ordered deployment performance, and frames the open problems accordingly.

We ran structured searches (2020–2025) in Scopus, IEEE Xplore, ACM DL, Web of Science, and Google Scholar using Boolean combinations of (blockchain OR smart contract OR DeFi OR Ethereum OR IoT) AND (deep learning OR neural OR GNN OR transformer OR autoencoder) AND (security OR intrusion OR anomaly OR fraud). Inclusion: peer-reviewed English articles with empirical evaluation on blockchain-relevant data; Exclusion: opinion pieces, purely theoretical crypto without ML, unreproducible gray literature (unless used only as case context). Two rounds of screening removed duplicates and off-scope items. We extracted: dataset/modality, task, DL model family, integration locus (on/off/hybrid), metrics (AUC/F1/precision-recall, latency), compute and on-chain cost (gas, TPS). Disagreements were resolved by re-reading or exclusion. Figure 2 shows their distribution by publication year and dominant deep-learning family.

Figure 2.

Distribution of the surveyed papers by publication year and dominant deep-learning family.

We categorize works along five orthogonal axes as summarized in Figure 3:

• Threat class — what the attacker tries to achieve: fraud/manipulation, intrusion/malware, smart-contract bugs & exploits, Sybil/phishing, consensus/MEV, privacy deanonymization.

• Integration locus — where the DL component runs relative to the chain: on-chain (contracts, zk/TEE-assisted inference), off-chain (indexers, SIEM, oracles), hybrid (on-chain verification with off-chain DL).

• DL family — the model architecture: GNNs (transaction/contract graphs), Transformers (time-series/logs/code), CNNs/RNNs (netflow/bytecode images/sequences), Autoencoders (unsupervised anomaly), GNN+AE/Contrastive (representation learning).

• Data modality — what is fed into the model: transaction graphs, bytecode/AST, mempool/events, network traffic, log traces, prices/DEX flows, IoT sensor streams.

• Deployment setting — the operational environment: DeFi/CeFi, smart-contract auditing, L1/L2 core infrastructure, IoT/IIoT, cross-chain bridges.

Figure 3.

Master Taxonomy: Threats, Integration Locus, DL Families, Data Modalities, and Deployment Settings

The issue of fraud detection in blockchain transactions is increasingly a topic of interest, especially in the wake of large hacks exposed through weaknesses in decentralized finance (DeFi) solutions. Deep learning models can be a great solution for detecting and preventing fraudulent transactions in blockchain system and its integration provides a high potential to improve the detection and prevention of fraud activities in blockchain based systems.

Last August, Poly Network, a system that enables users to send tokens to one another over several blockchains, was hit by a huge hack. Hackers abused Poly Network’s weaknesses to shift about $610 million in digital assets to wallets they own. The attack has been considered one of the biggest DeFi hacks to have occurred [22].

Attackers targeted Poly Network’s tools for moving assets between blockchains like Ethereum, Binance Smart Chain, and Polygon. They found a weakness in the smart contracts that manage these cross-chain transfers and used it to make unauthorized transactions.

Poly Network publicly asked the hackers to give the funds back, warning about possible legal action and the harm to the wider crypto community. In a surprising twist, the hackers began returning the money a few days later, saying their goal was to expose the flaws, not to steal assets.

In recent blockchain fraud-detection work, researchers are using deep learning and ensemble methods to boost accuracy and robustness. For example, Roy et al. (2022) built an Ethereum fraud classifier using an LSTM with a dense layer and used Information Gain to pick the most useful features, outperforming standard models [23]. Meanwhile, Ghosh et al. (2023) tackled Bitcoin fraud with an ensemble of deep models (including MLP, feed-forward networks, and attention-based LSTMs) to capture time-based and non-linear patterns, achieving strong accuracy and reliability [24]. Continuing with the interpretability, Olusegun and Yang (2024) proposed a fraud detector model for Ethereum based on Tabular Prior-Data Fitted Network (TabPFN), which is composed of several deep learning models such as MLP, LSTM, CNN and CLSTM, instructed by the features selected through SHAP the SHapley Additive exPlanations-based feature selection. In this case, their model does not only favor accuracy but emphasizes explainability, exposing insights about feature influence and model behavior [25].

Lakhan et al. (2022) proposed a serverless Blockchain-Enabled Task Scheduling (SBETS) model tailored for intelligent transportation systems (ITS), which integrates a deep graph convolutional neural network within a fog-cloud environment. Their approach effectively reduced processing overhead and improved fraud detection by 50%, utilizing a function-based price model to optimize computational cost [26]. Taher et al. (2024) built an Ethereum fraud detector by combining several classifiers with hard voting, reaching 99% accuracy, and they added XAI tools like LIME so users can see why the model made a decision [27]. Asiri and Somasundaram (2025) used a graph convolutional network on the Elliptic dataset to spot illegal Bitcoin transactions and found it outperformed logistic regression and random forest, with 98.5% accuracy and better AUC and RMSE [28]. Baabdullah et al. (2024) paired federated learning with blockchain to create a privacy-preserving credit card fraud system, letting different institutions train models without sharing raw data; they tried LSTM, CNN, and random forest, tuned with ADAM, SGD, and MSGD, and fixed class imbalance using SMOTE [29]. Finally, Gu and Dib (2025) designed an Ethereum fraud detector that ensembles SVM, XGBoost, and random forest; after grid-search tuning, it scored above 98% on accuracy, precision, recall, and F1, and ran quickly with about 0.13-second inference time [30].

Airlangga (2024) explored deep learning-based anomaly detection in the Open Metaverse by evaluating multi-layer perceptrons (MLP), convolutional neural networks (CNN), and long short-term memory (LSTM) models. Using a dataset of 78,600 blockchain transactions from virtual environments, the study employed 5-fold cross-validation with mean squared error (MSE) as the primary evaluation metric. Results showed that MLP outperformed other architectures, offering a robust and adaptive method for detecting anomalies in complex virtual economies [31]. Sun et al. (2025) proposes a joint pipeline that (i) turns raw Ethereum transaction attributes into “transaction sentences” and learns semantic embeddings with a BERT-style Transaction Language Model, (ii) builds a Transaction Attribute Similarity Graph (NPMI/TF-IDF) and an Account Interaction Graph, and (iii) jointly trains a multi-head attention fusion network with a GCN on the account graph. Evaluated on three Ethereum datasets (MulDiGraph, B4E, SPN), reporting +10–20% F1 over SOTA. Off-chain analytics; authors also release a new dataset.[32]

Kang and Hwang (2025) Introduces a Fraud-Oriented Transformer with Random Traversal: it stochastically traverses the transaction graph to form informative sequences for a Transformer, integrating deep graph features to classify fraudulent Ethereum accounts. On large Ethereum graphs, the paper reports superior AUC vs. baselines (details in article). Off-chain detection model [33]. Ferreira (2025) works with the Elliptic Bitcoin dataset. They do exploratory data analysis, pick and compress features (using methods like PCA and UMAP), and test several classifiers. XGBoost comes out on top for both two-class and three-class tasks. Dimensionality reduction helps with understanding the results, but full feature sets still perform best. The study also points out two big issues: severe class imbalance and very high feature dimensionality. The workflow runs off-chain [34].

Taken together, these papers suggest a clear shift toward deeper, more interpretable learning models that fit the complex patterns in blockchain transactions. As summarized in Table 3, multiple deep-learning methods have been tried for blockchain fraud detection, each offering specific advantages and trade-offs.

Smart contracts are automated contracts where the terms of the agreement between the parties are directly interpreted into code. They are built on top of blockchains such as Ethereum and can be used to create dApps in a world without middlemen. Yet, the immutable and autonomous nature of smart contracts exposes them to a range of security bugs, which have resulted in large financial losses. Figure 5 compares two Solidity smart contract implementations: Contract A (Vulnerable) and Contract B (Normal). Both contracts allow users to deposit and withdraw funds. However, Contract A demonstrates a classic reentrancy vulnerability by transferring Ether to the sender (msg.sender.call.value(…)) before updating the state variables (i.e., setting the lock and deducting the balance). This ordering allows malicious actors to re-enter the function before the state is updated, potentially draining the contract. In contrast, Contract B mitigates this vulnerability by updating the state before making the external call, following the checks-effects-interactions pattern, a recommended best practice in Ethereum smart contract development. Deep learning has been recognized as a promising technique to identify and suppress such vulnerabilities.

Figure 5.

An example of smart contracts [35]

The most high-profile example of a smart contract vulnerability is The DAO (Decentralized Autonomous Organization) hack in 2016. The DAO was an Ethereum-based investor-directed venture capital fund that raised more than $150 million (worth of Ether). In June 2016, The DAO's smart contract code was allegedly attacked after vulnerable spot reentrancy, resulting into the theft of an estimated $70 million worth of 3.6 million ether. This attack contravened a tremendous amount of monetary value and led to a forced hard fork of the Ethereum blockchain, causing Ethereum Classic [36]. The reentrant exploit helped the hacker repeatedly execute the withdraw function before the first transaction finished which eventually emptied the DAO's coffers.

Typical Vulnerabilities of Smart Contracts, open Issues of Smart contracts Beyond reentrancy, there are actually other ways that smart contracts can be vulnerable to:

Integer Overflow and Underflow: It is a type of error when the results of a calculation exceed the maximum value that the data type can store or fall below the minimum value.

Timestamp Dependence: Using block timestamps for critical operations can be abused by miners.

Unhandled Exceptions: Contracts are unpredictable or unable to execute when there is not proper exception handling.

These characteristics can be linked to the complexity of smart contract languages, such as Solidity, and the difficulties encountered for the secure development of smart contracts.

Researchers are using deep learning more and more to spot bugs in smart contracts. Li et al. (2023) combines several kinds of features (both static and dynamic) and feed them into GCNs and Bi-LSTMs to capture how the code is structured and what it means. Their system does well on common issues like reentrancy and timestamp dependence [37]. Li et al. (2022) takes a different route with Link-DC, which builds a contract graph and uses a Deep & Cross Network to turn simple, sparse features into richer ones, leading to strong accuracy across many vulnerability types [38]. Osei et al. (2024) introduce WIDENNET, which converts bytecode into opcode vectors and uses a wide-and-deep model. It strikes a good balance between speed and accuracy, though it covers fewer vulnerability categories [39].

To fix the lack of labeled data, Hwang et al. (2024) propose CGGNet, a compiler-guided generator. Instead of a standard GAN, it uses the compiler as an oracle and Monte Carlo Tree Search to create millions of valid, varied contract examples, helping models avoid underfitting [40]. Han et al. (2023) merge syntax and semantics by fusing features from ASTs and CFGs using TextCNN plus graph neural networks, boosting both accuracy and recall across several vulnerability types [41]. Li et al. (2024) focus on DEX contracts with StateGuard. They build ASTs, extract five key dependency signals (like control and data dependencies), and apply a GCN to catch subtle state mistakes that can cause security problems [42].

Other recent work follows the same theme of richer representations. Kasula et al. (2024) build a unified graph that mixes structural and semantic cues and report better results than traditional approaches [43]. Deng et al. (2023) fuse multiple “views” of a contract (source code, opcodes, and CFGs) by training deep models per view and combining their outputs for stronger predictions [44]. Chen et al. (2024) present Clear, which uses contrastive learning to model how vulnerable and safe contracts relate to each other. Clear significantly improves performance on many metrics and beats 13 prior deep-learning methods [35].

Wang et al. (2025) studies push beyond single-view code modeling toward multimodal and Transformer-centric pipelines. TMF-Net fuses textual (code tokens) and structural features (AST/CFG) via a multi-scale transformer fusion network, consistently beating single-modality baselines—especially on reentrancy and timestamp-dependence—by learning complementary representations across modalities [45]. Balci et al. (2025) present VASCOT targets compiled contracts, performing sequential analysis of EVM bytecode with a Transformer, and evaluates on ~16.4k verified Ethereum contracts deployed in 2022; independent summaries report ~90% test accuracy and superior speed vs. LSTM baselines, highlighting the practicality of bytecode-level detection when source is unavailable. Choi et al. (2025) proposed LLM + Graph Structural Analysis (CMC) integrates CodeBERT with CFG/AST-derived graphs (nodes embedded with Sent2Vec, centrality-weighted) and prompts an LLM using the fused features, reaching Acc 86.70 / F1 84.46 and beating CodeBERT-only baselines—evidence that graph cues materially help text models. Table 4 provides a comparative analysis of recent deep learning techniques applied to smart contract vulnerability detection.

Blockchain is decentralized and very secure, but it’s not completely safe from cyberattacks [47]. Intrusions such as the well-known 51% attack have exposed real weaknesses. That’s why strong protection is still essential, especially powerful intrusion detection systems that can spot and stop attacks quickly. Recent advances in deep learning have made these systems much better at detecting and responding to threats.

A clear example is the series of 51% attacks on the Ethereum Classic (ETC) network [48]:

• January 2019: Attackers gained control of over half of the network’s hashing power, reorganized the chain, and double-spent about 219,500 ETC (worth over $1.1 million).

• August 2020: ETC was hit by multiple 51% attacks in just one month, causing millions of dollars in losses and seriously undermining network security.

These incidents show why we urgently need advanced, real-time intrusion detection to protect blockchain networks.

Beyond 51% attacks, two attack families have come to dominate the threat landscape on smart-contract platforms: Maximal Extractable Value (MEV) exploitation and oracle manipulation. MEV refers to the profit a block proposer or sophisticated searcher can extract by reordering, inserting, or censoring transactions within a block — for example, sandwiching a victim's swap on a decentralized exchange, or front-running a profitable liquidation. Detecting MEV is fundamentally a temporal and graph-structured problem: candidate attacks manifest as suspicious transaction orderings in the mempool, often involving back-to-back trades against the same liquidity pool by related addresses. Oracle manipulation is the closely related problem of an attacker pushing a manipulated price into a DeFi protocol's price feed, typically via a flash loan that distorts a low-liquidity pool the oracle reads from. Detection here combines on-chain features (flash-loan call patterns, pool reserves, swap sizes) with cross-venue price signals from off-chain feeds to flag implausible deviations. Both MEV and oracle attacks share two characteristics the surveyed literature underweights: they are multi-block (attacks span several transactions and sometimes several blocks) and economically constrained (the attacker is profit-driven, so plausible attacks must remain economically rational).

The novel use of blockchain combined with deep learning in IDS as of the late has inspired the development of novel solutions to ensure the security of IoT and cloud networks [49]. In A deep blockchain framework-enabled collaborative intrusion detection system for securing IoT and cloud networks Al-Kadi et al. (2020) described a cooperative IDS which applies a BiLSTM-deep learning model for sequential network traffic, beside the help of Ethereum-blockchain and smart contracts for privacy and decentralized trust across IoT and cloud [50]. Elsewhere, Optimized blockchain-based deep learning model for cloud intrusion detection by Alasmari (2024) introduces a hybrid deep learning ensemble that consists of CNN, RBM, and GAN which is optimized by the hybrid seahorse and bat algorithm (HSHBA). This method could improve feature selection and prediction accuracy with blockchain as secure data storage and audibility [51]. Finally, Wang (2022) Embedded Architecture Protocol Network Intrusion Detection focuses on deep residual learning and adopted multi-threshold fusion, and spectral feature extraction, specifically for embedded blockchain-based protocols. This approach is focused more on accuracy of the abnormal traffic detection and no information regarding dataset normalization and larger blockchain integration [52].

Katib and Ragab (2023) introduced the H3SC-DLIDS model, which integrates Harris Hawks Optimization (HHO) with a sine cosine algorithm (SCA) for feature selection, followed by LSTM-based autoencoder (LSTM-AE) classification and hyperparameter tuning using the Arithmetic Optimization Algorithm (AOA). This hybrid methodology enhances DDoS attack detection accuracy in blockchain-enabled IoT environments [53]. Similarly, Mansour (2022) proposed the PRO-DLBIDCPS model for cyber-physical systems, employing an Adaptive Harmony Search Algorithm (AHSA) for feature selection and an attention-based BiGRNN classifier. The approach incorporates poor-rich optimization (PRO) for hyperparameter tuning and uses blockchain for securing CPS communications [54].

In a related study, Alkhonaini et al. (2024) developed SPOHDL-ID, which applies a sandpiper optimizer (SPO) for feature selection and combines CNN with a stacked autoencoder (SAE) for intrusion detection. The model further enhances accuracy through hyperparameter tuning using the Beetle Search Optimization Algorithm (BSOA), achieving notable performance on benchmark datasets [55]. Another hybrid system, BHS-ALOHDL by Alamro et al. (2023), uses Ant Lion Optimizer (ALO) for selecting optimal features and integrates CNN with LSTM for deep learning classification. Flower Pollination Algorithm (FPA) is then applied for hyperparameter tuning, offering significant improvements in IoT healthcare intrusion detection [56].

Kamali Poorazad et al. (2023) addressed vulnerabilities in SDN-enabled IIoT by integrating a CNN-based IDS within the SDN control plane, complemented by a blockchain system at the network layer. This dual-layer approach improves real-time threat mitigation and data integrity, particularly in SCADA environments [57]. Finally, Li, Sun, and Sun (2023) introduced a privacy-preserving intrusion detection system using federated deep learning that combines LSTM and GRU models. Blockchain ensures secure and private data transfer across distributed nodes, while the system maintains high accuracy and data integrity in sensitive domains like healthcare [58].

Alruwaili (2025) combine DL with blockchain-assisted infrastructure: LBCCD-GJO (GRU classifier; GJO feature selection; metaheuristic hyper-parameter tuning) on ToN-IoT, and MOBCF-ADDLM (DBN with evolutionary tuning) on BoT-IoT—both report ≈99%-level accuracy and position blockchain for decentralization/tamper-proofing rather than on-chain inference [59]. Aliyu et al. (2025) introduces a continuously learning IDS whose LSTM-based core ingests intrusion logs; self-updating neural nets are anchored per block and executed inside TEEs to harden integrity. Blockchain provides decentralized coordination/provenance; experiments on Binance Smart Chain and Ethereum Classic datasets report 98.5% accuracy with 1.5% FPR. Integration is effectively hybrid (TEE inference/off-chain; model state anchored on-chain) [60].

Cumulatively, these studies underline various and complementary methodological progresses in blockchain-supported deep learning for intrusion detection. Table 5 presents a comparative analysis of recent studies that integrate deep learning techniques with blockchain technology for intrusion detection.

Consensus algorithms are the heart of blockchain, as they guarantee that all decentralized nodes come to an agreement on the transaction logic and maintain consensus of the distributed ledger. Primitive consensus mechanisms such as Proof of Work (PoW) and Proof of Stake (PoS) have been widely used for the security of blockchain systems. Nevertheless, these approaches are not without problems, including that of high energy consumption, vulnerability to centralization, and security attacks that are possible. Implementing deep learning methods with consensus algorithms is a new innovative exploring direction for improving security, efficiency and robustness.

A 51% attack happens when a single party or group of parties takes control of more than half of a blockchain network’s mining or staking power, effectively allowing them to alter transactions, double spend coins, and degrade the network’s reliability. Ethereum Classic (ETC) suffered several 51% attacks in the past. ETC experienced a major attack in January 2019 where around $1.1M worth of double spend ETC was made. Despite deploying network upgrades, there were further attacks in August and October 2020, with estimated losses of $5.6 million and $1.68 million, respectively[61].

The content storage network is resilient against such Sybil attacks because it uses a stable-form of anonymous identifiers. Take IOTA network as an example, many attacks related to double-spending, e.g., parasite chain attack, becoming quite serious challenges of the new networks, especially for those young networks when they were still immature and were unable to defend [62].

The application and use of deep learning in the blockchain-based consensus protocol has already stimulated attention for new tactics to resolve the inefficiencies that characterize the convergence of classical PoW (Proof of Work). Zhi et al. (2025) propose the Blockchain Consensus based on Distributed Deep Learning Work (BCDDL), converting the distributed deep learning (DDL) training into a mining process. They propose a methodology that optimizes the allocation of training data according to the node's computing power, and uses the Model Aggregation Algorithm (MAA-TM) and the Dynamic Incentive Mechanism (DIM-TSCR) to maximize accuracy, security and maximize resource utilization [63]. In contrast, He et al. (2024), Proof of Privacy Preserving Machine Learning (PPPML) is proposed guarding confidential data and models at the consensus level utilizing encrypted deep learning and the hybrid approach to take the training procession. Their method is focused on confidentiality preserving while keeping model accuracy, and thus applicable to privacy-demanding blockchain applications [64].

Liu et al. (2021) propose Proof of Learning (PoLe), which swaps energy-heavy calculations for training neural networks to reach consensus; a statistical ML checker validates models and deters cheating, making the system more practical and sustainable [65]. Building on adaptive ideas, Islam et al. (2023) introduce MRL-PoS, a PoS method that uses multi-agent reinforcement learning with dynamic voting and a reward-penalty scheme to discourage malicious nodes and promote honest behavior [66]. For IoT settings, Goh et al. (2022) present TDCB-D3P, which relies on a Dueling Double Deep Q-Network with prioritized replay to choose trustworthy nodes, raise transactions per second, and tune parameters on the fly for better scalability and security [67]. In transport, Kim (2022) combines a blockchain consensus approach with LSTM-based anomaly detection for vehicle cybersecurity, showing promise against real-time attacks in a virtual testbed [68]. Badruddoja et al. (2022) split the workload: models are trained off-chain, while on-chain smart contracts handle predictions using Taylor-series approximations of activation functions, enabling accurate decentralized inference on MNIST despite blockchain limits [69]. Alruwaili (2024) introduced FGADL-DEVCA, a consensus protocol for IoT-cloud environments that integrates blockchain with a deep autoencoder for fault detection. The system utilizes a Football Game Algorithm for hyperparameter optimization and supports decentralized edge verification to ensure data integrity across distributed networks [70]. Amarnadh & Rao (2025) propose a deep-learning + blockchain pipeline for bank credit-risk evaluation: data are preprocessed and features selected via an enhanced Mountain Gazelle metaheuristic (pheromone-guided), then classified with a Multi-layer Residual coordinate-Boosted Sooty-tern Attention Network (MRBSAN) trained with focal loss; final credit decisions are written to a consortium blockchain that uses a Byzantine lightweight-fault-tolerant consensus to provide tamper-evident storage across nodes. Reported performance across three datasets is strong: Accuracy 97.2%, Precision 98.6%, Recall 98.6%, F1 98.0%. The figures show the off-chain ML pipeline with on-chain record storage and identical copies across nodes [71].

On-chain inference: gas and latency reality. A practical question that pervades on-chain inference is the cost–latency budget. On Ethereum mainnet, a simple ERC-20 transfer costs roughly 21,000 gas; a smart-contract function call invoking even a small fully-connected layer with fixed-point arithmetic can easily exceed 1–5 million gas per inference, translating to several USD per call at typical gas prices and to block-confirmation latencies in the tens of seconds. These figures rule out on-chain inference for any task with mempool-speed deadlines (DEX front-running detection, MEV mitigation) and severely constrain the model size that fits within the block gas limit. The trade-off explains why the surveyed works overwhelmingly favour a hybrid pattern: heavy inference runs off-chain (or inside a TEE or zk-circuit), and only a compact commitment — a hash, a Merkle root, or a succinct proof — is anchored on-chain. Approximation techniques such as Taylor-series linearization of activation functions make small on-chain models possible, but their accuracy still trails their off-chain counterparts. Future deployments will need to publish gas-per-inference and end-to-end latency alongside accuracy if on-chain DL is to graduate from prototype to production. Table 6 presents a comparative analysis of recent blockchain consensus mechanisms that incorporate deep learning techniques.

Privacy online is still a major concern, especially with blockchains, which are designed to be transparent by default. Decentralization can strengthen security, but it also makes it harder to keep sensitive information secret [72]. In this space, deep learning offers practical tools to help protect data and reinforce privacy within blockchain networks.

A well-known example of why privacy matters is the Facebook Cambridge Analytica scandal. In 2018, it was revealed that Cambridge Analytica had obtained data from up to 87 million Facebook users without their consent, largely through a personality-quiz app. Reports indicated that this information was used to influence voters during the 2016 U.S. presidential election and the Brexit referendum. The incident exposed the weaknesses of centralized data control and underscored the need for strong privacy safeguards.

Researchers have also explored ways to combine blockchain and deep learning to improve privacy and decentralization [73]. For instance, a 2019 study by Fadaeddini and colleagues proposed a decentralized deep-learning setup on the Stellar blockchain. In their approach, each participant trains the model locally and shares only the learned parameters (not the raw data) so collaborators can benefit from shared learning without exposing private information. The architecture leverages the native exchange of Stellar, along with custom tokens (DLC, VLM) to reward honest participation and to punish malice action - a mechanism is Know Your Customer (KYC). The approach escapes reliance on a central authority by employing a distributed ledger technology for organizing the training cooperation and rewards [74].

Mahmood et al. (2022) introduced secure protocols namely ZKPs, differential privacy and adversarial training in their blockchain-based federated learning system. Their approach is developed on the Ethereum blockchain and adopts a CNN model for training based on the Fashion-MNIST dataset. It combines local model updates with secure aggregation and encrypted communication to defend against adversary attacks including poisoning, inference and backdoor. There is also a transparent incentive mechanism to encourage the honest behavior of the node [75].

Instead of data integrity issue of decentralized FDL, Zhu and Li (2021) improved the data privacy of decentralized FDL by presenting a privacy-preserving framework (PDFDL). They used secure multiparty computation based on a variant of the Paillier encryption for aggregating encrypted gradients without performing decryption. Running on ethereum, the smart contract orchestrates the training rounds and rewards users according to their contribution. Their scheme deals securely with the model updates and achieves global model privacy through threshold decryption, dealing with both data leakage risk and malicious participant risk [76].

Awotunde et al. (2023) proposed a hybrid model integrating Kernel Principal Component Analysis (KPCA) with Convolutional Neural Networks (CNNs) and blockchain for smart city security. The method includes preprocessing, feature reduction, and classification stages, using ToN-IoT and BoT-IoT datasets for evaluation, achieving high intrusion detection accuracy [77]. Raju et al. (2023) developed a secure IoT-healthcare system using Optimal Key-based Hybrid Elliptic Curve Cryptography with Fully Homomorphic Encryption (OK-HECCFHE), combined with a deep learning prediction model based on Gated Recurrent Units (GRUs). Blockchain ensures secure data storage, while hybrid optimization algorithms improve encryption and prediction performance [78]. BlockDLO, introduced by Kokila and Reddy (2024), offers a five-phase IoT security architecture combining chaotic authentication, page rank-based clustering, smart contracts, and CNN-based anomaly detection. Blockchain ensures data integrity, while deep learning enhances intrusion detection in edge networks [79].

In digital governance, Malik et al. (2023) proposed a blockchain-based secure data exchange platform using bonobo optimization, a lightweight Feistel structure for encryption, and a deep reinforcement learning model for anomaly detection. The system was tested on BoT-IoT and ToN-IoT datasets to improve security and interoperability in governance systems [80]. Li et al. (2024) presented a privacy-preserving blockchain transaction framework using probabilistic encryption, zero-knowledge proofs, and Graph Neural Networks (GNNs). The model supports both privacy and regulatory oversight without compromising user identity [81]. Ghani et al. (2024) addressed biometric privacy by integrating Generative Adversarial Networks (GANs) and deep learning within a blockchain framework for facial recognition. This approach enhances data anonymity and security in decentralized environments [82]. Finally, Zhou et al. (2022) proposed a blockchain-based data-sharing system for brain-computer interface (BCI) applications using synthetic EEG data generation via GANs and transfer learning. The system enables privacy-aware storage and analysis sharing via Ethereum-based smart contracts [83].

Bhardwaj and Sumangali (2025) introduces PPFBXAIO, integrating FL (Flower-style orchestration) with a permissioned blockchain (SHA-256-backed logging + access control smart contracts), XAI (SHAP at the client), and optimization (Lévy Grasshopper Optimization Algorithm) for feature selection and FL hyper-parameter tuning. Uses Entropy Deep Belief Network (EDBN) as the classifier. Evaluated on Breast Cancer Wisconsin and UCI Heart; reports ~95–97% class metrics (precision/recall/F1 around mid-90s), plus latency ↓ by ~81 ms and throughput ↑ by ~109 TPS vs FedAvg/FL-MPC/FL-RAEC/PEFL. Bezanjani et al. (2025) proposes a three-phase framework: (1) reputation-based trust estimation for IoT devices with off-chain storage; (2) a lightweight PoW blockchain for immutability and secure messaging; (3) a lightweight LSTM for anomaly detection/classification in real time. Reported simulation shows +2% in precision/accuracy/recall, +5% attack-detection rate, and −3% false-alarm rate vs. baselines. The design targets scalability and low latency for healthcare IoT [84]. Table 7 presents a comparative analysis of recent studies that integrate deep learning with blockchain technologies for data privacy.

Although inherently so, as decentralized and immutable structures, blockchain networks are not immune to malware attacks. Adversaries are constantly finding new and advanced ways of attacking weaknesses in these networks resulting in huge financial losses and establishing doubts in blockchain system itself. Deep learning, a sub-field of machine learning, has become a powerful technology in identifying, and preventing those threats. This section focuses on the use of deep learning solutions for malware detection in blockchain networks, validating them on interesting case studies coming from real life.

On the heels of that revelation, cybersecurity researchers discovered an attack using more than 287 malicious packages published in the Node Package Manager (NPM) repository. In the attack, the malicious party used typo squatting methods — giving packages names similar to those of popular libraries — to trick developers into downloading them. Upon installation, these packages would run scripts that communicated with Ethereum smart contracts to obtain C2 server addresses, and then download and execute malware on the victim's machine [86].

Due to the explosion in cyber attacks via malware in the context of Internet of Things (IoT) in healthcare and governance, there is an increasing interest of the security researchers to propose blockchain based deep learning techniques [87]. Alotaibi (2021) presented a new BCMPB-RIDMPL (Biserial Miyaguchi–Preneel Blockchain-Based Ruzicka-Indexed Deep Perceptive Learning) for Internet of Medical Things (IoMT) malware detection. The model is based on multilayer perceptron and feature selection is performed by applying point biserial correlation as a first step, then the selected features are cryptographic hashed by Miyaguchi–Preneel blockchain in the second step. The hash integrity is checked for during classification with Ruzicka indices, in order to increase accuracy and speed of detection [88].

In related work, Nalinipriya et al. (2021) proposed a Vision-based Deep Stacked Autoencoder (DSAE) for detecting ransomware in blockchain networks. Their approach first extracts statistical features from opcode sequences (n-grams and TF-IDF) and then the extracted features are transformed using Box-Cox and the features are fused. Classification is conducted by a deep stacked autoencoder trained by a hybrid WMFO method on the fine-tuning of model weights, and demonstrates good performance for ransomware detection [89]. In addition to these attempts, Pawar et al. (2024) proposed a blockchain-based deep learning structure that is custom made for digital governance within the scope of IoT. They combine Bonobo optimization for SCDA and two-layered XGBoost model with a greedy search algorithm and bat optimization for parameter adjustment. This hybrid framework is developed to detect malware over distributed smart spaces, and interoperability and data security are also being considered [90].

Pastor et al. (2020) proposed a comprehensive system for detecting encrypted crypto mining malware traffic using machine and deep learning techniques without relying on payload inspection or sensitive metadata. Their methodology involved building a realistic experimental setup with encrypted Monero (XMR) mining traffic and designing two feature sets (Tstat and NetFlow), with Tstat-derived features proving significantly more informative. They evaluated classifiers such as Random Forests, fully connected neural networks, and logistic regression, highlighting the superior performance of complex models even with encrypted traffic [91]. In the domain of Android malware detection, Şafak et al. (2025) introduced BlockDroid, a lightweight convolutional neural network (CNN) ensemble model that processes DEX files converted into grayscale images. By combining EfficientNetB0, MobileNetV2, and a custom CNN through stacking, the system achieved 97.38% accuracy. Uniquely, it incorporates blockchain to securely store prediction results, preventing re-analysis and ensuring data immutability [92]. Finally, Denysiuk et al. (2023) also explored a blockchain-enhanced malware detection system but focused on using a deep learning model validated through a Proof-of-Action consensus mechanism. Their method enables parallel malware analysis across nodes, increasing detection robustness and reaching an accuracy of up to 99.33% [93]. Nannan et al. (2025) Andro-BCFL proposes a Federated Learning + blockchain framework so devices train locally and synchronize updates via a ledger/smart contracts, improving timeliness and privacy while avoiding raw data sharing [94]. Table 8 presents a comparative analysis of recent studies that integrate deep learning with blockchain technologies for malware detection.

Most papers report top-line scores (like F1 or AUC) on easy, static datasets things like transaction graphs, smart-contract code, or IoT logs using random splits. That makes models look more general than they really are and hides the real issue: data changes over time in the wild (DeFi markets, mempool activity, IoT botnets). When you evaluate on real timelines and incidents, the difference between in-distribution and out-of-distribution performance shows up fast. Models that seem tied on random splits start to pull apart under time-ordered tests. On top of that, class imbalance and messy labels are everywhere: blacklists, heuristics, and weak supervision create shaky “ground truth” and quietly hurt recall at practical alert limits. Few papers share PR-AUC, calibration, or operating points tied to business needs; even fewer track latency or costs (like gas fees for on-chain checks).

Model choice also fits the data unevenly. GNNs are strong on relational fraud and contract-interaction graphs, while Transformers shine on time-based mempool patterns and code-like data (opcode sequences, logs). But cross-modal signals are rarely combined: DeFi fraud models often ignore code meaning; bytecode models rarely add transaction context; IoT IDS models skip blockchain telemetry even when a ledger is used for attestation. Robustness checks are shallow, too: simple evasion (small feature tweaks or bytecode padding), poisoning of graphs or crowd labels, and backdoors in pretrained embeddings are rarely stress-tested. Finally, deployment details are fuzzy. Teams don’t clearly document end-to-end latency (from mempool event to action), model update governance, human-in-the-loop review, or rollback for false positives. Reproducibility suffers from missing code, seeds, and fixed, time-aware splits. The real-world cases in the manuscript highlight these gaps and argue for moving beyond static benchmarks to evaluations that account for cost and latency.

Future work should focus on evaluations that mirror how these systems actually operate. In DeFi fraud detection, mempool analytics, smart-contract analysis, and IoT malware detection, time-ordered or rolling-window splits should replace random splits so we measure performance on evolving data. Building versioned, incident-anchored datasets linking transactions, contracts, block ranges, and logs to publicly documented attacks and responses will let researchers replay real crises and test resilience to new tactics. Results should go beyond accuracy to routinely include PR-AUC, calibration error, precision/recall at fixed alert rates, end-to-end decision latency, and a clear accounting of costs like on-chain gas, rollup TPS impact, and edge-device energy.

While within-domain multimodal fusion is already well established in the surveyed literature, these efforts remain confined to code-level or transaction-level modalities in isolation. A practical approach is late fusion or cross-attention between: (i) GNNs over wallet/contract interaction graphs; (ii) code-aware encoders over bytecode/AST/CFG to capture semantics and resist simple obfuscations; and (iii) temporal modules for mempool/DEX flow sequences. Self-supervised pretraining on large unlabeled ledgers and logs can reduce labeling needs and improve transfer to new protocols and attack families, while lightweight adapters can quickly specialize the backbone to emerging contexts.

Deployed systems must be shift-aware and continuously adaptive. Embedding-space drift detectors and change-point tests on alert streams can trigger online fine-tuning or safe fallbacks to preserve precision when adversaries pivot. Parameter-efficient updates (e.g., adapters, LoRA-style layers) and few-shot prototype mechanisms can absorb new exploit patterns with minimal downtime and compute. These updates should be guided by explicit service-level objectives, milliseconds for mempool gating versus minutes for post-trade forensics, and protected with guardrails to prevent catastrophic forgetting.

The community should also standardize security evaluations for ML pipelines. Shared red-team suites ought to test constrained evasion (feature edits that remain economically plausible), semantics-preserving bytecode transformations, and localized graph poisoning. Dataset lineage must be auditable through hashed snapshots, labeled-source provenance, and release notes that record merges and deprecations. Backdoor screening and robust-training baselines such as adversarial augmentation, consistency regularization, and confidence calibration, should be considered minimum requirements for production claims.

Deployment patterns should be hybrid by design. Heavy inference can run off-chain or at the edge, with on-chain commitments, succinct proofs, or TEE attestations providing auditability without excessive gas costs. Serving stacks should separate ultra-low-latency filters on the mempool path from slower, high-confidence analytics used for escalation and forensic review. Clear governance covering model-update approvals, incident playbooks, and reversible mitigation tools (pause/resume guards, quarantine lists) is essential to turn model scores into accountable actions.

Meaningful adoption will also depend on privacy-preserving collaboration. Federated learning can let exchanges, wallets, and IoT operators share signals without sharing raw data. Secure aggregation and differential privacy reduce leakage, while confidential inference (using TEEs or proof-carrying computations) sustains trust when models influence on-chain policy. These techniques should be evaluated together for utility, leakage risk, and computational overhead to avoid “security theater.”

Finally, interpretability and reproducibility must be treated as deliverables, not extras. Local explanations that highlight salient edges, counterparty clusters, or opcode spans can justify decisions like blacklisting or pausing a contract, while global dashboards that track drift, failure modes, and sector-level alert distributions help operators calibrate trust. Public releases should include code, configs, fixed temporal splits, and model cards that state intended use, limits, and known failure modes. To make incident-driven research cumulative, each dataset should ship with a machine-readable event index timestamp, block heights, transaction hashes, and remediation notes so rigorous, event-aligned evaluation becomes routine.