Contract-Graph Fusion and Cross-Graph Matching for Smart-Contract Vulnerability Detection

1. Introduction

Smart contracts are the core element of the blockchain stack and face persistent security risks due to code-level weaknesses. Many vulnerabilities are related to Solidity features and suboptimal development practices [1]. High-impact incidents in 2023, including Lido DAO and Deus DAO with losses over $\$6.5$ million [2], and other events such as Euler Finance and CertiK [3], show that local design or implementation flaws can escalate to protocol-level failures. As decentralized finance and other critical applications are more dependent on chain execution [3], detection methods must balance accuracy, scalability and operational reliability.

Vulnerability detection has therefore become a central theme of blockchain security [4]. Traditional program analysis, including static analysis and formal verification, can provide strong guarantees for some bugs, but it is difficult to adapt to large heterogeneous code bases and rapidly changing attack surfaces. Data-driven methods reduce part of this gap. Earlier neural approaches treated code as token sequences or shallow characteristics and could not capture program structure or data dependencies [5]. Large language models improve context modeling, but are expensive and often underrepresent complex control and data flows [6]. Graph-based analysis addresses these limitations by modeling code as graphs, so that graph neural networks combine structural and semantic signals and reason over paths and dependencies. Many existing graph methods still rely on a single mode such as AST, CFG, or DFG, or operate only at the contract level, which limits the recognition of patterns that span structural views or recur across contracts. Many existing graph methods still rely on a single modality such as AST, CFG, or DFG, or operate only at the contract level, which limits recognition of patterns that span structural views or recur across contracts [5,7].

This work presents an across-graph matching contract graph method for intelligent contract vulnerability detection. Abstract syntax, control flow, and data flow are combined into a typed, directed contract graph. Nodes are enriched by contextual integrations from pre-defined encoders such as GraphCodeBERT and CodeT5+. A Graph Matching Network with cross-graph attention compares pairs of contract graphs and focuses inference on homologous subgraphs associated with vulnerabilities. The design balances broad structural coverage with discriminatory pairwise alignment, and supports interpretation at the statement level.

The study is empirical and takes into account deployment needs. First, a unified multi-graph representation combines AST, CFG, and DFG with encoded node features so that syntax, control, and data dependencies are modeled in a single space with better coverage of execution semantics. Secondly, an across-diagram alignment mechanism based on a Graph Matching Network with attention aligns related subgraphs and concentrates evidence on regions relevant to vulnerabilities, thereby supporting assertion-level clues and downstream localization. Thirdly, a deployment-oriented evaluation and calibration protocol is employed, with thresholds set on validation, multi-seed reporting, and a conservative estimate of the average normalized positive rate under low false positive budgets, calculated from standard detection statistics.

The model capacity and overhead are kept clear. The encoder uses 12 Transformer layers with hidden size of 768 and 12 attention heads. The matching network uses 100 dimensional node embeddings and four propagation layers. The evaluation is performed on SmartBugs Wild with 47,398 unique Solidity files and about 203,716 contracts. Sensitivity is summarized at the reference operating points $\{1\%,5\%,10\%\}$ to reflect strict audit budgets. The results show consistent gains over strong baselines in macro precision, recall and $F_1$ and higher sensitivity in low false positive regions. The ablation confirms complementary benefits of fusion, encoder features and cross-graph matching. The results are stable throughout the seeds. All claims are limited by the evaluated body and protocol.

The rest of the document is organized as follows. Section 2 examines the detection of vulnerability based on graphs and motivates multi-graph fusion with cross-graph alignment. Section 3 describes contract graph construction, encoder integration and matching architecture. Section 4 presents datasets, baselines, measures and results, including low false positive sensitivity and ablations. Section 5 concludes with the limitations and directions for the deployment of unified extensions.

2. Related Works

Recent studies model the program code as graphs to combine structural and semantic hints. Unique encoding (AST, CFG, or DFG only) often misses the interactions between control and data that trigger vulnerabilities. Multi-graph and heterogeneous formulations address this gap by coding syntax, control flow and data dependencies together, and report more stable detection and localization at the function and statement level [5,8,9]. In smart contracts, attention mechanisms further separate control signals from data signals and mitigate false correlations, improving trigger location through dual or heterogeneous attention [7,10]. The work on robustness and interpretation uses contextual graphic enhancement and assignment [11]. These results suggest that fusion benefits from explicit relationship separation and task-aware weighting, rather than naive concatenation.

Pre-trained code models provide contextual inserts that capture long-term semantics and lexical regularities. CodeT5+ is an example of code understanding and generation [12]. Hybrid pipelines incorporating sequence-level embedding with graph encoders show improvements in software vulnerability detection and just-in-time scenarios [5,8,13]. Graph-aware alignment and cross-graph message passing tend to overcome the heuristic stacking in ablations by selectively transmitting information through modalities and reducing graphical conflicts.

In the field of intelligent contracts, surveys synthesize the taxonomies of attacks, data sources, evaluation practices and deployment concerns, and emphasize compromises between cover, interpretability and operational costs [14,15,16,17,18]. The learner detectors customized to contracts extend coverage through transfer and multi-label learning [19]. Program analysis and measurement studies reveal risks that are rooted in contract-specific semantics and cross-contract interactions [20]. Public organizations such as SmartBugs Wild support reproducible evaluations and large-scale error analyses [21,22]. Throughout these studies, graph learning and pre-training embedding are complementary. Robust detection still requires modeling how syntax, control flow, and data flow interact at fine granularity. Our work follows this direction by combining AST, CFG and DFG under a spine with cross-graph alignment and attention, with the aim of precisely locating the triggers and presenting evidence-based reports at practical cost [14,17].

Figure 1. Contract-graph construction. (a) Source snippet (VictimBank) with transfer logic to avoid reentry. (b) Abstract syntax tree (AST), (c) data flow diagram (DFG), and (d) control flow diagram (CFG) of static analysis. (e) Fused Contract Graphic (CG), in which the statement nodes are connected by a type dependency: control (orange) and data (green). For readability, the AST leaves and syntax edges are cut and the virtual anchor nodes (functions and loops) are omitted in this rendering.

Figure 1. Contract-graph construction. (a) Source snippet (VictimBank) with transfer logic to avoid reentry. (b) Abstract syntax tree (AST), (c) data flow diagram (DFG), and (d) control flow diagram (CFG) of static analysis. (e) Fused Contract Graphic (CG), in which the statement nodes are connected by a type dependency: control (orange) and data (green). For readability, the AST leaves and syntax edges are cut and the virtual anchor nodes (functions and loops) are omitted in this rendering.

3. Proposed Approach

3.1. Overview

The proposed framework detects smart contract weaknesses by measuring the similarity between contract diagrams, as shown in Figure 2. The training stage transforms contract pairs into graphs and learns a similarity function that places vulnerable contracts close to each other, while pushing secure contracts further away. The detection stage then incorporates a target contract and assigns a score using the learned Matcher. A threshold determined during validation is applied to the similarity point. The training process includes the creation of graphics from abstract syntax, control flow, and data flow representations, and the detection process applies the learning matching model to threshold-based similarity rule.

3.2. Contract Graph Construction

The contract S contains a statement set $\mathcal{U}$ and a variable set $\mathcal{V}$. Static analysis produces an abstract syntax tree $\mathcal{T}=P_{\mathrm{ast}}\left(S\right)$, a control flow graph ${\mathcal{G}}_{\mathrm{cfg}}=(V_{\mathrm{cfg}},E_{\mathrm{cfg}})$ and a data flow graph ${\mathcal{G}}_{\mathrm{dfg}}=(V_{\mathrm{dfg}},E_{\mathrm{dfg}})$. Each statement $u\in \mathcal{U}$ aligns with a subtree ${\mathcal{T}}_u$ through a parser map $m:\mathcal{U}\to 2^{V_{\mathrm{ast}}}$. The fused, typed multigraph is

$$\mathrm{CG}\left(S\right)=(V,E,X,T),E=E_{\mathrm{ast}}\cup E_{\mathrm{cfg}}\cup E_{\mathrm{dfg}},$$

constructed by replacing each control flow node for u with ${\mathcal{T}}_u$ (redundantly pruned leaves), introducing virtual nodes $v_{\mathrm{fun}}$ and $v_{\mathrm{loop}}$ to preserve the function and cycle area, and maintaining type maps $\psi :E\to \{\mathrm{ast},\mathrm{cfg},\mathrm{dfg}\}$ and $\tau :V\to {\Sigma }_{\mathrm{node}}$. Here, $X\in {\mathbb{R}}^{\left|V\right|\times d}$ denotes the node-feature matrix (e.g., contextual code embeddings and local structural descriptors), and T collects node/edge type tags consistent with $\psi$ and $\tau$. A token alignment $\pi :V\to 2^{\{1,\dots ,L\}}$ from graph nodes to source tokens is recorded for feature pooling. Once $\mathcal{T}$, $E_{\mathrm{cfg}}$, and $E_{\mathrm{dfg}}$ are available, the construction is completed in $O\left(\right|V|+|E\left|\right)$ time. Control flow and def-use metadata come from Slither [23]; ASTs with nodeType use solc-typed-ast [24]. Algorithm 1 summarizes the extraction and fusion pipeline, specifying the inputs (source code and analyzers), the token/statement alignments, and the typed-edge assembly on the input in the final contract graph.

Algorithm 1 BuildContractGraph: extraction and fusion

Require:  Source code S, tokenizer, static analyzers Ensure:  $\mathrm{CG}\left(S\right)=(V,E,X,T)$ and alignment $\pi$  1:  $\mathcal{T}\leftarrow P_{\mathrm{ast}}\left(S\right)$; $(V_{\mathrm{cfg}},E_{\mathrm{cfg}})\leftarrow \mathrm{CFG}\left(S\right)$; $(V_{\mathrm{dfg}},E_{\mathrm{dfg}})\leftarrow \mathrm{DFG}\left(S\right)$  2:  Build $m\left(u\right)=V\left({\mathcal{T}}_u\right)$ for $u\in \mathcal{U}$; record token alignment $\pi$  3:  Replace each CFG node by ${\mathcal{T}}_u$; reconnect links; prune redundant leaves  4:  Add $v_{\mathrm{fun}},v_{\mathrm{loop}}$; connect statements within each function/loop  5:  Set $E=E_{\mathrm{ast}}\cup E_{\mathrm{cfg}}\cup E_{\mathrm{dfg}}$ with type maps $\psi ,\tau$  6:  return$\mathrm{CG}\left(S\right)=(V,E,⌀,T)$ and $\pi$                   ▹X set in Section 3.3

3.3. Pretrained Encoder and Node Features

The input sequence concatenates [CLS], code tokens, [SEP], and variable tokens (total length L). A multilayer transformer produces contex states $H^{\left(n\right)}\in {\mathbb{R}}^{L\times d}$ with multi-head attention

$$\mathrm{Attn}(Q,K,V;M)=\mathrm{softmax}\left(\frac{Q{K}^{\top }}{\sqrt{d}}+M\right)V,$$

where the mask accepts adjacent token pairs in text, connected by control flow or data flow, aligned by code-variable matches or marked as special tokens. Other entries receive $-\infty$. After encoding, node features pool $H^{\left(N\right)}$ over $\pi \left(i\right)$ and concatenate type and Skip-gram annotations,

$$x_i=\left[\mathrm{pool}\left(H^{\left(N\right)}\left[\pi \left(i\right)\right]\right);W_{\mathrm{type}}{1}_{\tau \left(i\right)};e_i^{\mathrm{sg}}\right],$$

and edge features ${\alpha }_{ij}$ include type encodings and optional Skip-gram embeddings. Pre-training follows previous work on masked language modeling [25], data flow prediction, and code flow alignment

$$\mathcal{L}={\lambda }_1{\mathcal{L}}_{\mathrm{MLM}}+{\lambda }_2{\mathcal{L}}_{\mathrm{DFG}}+{\lambda }_3{\mathcal{L}}_{\mathrm{Align}}.$$

3.4. Cross-Graph Similarity with a Contract-Graph Matcher

Given ${\mathrm{CG}}_1=(V_1,E_1,X_1)$ and ${\mathrm{CG}}_2=(V_2,E_2,X_2)$, initialize

$${\eta }_i^{\left(0\right)}={\mathrm{MLP}}_{\mathrm{node}}\left(x_i\right),e_{ij}={\mathrm{MLP}}_{\mathrm{edge}}\left({\alpha }_{ij}\right).$$

In iteration t,

$${\mu }_{j\to i}^{\left(t\right)}=f_m\left({\eta }_i^{\left(t\right)},{\eta }_j^{\left(t\right)},e_{ij}\right),(i,j)\in E_1\cup E_2,a_{ij}^{\left(t\right)}={\mathrm{softmax}}_j\left({\left({\eta }_i^{\left(t\right)}\right)}^{\top }W{\eta }_j^{\prime \left(t\right)}\right),$$

$$v_{j\to i}^{\left(t\right)}=a_{ij}^{\left(t\right)}{\eta }_j^{\prime \left(t\right)},{\eta }_i^{(t+1)}=f_u\left({\eta }_i^{\left(t\right)},\sum _j{\mu }_{j\to i}^{\left(t\right)},\sum _{j^{\prime }}{v}_{j^{\prime }\to i}^{\left(t\right)}\right).$$

Here, ${\eta }_i^{\left(t\right)}$ and ${\eta }_j^{\left(t\right)}$ denote the hidden states of nodes i and j at iteration t. Functions $f_m$ and $f_u$ handle intra-graph aggregation, and node updates, respectively. Figure 3 illustrates the cross-graph attentino mechanism. After T iterations,

$$g_1=f_a\left({\left\{{\eta }_i^{\left(T\right)}\right\}}_{i\in V_1}\right),g_2=f_a\left({\left\{{\eta }_j^{\left(T\right)}\right\}}_{j\in V_2}\right),s=cos(g_1,g_2),$$

here, $f_a$ denote the graph aggregation function,with ${\ell }_2$ normalization before $cos(·,·)$. Construction is $O\left(\right|V|+|E\left|\right)$; the cost per layer encoder is $O\left(Ld\right)$; the matcher is $O\left(T\left(\right|E_1|+|E_2\left|\right)\right)$ for intra-graph messages and $O\left(T|V_1\left|\right|V_2|\right)$ for cross-graph attention.

3.5. Training and Detection

A contrastive loss of the margin trains the matcher on pair labeled $(S_a,S_b,y)$ with similarity $s=cos(g_a,g_b)$:

$${\mathcal{L}}_{\mathrm{pair}}=y{(1-s)}^2+(1-y)max{(0,s-m)}^2,$$

where $y\in \{0,1\}$ and $m\in (0,1)$. Let $\mathcal{Z}$ be a graph of vulnerable embeddings from the training data. For a target contract graph with encapsulation g,

$$s\left(G\right)=\underset{z\in \mathcal{Z}}{max}cos(g,z),$$

and the decision is $1\left\{s\right(G)\ge \tau \}$ with a $\tau$ threshold fixed in validation. Algorithm 2 details the process from end to end, including graph construction, encoder pre-training and pooling, pair-wise optimization, assembling the reference embeddings and the maximum similarity inference rule.

Algorithm 2 TrainAndDetect: compact training and inference

Require:  Labeled contracts $\left\{(S_i,y_i)\right\}$; validation-chosen threshold $\tau$  1:  Build $\mathrm{CG}\left(S\right)$ and alignment $\pi$ via Alg. 1  2:  Pretrain encoder; pool node/edge features  3:  Train the matcher on pairs $(S_a,S_b,y)$ minimizing ${\mathcal{L}}_{\mathrm{pair}}$  4:  Form graph $\mathcal{Z}\leftarrow \{z=\mathrm{embed}(S):y=1\}$  5:  Detect: embed target G as g; compute $s\left(G\right)$; output vulnerable if $s\left(G\right)\ge \tau$, else secure

4. Empirical Evaluation

The method is evaluated on three fronts. First, the end-to-end accuracy against the Rule-based and Learning-based baselines. Secondly, the benefit of fusing AST+CFG+DFG over single views. Thirdly, the ablations of the key modules. Sensitivity is also studied under low false positive budgets.

4.1. Datasets

SmartBugs Wild [26] is used as a public corpus of Solidity contracts. It contains $\mathrm{47,398}$ unique .sol files (approximately $\mathrm{203,716}$ contracts). Labels cover Reentrancy (RE), Timestamp Dependency (TD) and Integer Overflow/Underflow (IO), plus non-vulnerable files.

4.2. Baselines and Setup

1) Static analysis and graphs. ASTs are extracted with solc-typed-ast [24]. CFG/DFG and def-use metadata come from Slither [23]. These artifacts are merged into contract-level graphs (Section 3.2) using NetworkX [27].

2) Encoder and matcher. GraphCodeBERT [25] is used (12 layers, hidden size 768, 12 heads, Adam). The contract graphs matcher uses embedded size 100, four hidden layers, learning rate ${10}^{-4}$, and test time threshold $\tau =0.8$. Training is for 85 iterations (Section 3.4).

3) Baselines. For transparency and comparability, the baselines are organized into two families under a uniform evaluation interface: Rule-based: sFuzz [28], SmartCheck [29], Osiris [30], Oyente [31], Mythril [32]; Learning-based: LineVul [33], GCN [34], TMP [35], AME [36], Peculiar [37], CBGRU [38], CGE [39]. All experiments follow the configurations specified in the original works.

4) Splits and protocol. A 60/20/20 train/validation/test split is used. The thresholds are chosen during validation and fixed during testing. Each experiment uses five random seeds; the means are reported.

5) Metrics. Precision, recall, and $F_1$ follow the standard definitions and are not repeated here. For completeness, $F_2$ and Fowlkes–Mallows (FM) are reported as deterministic functions of $(P,R)$.

4.3. End-to-End Results

Table 1 reports per class and macro $P/R/F_1$. The right block adds $F_2$ and FM calculated from $(P,R)$. On a macro-average, the proposed method reaches Recall $=89.37\%$, Precision $=91.02\%$ and $F_1$$=90.18\%$, improving over CGE by $+3.03$, $+4.40$ and $+3.71$ points. Each class $F_2$ and FM show the same trend, with the highest gains in RE.

4.4. Low-FPR Sensitivity

1) Definition. Let $\pi \in (0,1)$ denote the prevalence of positives, and let R and P denote recall (true positive rate, TPR) and precision at a fixed operating threshold. By standard confusion-matrix relations,

$$P={\displaystyle \frac{\pi R}{\pi R+(1-\pi ){\mathrm{FPR}}_{★}}}⟹{\mathrm{FPR}}_{★}={\displaystyle \frac{R\pi \left(\frac{1}{P}-1\right)}{1-\pi }}.$$

For a target false-positive budget $\alpha \in (0,1)$, the low-FPR normalized sensitivity[40] is defined as the vertically normalized partial ROC area (pAUC), i.e., the average TPR on $[0,\alpha ]$:

$${\mu }_{\mathrm{TPR}}\left(\alpha \right)={\displaystyle \frac{1}{\alpha }}{\int }_0^{\alpha }\mathrm{TPR}\left(u\right)du\in [0,1].$$

2) Attainable lower bound under ROCCH. Under the ROC convex-hull model (allowing randomized thresholds so that points on chords between ROC points are attainable), the least-favourable concave, nondecreasing ROC consistent with the origin and the observed point $({\mathrm{FPR}}_{★},R)$ is the chord from $(0,0)$ to $({\mathrm{FPR}}_{★},R)$ followed by the horizontal ray at level R. Substituting this piecewise-linear ROC into the definition of low-FPR normalized sensitivity yields the closed-form attainable lower bound

$${\mu }_{\mathrm{TPR}}^{\mathrm{lower}}\left(\alpha \right)=\left\{\begin{array}{cc}\left({\displaystyle \frac{R}{2}}\right){\displaystyle \frac{\alpha }{{\mathrm{FPR}}_{★}}},\hfill & \alpha \le {\mathrm{FPR}}_{★},\hfill \\ R\left(1-{\displaystyle \frac{{\mathrm{FPR}}_{★}}{2\alpha }}\right),\hfill & \alpha >{\mathrm{FPR}}_{★},\hfill \end{array}\right.$$

which is continuous at $\alpha ={\mathrm{FPR}}_{★}$ with value $R/2$. Reported values are ${\mu }_{\mathrm{TPR}}^{\mathrm{lower}}\left(\alpha \right)\times 100\%$.

3) Evaluation protocol. Unless otherwise stated, the prevalence is fixed at $\pi =0.05$ for calculating the false positive rate. For each method and class, ${\mathrm{FPR}}_{★}$ is determined using the relationship between $(P,R,\pi )$, and ${\mu }_{\mathrm{TPR}}^{\mathrm{lower}}\left(\alpha \right)$ is derived from the attainable lower bound definition at the budgets $\alpha \in \{0.01,0.05,0.10\}$. This procedure requires only $(P,R,\pi )$ at the reported operating point and does not assume access to unobserved ROC segments.

Figure 4 plots ${\mu }_{\mathrm{TPR}}^{\mathrm{lower}}\left(\alpha \right)$ versus the FPR budget $\alpha$. The vertical dashed lines mark $\alpha \in \{1\%,5\%,10\%\}$. For $\alpha \le 5\%$, the Proposed method attains the highest low-FPR normalized sensitivity across all classes. At $\alpha \in \{1\%,5\%,10\%\}$, the performance margin is relative to the strongest baseline,

$$\Delta \left(\alpha \right)={\mu }_{\mathrm{TPR}}^{\mathrm{Proposed}}\left(\alpha \right)-\underset{\mathrm{baseline}}{max}{\mu }_{\mathrm{TPR}}^{\mathrm{baseline}}\left(\alpha \right).$$

On average across RE, TD, and IO, the gains span 11.82–54.91 at 1% poisoning, 4.97–40.09 at 5%, and 3.95–31.96 at 10%, with improvements decreasing as the poisoning ratio grows. The curve is monotone nondecreasing in $\alpha$ and upper-bounded by R for each method and class, consistent with the attainable lower bound definition.

4.5. Visual Diagnostics

Figure 5 couples $F_1$ bars with empty recall and precise markers. The tight marker co-location near the bar tip indicates a well-calibrated threshold. The gaps reveal asymmetric errors. The proposed method is the rightmost in all classes and shows minimal gaps. CGE is close but loses recall on RE. Peculiar is precisely biased. CBGRU suppresses the recall. Rule-based tools trail.

4.6. Fusion and Ablations

The inputs and ablations of the single view are in Table 2. AST-only, CFG-only, and DFG-only are weaker than fusion. The removal of GraphCodeBERT affects RE and TD most. The removal the matcher damages all classes. Replacing the fused graph with DFG-only reduces the results. Fusion adds context. Semantics of the encoder help. The cross-graph matching focuses on evidence.

4.7. Uncertainty and Limits

Stratified bootstraps (1,000 resamples) are used for macro $F_1$ and low-FPR sensitivity, and pairs tests vs. CGE support statistical significance. The main threats include label noise, split leakage through shared libraries, and data distribution. The use of five random seeds and validation thresholds helps reduce bias, but external validity depends on future data. Overall, the results are consistent in tables and figures: multi-graph fusion, pre-trained encoder, and cross-graph matching provide complementary contributions, and the observed gains persist under limited false positive budgets.

5. Conclusion and Future Work

This work introduces a contract-graph vulnerability detection framework that combines Abstract Syntax Trees (AST), Control-Flow Graphs (CFG), and Data-Flow Graphs (DFG) into a typed, guided multigraph, couples a graphical-aware encoder with a cross-graph matcher, and applies a threshold decision rule fixed by validation. On SmartBugs Wild, the framework achieved a macro $F_1$ of 90.18% over reentry, timestamp dependency and integer overflow/underflow, surpassing strong Rule-based and Learning-based baselines. The deployment-aligned criteria, including Matthews correlation coefficient (MCC) for robustness under class imbalance, partial AUROC in low-FPR bands (pAUROC) for budgeted false positives, and calibration metrics (ECE/Brier) for probability reliability, show further improvements in discrimination and confidence alignment.

Two limitations suggest concrete next steps. First, potential temporal drift and label noise in public organizations may limit the availability of distributions; future evaluations should adopt rolling, time-sharing standards with labeled judgments and report MCC, pAUROC at low FPR, and calibration before and after adaptation. Second, a static, single-contract abstraction captures environment- and context-dependent uses; enriching the graph with inter-contract call structure and selective dynamic evidence (e.g., symbolic execution traces or fuzzing witnesses), aligning objectives to low-FPR operating points (e.g., partial AUC-based or cost-sensitive losses), and expanding graph retrieval by closest approximate neighbors with subgraph-level attribution constitute promising directions towards a more robust, interpretable, and deployable detector.