#  Effective Multi-Graph Neural Networks for Illicit Account Detection on
Cryptocurrency Transaction Networks

Zhihao Ding, Jieming Shi, Qing Li, Jiannong Cao  Zhihao Ding is with the
Department of Computing, The Hong Kong Polytechnic University E-mail:
<EMAIL_ADDRESS>Shi is with the Department of Computing,
The Hong Kong Polytechnic University. E-mail<EMAIL_ADDRESS>Qing
Li is with the Department of Computing, The Hong Kong Polytechnic University.
E-mail<EMAIL_ADDRESS>Jiannong Cao is with the Department of
Computing, The Hong Kong Polytechnic University. E-mail:
<EMAIL_ADDRESS>
###### Abstract

We study illicit account detection on transaction networks of cryptocurrencies
that are increasingly important in online financial markets. The surge of
illicit activities on cryptocurrencies has resulted in billions of losses from
normal users. Existing solutions either rely on tedious feature engineering to
get handcrafted features, or are inadequate to fully utilize the rich
semantics of cryptocurrency transaction data, and consequently, yield sub-
optimal performance. In this paper, we formulate the illicit account detection
problem as a classification task over directed multigraphs with edge
attributes, and present DIAM, a novel multi-graph neural network model to
effectively detect illicit accounts on large transaction networks. First, DIAM
includes an Edge2Seq module that automatically learns effective node
representations preserving intrinsic transaction patterns of parallel edges,
by considering both edge attributes and directed edge sequence dependencies.
Then utilizing the multigraph topology, DIAM employs a new Multigraph
Discrepancy (MGD) module with a well-designed message passing mechanism to
capture the discrepant features between normal and illicit nodes, supported by
an attention mechanism. Assembling all techniques, DIAM is trained in an end-
to-end manner. Extensive experiments, comparing against 14 existing solutions
on 4 large cryptocurrency datasets of Bitcoin and Ethereum, demonstrate that
DIAM consistently achieves the best performance to accurately detect illicit
accounts, while being efficient. For instance, on a Bitcoin dataset with 20
million nodes and 203 million edges, DIAM achieves F1 score $96.55\%$,
significantly higher than the F1 score $83.92\%$ of the best competitor.

###### Index Terms:

Multigraphs, Graph Neural Networks, Illicit Account Detection, Transaction
Networks, Cryptocurrency.

##  I Introduction

Online payment and exchange platforms are playing a growing role in financial
markets [1, 2, 3, 4, 5]. Massive online transaction data have been generated.
In general, a transaction network can be modeled as a directed multigraph that
permits multiple edges between nodes (i.e., multiple transactions between
accounts) and allows edge attributes that describe the corresponding
transactions (e.g., transaction timestamp and amount). Figure 1 shows an
example transaction network. Edge $e_{10}$ is a transaction from nodes $v_{6}$
to $v_{7}$ with transaction timestamp and transaction amount as edge
attributes (edge attributes of other edges are omitted for brevity in Figure
1). Multiple edges can exist between nodes. For instance, edges
$e_{4},e_{5},e_{6}$ between nodes $v_{3}$ and $v_{4}$ in Figure 1 represent
three transactions that have happened between $v_{3}$ and $v_{4}$. A node
(e.g., $v_{4}$) can have in and out transactions.

In recent years, one representative type of online transactions,
cryptocurrency, has become increasingly popular and important, due to the
nature of decentralization and pseudo-anonymity based on blockchain
technology. As of February 2023, Bitcoin and Ethereum are the top-2 largest
cryptocurrencies with $650 billion market capitalization in total [6]. An
Ethereum transaction is a message sent from a sender address111 Account,
address, and node are used interchangeably. to a receiver address at certain
time with certain transaction amount, forming a directed edge. Bitcoin is
slightly complicated by allowing multiple senders and receivers in a
transaction. Both of them can be modeled by the multigraph model in Figure 1
(see Section III-A).

Albeit the huge volume of cryptocurrency transactions generated by normal
users, illicit entities are also taking advantage of Bitcoin and Ethereum for
illegal activities, such as phishing scams [7, 8, 9, 10], Ponzi scheme [7,
11], ransomware [12], and money laundering [13], which put millions of normal
users at the risk of financial loss and hinder the development of blockchain
ecosystem. In fact, cryptocurrency-related illicit activities are recognized
as one of the fastest-growing cyber-crimes [12], e.g., a reported surge of
scamming revenue increasing by 82% in 2021, resulting to $7.8 billion loss
from victims [14]. Therefore, it is of great importance to develop effective
methods to identify the illicit accounts on transaction networks of
cryptocurrencies, including Bitcoin and Ethereum, which is the focus of this
paper.

However, it is a highly challenging task to accurately detect illicit
accounts, particularly on large-scale transaction networks with massive number
of transactions. Cryptocurrency accounts are anonymous, and thus, there exists
no meaningful portrait information as node features that are crucial to detect
illicit accounts. Also illicit accounts can deliberately provide meaningless
user data and transactions to hide. For instance, in Figure 1, there are 2
illicit ($v_{4}$ and $v_{5}$) and 5 benign nodes. All of them are connected by
transactions, and apparently it is non-trivial to distinguish the two classes
of nodes. Moreover, the directed multigraph with edge attributes is inherently
sophisticated as shown in Figure 1, which makes it hard to develop a
synergetic model that exploits all available feature dimensions over the
multigraph topology for effective detection.

A collection of existing solutions [12, 7, 10, 11] mainly rely on feature
engineering to extract handcrafted features by aggregating cryptocurrency
transaction information (e.g., total amount received [10, 7]). Such shallow
statistical features highly depend on domain expertise and overlook the hidden
transaction patterns expressed in the multigraph data model. There are also
studies using Graph Neural Networks (GNNs) for detection [9, 10, 13, 15, 8].
However, simple adoption of common GNNs, such as GCNs [16] and GATs [17], may
not capture the unique characteristics of illicit accounts. In particular,
traditional GNNs mainly rely on the homophily assumption that connected nodes
share similar representations [18], which, however, is not true for illicit
account detection. In Figure 1, nodes $v_{4}$ and $v_{3}$ are connected, but
they should have very different representations since $v_{4}$ is illicit while
$v_{3}$ is normal. In other words, the representations of connected nodes can
have a very large discrepancy in illicit account detection (also known as
inconsistency in [19, 20, 21]). Existing cryptocurrency studies with simple
adoption of common GCNs and GATs that are not aware of the discrepancy may
learn indistinguishable node representations. As reviewed in Section II-B,
there are also studies on general graph-based anomaly detection [22, 23].
These methods can be customized for the problem of illicit account detection,
but yield moderate performance in experiments.

In this paper, we study the problem of Detecting Illicit Accounts as a node
classification task on directed Multigraphs with edge attributes, for
transaction networks of cryptocurrencies. We present DIAM, a multi-graph
neural network method for effective illicit account detection. DIAM consists
of several well-thought-out technical designs to holistically utilize all of
directed multigraph topology, edge attributes, and parallel edge sequential
dependencies. First, DIAM has an Edge2Seq module that automatically learns
high-quality representations to preserve the intrinsic transaction patterns
represented by the directed parallel edges with attributes. Specifically,
Edge2Seq adopts Recurrent Neural Networks (RNNs) to model and capture both
edge attributes and edge sequence dependencies into node representations. Note
that Edge2Seq handles incoming and outgoing edges of a node separately since a
node can have significantly different transaction patterns when being a
sender/receiver [7]. To further utilize the multigraph topology and handle the
discrepancy issue mentioned above, we then develop an Multigraph Discrepancy
(MGD) module in DIAM. MGD is a well-designed message passing mechanism to
propagate not only node representations, but also the discrepancies between
nodes, along directed multiple edges, with the help of a dedicated attention
mechanism and learnable transformation. In other words, MGD can preserve both
similar and discrepant features, which are vital for effective illicit account
detection. DIAM stacks multiple MGD modules to consider multi-hop multigraph
topology. Finally, assembling all techniques, DIAM is trained in an end-to-end
manner, to minimize a cross-entropy loss. We evaluate DIAM against 14 existing
solutions over 4 real cryptocurrency datasets of Bitcoin and Ethereum.
Extensive experiments validate that DIAM consistently achieves the highest
accuracy on all datasets, outperforming competitors often by a significant
margin, while being efficient.

Summing up, our contributions are as follows:

  * •

We study the problem of illicit account detection on transaction networks of
cryptocurrencies, and present DIAM, an effective multi-graph neural network
over large directed multigraphs with edge attributes.

  * •

In DIAM, we develop an Edge2Seq module that automatically learns and captures
edge attributes, edge sequence dependencies, and edge directions into
expressive node representations.

  * •

We further design MGD, a multigraph discrepancy module to effectively preserve
the representation discrepancies between illicit and benign nodes over the
multi-hop multigraph topology.

  * •

The superiority of DIAM is validated via extensive experiments by comparing 14
baselines on 4 real datasets.

Figure 1: An example of a directed multigraph with edge attributes for
transaction networks. All edges (e.g., $e_{10}$) have attributes such as
transaction amount and timestamp. $v_{4}$ and $v_{5}$ are illicit, while the
others are normal. The in and out transactions of $v_{4}$ are listed.

##  II Related Work

Our work is closely related to studies on cryptocurrency illicit account
detection, and graph-based anomaly detection.

###  II-A Cryptocurrency Illicit Account Detection

As mentioned, there is a lack of meaningful portrait information as node
features for cryptocurrency illicit account detection. Early studies mostly
rely on tedious feature engineering to obtain shallow statistical features,
such as the sum, average, standard deviation of transaction amounts and time
[8, 7, 10]. These studies then mainly employ on-the-rack classifiers (e.g.,
XGBoost [24] and LightGBM [25]) over the extracted features to detect illicit
accounts [12, 7, 8]. To further exploit the graph topological characteristics
of cryptocurrency transaction networks, recent studies [9, 10] incorporate
network embedding techniques for illicit account detection. For instance,
Poursafaei et al., [10] use node2vec [26] and Ri-walk [27] to extract
structural information from different views into node embeddings, and further
leverage extracted features, for the training process of illicit account
detection. Wu et al., [9] propose trans2vec, which is a random-walk based node
embedding method, in which, the random walk transition probability is biased
by transaction amounts and time. However, these studies still partially rely
on handcrafted node features, and do not fully exploit the multigraph data
model of cryptocurrency transactions. With the success of GNNs, latest studies
start to use GNNs on cryptocurrency transaction networks, e.g., [13, 15, 8,
28]. Weber et al., [13] train an end-to-end GCN for anti-money laundering in
Bitcoin. Tam et al., [15] propose EdgeProp that augments edge attributes in
the message passing mechanism to identify illicit accounts in Ethereum. Li et
al., [28] incorporate GNNs and self-supervised learning to detect phishing
scams. Summing up, most of existing cryptocurrency illicit account detection
methods still adopt manual feature engineering for node feature initialization
[12, 11, 7, 8, 10, 13]. Moreover, existing studies did not explicitly design
techniques to fully utilize the rich semantics of directed multigraph data
model for illicit account detection [9, 10, 15]. In this work, we exploit the
directed multigraph data model, and develop dedicated techniques to
automatically learn deep intrinsic node representations that are highly
effective for illicit account detection on cryptocurrency transaction
networks.

###  II-B Graph-based Anomaly Detection

In literature, there exist anomaly detection methods on various types of
graph-based data, e.g., review graphs [15, 23, 29, 19]. Most of the recent
graph-based anomaly detection methods are under the regime of GNNs. Classic
GNNs, such as GCN [16], Sage [30], and GAT [17], rely on the assumption of
homophily [31]. That is, similar nodes tend to connect to each other, which is
not true in anomaly detection. GINE [32] and TransConv [33] attempt to
incorporate edge features in GNNs, but still follows the homophily assumption.
Abnormal nodes usually have discrepant features, compared with normal ones
[20]. Further, abnormal nodes often intentionally create connections with
normal nodes to hide in camouflage [19]. Therefore, classic GNNs may not be
able to effectively handle these issues for anomaly detection. To alleviate
the issues, CARE-GNN [19] trains a predictor to measure the similarity between
target nodes and their neighborhoods, and further leverage reinforcement
learning to find the most related neighbors for aggregation. In [34], a new
framework is proposed to use attention mechanism and generative adversarial
learning [35] to detect anomalies. Zhou et al., enhance vanilla GNNs with
subtractive aggregation to model camouflage behaviors [36]. In [37], a new
loss function that leverages global structure patterns for generating anomaly-
detectable representations is presented. Liu et al., [38] propose PC-GNN to
sample neighbors from the same class and relieve the imbalance between
abnormal and normal nodes. Ding et al., [22] leverage meta-learning, while
Wang et al., [21] use self-supervised learning in GNNs, for detection. FRAUDRE
[39] takes mean aggregation of neighborhood differences and representations,
and develops a loss function to remedy class imbalance for anomaly detection.
These methods can be customized for the illicit account detection problem. We
have a detailed discussion in Section IV-C to elaborate the technical
differences between our MGD technique and existing methods that also consider
the discrepancy issue. In experiments, we compare with existing graph-based
anomaly detection methods to evaluate the effectiveness. In summary, these
methods are designed without considering the aforementioned unique
characteristics of cryptocurrency transactions, such as lack of meaningful
node features. Moreover, they are designed either for relation graphs (e.g.,
[19, 38, 39]) or node-attributed graphs (e.g., [34, 21]). On the other hand,
we consider all aspects of the multigraph data model into DIAM for illicit
account detection.

TABLE I: Frequently used notations

Notation |  Description
---|---
$G=(V,E,\mathbf{X}_{E})$ |  A directed multigraph with node set $V$, edge set $E$, and edge attribute matrix $\mathbf{X}_{E}$.
$N_{in}(v),N_{out}(v)$ |  The multisets of node $v$’s incoming and outgoing neighbors, respectively.
$Y_{\mathcal{L}},Y_{\mathcal{U}}$ |  The sets of observed and unobserved node labels, respectively.
$X^{out}_{v},X^{in}_{v}$ |  The incoming and outgoing edge attribute sequences of node $v$, respectively.
${\mathbf{h}_{v_{in}}},{\mathbf{h}_{v_{out}}}$ |  The incoming and outgoing sequence representation of node $v$, respectively.
${\mathbf{h}_{v}}$ |  The node representation concatenating ${\mathbf{h}_{v_{in}}}$ and ${\mathbf{h}_{v_{out}}}$ of node $v$.
${\mathbf{z}^{(\ell)}_{v}}$ |  The linearly transformed node representation of node $v$ at $\ell$-th MGD.
${\mathbf{r}^{(\ell)}_{v_{in}}},{\mathbf{r}^{(\ell)}_{v_{out}}}$ |  The discrepancy-aware incoming and outgoing messages node $v$ received at $\ell$-th MGD, respectively.
$\alpha_{v,1},\alpha_{v,2},\alpha_{v,3}$, |  The attention weights of ${\mathbf{z}^{(\ell)}_{v}},{\mathbf{r}^{(\ell)}_{v_{in}}},{\mathbf{r}^{(\ell)}_{v_{out}}}$, respectively.
${\mathbf{h}^{(\ell)}_{v}}$ |  Node representation after $\ell$-th MGD of node $v$.
$T_{\max}$ |  Maximum length of edge attribute sequences.
$d$ |  The dimension of edge attributes.
$c$ |  The dimension of hidden representations.
$L$ |  The number of MGD layers.

##  III Preliminaries

We first present the data model of directed multigraph with edge attributes,
to depict real-world transaction networks, and then provide the definition of
the illicit account detection problem as a classification task on the data
model.

###  III-A Directed Multigraphs With Edge Attributes

Transactions can be treated as the interactions among accounts. Here we focus
on how to build directed multigraphs with edge attributes using transaction
data, and adopt Ethereum and Bitcoin transactions to explain. For interested
readers, see [40] for a comprehensive introduction of Bitcoin and Ethereum. A
transaction $e$ sent from accounts $v$ to $u$ can be regarded as a directed
edge from nodes $v$ to $u$ with edge attributes describing transaction
details, such as transaction amount and timestamp (e.g., edge $e_{10}$ in
Figure 1). Parallel edges may exist between $v$ and $u$, since there could be
many transactions between nodes $v$ and $u$. Ethereum transactions follow the
procedure above to model transactions into multigraphs. Bitcoin transactions
are similar but with differences. Specifically, a Bitcoin transaction can
contain multiple senders and receivers who may send or receive different
amounts of Bitcoin respectively in the transaction [41]. Given a Bitcoin
transaction, we will create a directed edge $e$ from every sender $v$ to every
receiver $u$ in the transaction, and edge attributes contain the amount sent
by $v$, the amount received by $u$, timestamp, and other related information,
e.g., transaction fee.

Given a collection of transactions, we can build the corresponding directed
multigraph with edge attributes, by following the steps above. Specifically,
let $G=(V,E,\mathbf{X}_{E})$ be a directed multigraph, consisting of (i) a
node set $V$ that contains $n$ nodes, (ii) a set of directed edges $E$ of size
$m$, each connecting two nodes in $V$, and (iii) an edge attribute matrix
$\mathbf{X}_{E}\in\mathbb{R}^{m\times d}$, each row of which is a
$d$-dimensional vector serving as the edge attributes to encode the details of
the corresponding transaction. In a multigraph $G$, nodes $v$ and $u$ can have
parallel edges with different edge attributes. Let $N_{out}(v)$ be the
multiset of node $v$’s outgoing neighbors. If a node $u$ has many transactions
received from $v$, $u$ will have multiple occurrences in $N_{out}(v)$.
Similarly, let $N_{in}(v)$ be the multiset of node $v$’s incoming neighbors.

###  III-B Problem Definition

Given a directed multigraph $G=(V,E,\mathbf{X}_{E})$ with a subset of $V$
containing labeled nodes, where each labeled node $v$ has a class label
$y_{v}\in\\{0,1\\}$, indicating $v$ is illicit ($y_{v}=1$) or benign
($y_{v}=0$), we formulate the problem of illicit account detection on directed
multigraphs with edge attributes as a classification task defined as follows.

###### Definition 1

(Illicit Account Detection on Directed Multigraphs.) Given a partially labeled
directed multigraph $G=(V,E,\mathbf{X}_{E},Y_{\mathcal{L}})$, where
$Y_{\mathcal{L}}$ is the set of the partially observed node labels, and each
node label $y_{v}\in Y_{\mathcal{L}}$ takes value either $1$ or $0$,
indicating the node to be illicit or not, the objective is to learn a binary
classifier $f$ that can accurately detect the illicit accounts in
$Y_{\mathcal{U}}$:

$f:G=(V,E,\mathbf{X}_{E},Y_{\mathcal{L}})\mapsto Y_{\mathcal{L}}\cup
Y_{\mathcal{U}},$ (1)

where $Y_{\mathcal{U}}$ is the set of unobserved node labels to be predicted
in $G$.

As mentioned, we use representative cryptocurrencies, Bitcoin and Ethereum
transactions, as instances to elaborate and evaluate our method. Bitcoin and
Ethereum are distributed public ledgers that record all transactions
anonymously accessible to the public [8, 42]. Further, in terms of labeled
data $Y_{\mathcal{L}}$, since the addresses in cryptocurrency platforms are
unique and immutable, there are websites and forums, like WalletExplorer [43]
and EtherScan [44], providing illicit label information over addresses
involving illicit activities, such as phishing and gambling. As described in
Section V-A, we crawl such information as ground-truth labels.

Table I lists the frequently used notations in the paper.

Figure 2: The DIAM framework with an input transaction network modeled as a
directed multigraph with edge attributes.

##  IV The DIAM Framework

In this section, we present our solution DIAM. We provide the overview in
Section IV-A, develop the Edge2Seq module to learn representations over
directed parallel edges with attributes in Section IV-B, design the MGD module
that considers multigraph topology and representation discrepancies in Section
IV-C, and elaborate the objective and algorithmic analysis of DIAM in Section
IV-D.

###  IV-A Solution Overview

Figure 2 presents the proposed DIAM framework. Taking as input a directed
multigraph $G$ with edge attributes, which models a transaction network, the
first module in DIAM is Edge2Seq that automatically learns expressive
representations with the consideration of both incoming and outgoing edges of
nodes. In particular, as shown in Figure 2, for a node $v$ (e.g., $v_{4}$),
Edge2Seq first builds an incoming sequence $X^{in}_{v}$ and an outgoing
sequence $X^{out}_{v}$ that consist of $v$’s incoming and outgoing edge
attributes in chronological order, respectively. Intuitively, $X^{out}_{v}$
and $X^{in}_{v}$ describe different sequential transaction patterns of node
$v$, when $v$ serves as a sender or a receiver respectively. Then Edge2Seq
employs an RNN model, specifically Gated Recurrent Units (GRUs) [45], to learn
the sequence representations of both $X^{out}_{v}$ and $X^{in}_{v}$, which are
then processed by pooling operations, to get representations
${\mathbf{h}_{v_{out}}}$ and ${\mathbf{h}_{v_{in}}}$ respectively. Then as
shown in Figure 2, ${\mathbf{h}_{v_{out}}}$ and ${\mathbf{h}_{v_{in}}}$ are
concatenated together to be the node representation ${\mathbf{h}_{v}}$ of $v$.
Intuitively, ${\mathbf{h}_{v}}$ captures both the incoming and outgoing
transaction patterns of node $v$, as well as their sequential dependencies.
The node representations ${\mathbf{h}_{v}}$ for all $v\in V$ learned by
Edge2Seq are then regarded as initial inputs fed into the proposed multigraph
discrepancy (MGD) module. DIAM stacks multiple MGD layers to further consider
multi-hop multigraph topology to learn more expressive discrepancy-aware node
representations. In an MGD, a target node $v$ receives messages from its
incoming and outgoing neighborhoods separately (e.g., $v_{4}$ as an example in
MGD of Figure 2). The incoming and outgoing messages, denoted as
${\mathbf{r}_{v_{in}}}$ and ${\mathbf{r}_{v_{out}}}$, contain both neighbor
representations and their discrepancies with the target node as shown in
Figure 2, in order to preserve distinguishable features for illicit account
detection. Then an attention mechanism is designed in MGD to integrate $v$’s
representation ${\mathbf{z}_{v}}$, incoming message ${\mathbf{r}_{v_{in}}}$,
and outgoing message ${\mathbf{r}_{v_{out}}}$ together via attentions
$\alpha_{v,1}$, $\alpha_{v,2}$, and $\alpha_{v,3}$. The last component of DIAM
is a two-layer multilayer perceptron (MLP) classifier to learn illicit
probability $p_{v}$ of node $v$. Note that DIAM in Figure 2 is an end-to-end
classification framework, meaning that all modules in DIAM are jointly trained
to minimize a binary cross-entropy loss formulated in Section IV-D.

###  IV-B Edge2Seq: Learn via Directed Parallel Edges

Obtaining high-quality node representations is crucial for the illicit account
detection task in Section III-B. However, as mentioned in Section I, the
native node features of illicit accounts are often falsified or lacking in
transaction networks, since these accounts intend to pretend themselves to be
benign and hide themselves among normal nodes, particularly on
cryptocurrencies that are decentralized and pseudo-anonymous [8]. Existing
solutions mostly resort to manual feature engineering to get statistical
features [7, 10], which requires domain expertise and is dependent on a
specific cryptocurrency.

Hence, we present Edge2Seq to automatically learn high-quality node
representations that preserve the intrinsic transaction patterns of nodes. In
a nutshell, Edge2Seq integrates (i) edge attributes (transaction information),
(ii) parallel edge sequential dependencies (transaction dependencies), and
(iii) edge directions (directional transaction flows) together in the
multigraph data model. Existing methods [30, 46] use RNNs as node
representation aggregator, which is different from Edge2Seq that works on edge
attributes and sequential dependencies among directed parallel edges on
multigraphs.

Remark that Edge2Seq handles the incoming and outgoing edges of a node
separately. In fact, the incoming and outgoing edges of a node indicate
different money flow directions, whose differences are crucial to distinguish
transaction patterns in cryptocurrency transaction networks [15]. For example,
Chen et al., [8] find that phishing accounts in Ethereum usually have fewer
incoming edges, while having more outgoing edges, compared with non-phishing
accounts. In addition, phishing accounts often receive 3 times more
cryptocurrency amount than the amount spent.

Hence, a model should be able to differentiate and capture such directional
transaction patterns. Specifically, for every node $v$ of the input multigraph
$G$, we first build an incoming (resp. outgoing) sequence that consists of its
incoming (resp. outgoing) edge attributes ordered by timestamps. We then apply
GRUs over the sequences to learn representations that preserve both edge
attributes (i.e., transaction information) and sequential dependencies among
edges (i.e., transaction behaviors). The sequence representations are then
processed as the respective node representations for subsequent training. In
the following, we explain the details of Edge2Seq that contains two parts:
sequence generation and sequence encoding.

Sequence Generation. Given a node $v$ of the input multigraph $G$, Edge2Seq
first builds two sequences for it. In particular, for all outgoing edges of
$v$, Edge2Seq sorts the outgoing edges in chronological order according to the
timestamps on edges, and gets
$E^{out}_{v}=({e}^{1}_{v},{e}^{2}_{v}...,{e}^{T}_{v})$, the sequence of $T$
sorted outgoing edges of $v$. For instance, in Figure 1, node $v_{4}$ has
outgoing edge sequence $(e_{6},e_{7},e_{8})$. Edge2Seq then extracts the
corresponding edge attributes accordingly, and builds the outgoing edge
attribute sequence of $v$,
$X^{out}_{v}=({\mathbf{x}_{e_{v}^{1}}},{\mathbf{x}_{e_{v}^{2}}},...,{\mathbf{x}_{e_{v}^{T}}})$.
Then, similarly, we also build an incoming edge attribute sequence
$X^{in}_{v}$. Obviously, sequences $X^{out}_{v}$ and $X^{in}_{v}$ of node $v$
consider both edge sequence and edge attributes, and also utilize parallel
edges between $v$ and its neighbors. Intuitively, $X^{out}_{v}$ (resp.
$X^{in}_{v}$) represents the transaction behaviors of node $v$ when $v$ serves
as a sender (resp. receiver).

Note that an account can participate in thousands of transactions, resulting
to substantially long sequences. The number of transactions of accounts
commonly follows the power-law distribution [47]. In other words, in practice,
only a few nodes have too long sequences $X^{out}_{v}$ or $X^{in}_{v}$. To
reduce the computational costs incurred when handling extremely long
sequences, we apply a common trick [48, 23], and limit the sequence length to
be at most $T_{\max}$, by keeping the most recent edges. In experiments, we
study the effect of $T_{\max}$ when varying it. In addition, for nodes without
any incoming or outgoing edges, we add self-loops to generate sequences.

Learning Representations by Sequence Encoding. After generating sequences
$X^{out}_{v}$ and $X^{in}_{v}$ for node $v$ in the input multigraph $G$, we
adopt GRUs to learn deep sequential representations. We use node $v$’s
length-$T$ outgoing sequence
$X^{out}_{v}=({\mathbf{x}_{e_{v}^{1}}},{\mathbf{x}_{e_{v}^{2}}},...,{\mathbf{x}_{e_{v}^{T}}})$
to explain the encoding process, and the encoding process of $X^{in}_{v}$
naturally follows. In particular, as shown in Eq. (2), starting from $t=1$,
until the end of the length-$T$ sequence $X^{out}_{v}$, we first apply a
linear transformation on edge attributes ${\mathbf{x}_{e_{v}^{t}}}$ to get
${\mathbf{z}^{out}_{e_{v}^{t}}}$ via a one-layer MLP with learnable parameters
$\mathbf{W}_{out}$ and $\mathbf{b}_{out}$. Then we apply GRU over
${\mathbf{z}^{out}_{e_{v}^{t}}}$ and the $(t-1)$-th hidden state
${\mathbf{h}^{t-1}_{v_{out}}}$, to get the updated
${\mathbf{h}^{t}_{v_{out}}}$ at the $t$-th position of sequence $X^{out}_{v}$:

$\begin{split}&{\mathbf{z}^{out}_{e_{v}^{t}}}=\mathbf{W}_{out}{\mathbf{x}_{e_{v}^{t}}}+\mathbf{b}_{out},\\\
&{\mathbf{h}^{t}_{v_{out}}}=\mathrm{GRU}_{out}({\mathbf{z}^{out}_{e_{v}^{t}}},{\mathbf{h}^{t-1}_{v_{out}}}),\end{split}$
(2)

where $\mathbf{W}_{out}\in\mathbb{R}^{\frac{c}{2}\times d}$ and
$\mathbf{b}_{out}\in\mathbb{R}^{\frac{c}{2}}$ are learnable parameters, and
$c$ is the representation dimension. By convention, the initial hidden state
of GRU, ${\mathbf{h}^{t=0}_{v_{out}}}$, is set to be zero.

Essentially, we use GRUs to generate a representation
${\mathbf{h}^{t}_{v_{out}}}$ for each outgoing edge at position $t\in[1,T]$ of
sequence $X^{out}_{v}$. Then we apply element-wise max-pooling [49, 30] to get
the representation ${\mathbf{h}_{v_{out}}}$ of sequence $X^{out}_{v}$,

${{\mathbf{h}_{v_{out}}}={\varphi_{pool}}_{\forall
t\in[1,T]}({\mathbf{h}^{t}_{v_{out}}}),}$ (3)

where $\varphi_{pool}(\cdot)$ is the max-pooling operation.

We apply the same procedure over the incoming sequence $X^{in}_{v}$ of node
$v$ by using another $\mathrm{GRU}_{in}$, to get the incoming sequence
representation ${\mathbf{h}_{v_{in}}}$. Finally, we obtain the representation
${\mathbf{h}_{v}}$ of node $v$ by concatenating ${\mathbf{h}_{v_{in}}}$ and
${\mathbf{h}_{v_{out}}}$ in Eq. (4). Since we obtain ${\mathbf{h}_{v_{in}}}$
and ${\mathbf{h}_{v_{out}}}$ based on the incoming and outgoing edge attribute
sequences of $v$ respectively, inherently node representation
${\mathbf{h}_{v}}$ can preserve the hidden transaction patterns of node $v$ in
both directions:

${\mathbf{h}_{v}}={\mathbf{h}_{v_{out}}}||{\mathbf{h}_{v_{in}}}.$ (4)

###  IV-C MGD: Capture Discrepancies in Multigraph Topology

Note that the node representation ${\mathbf{h}_{v}}$ of $v$ obtained by
Edge2Seq in Section IV-B only captures $v$’s individual transaction features
contained in its outgoing and incoming edges, without considering multi-hop
multigraph topology. Existing studies try to exploit graph topology and employ
GNNs for better performance [13, 15, 8]. However, as explained, conventional
GNNs heavily rely on the assumption that similar nodes tend to connect to each
other and share similar representations [30], which may be less effective on
the task of illicit account detection on multigraphs. On the other hand, an
effective model should be able to learn distinguishable representations
between normal and illicit nodes that may be closely connected either
intentionally via camouflaging behaviors or unintentionally. Simply adoption
of conventional GNNs may result to entangled representations between normal
and illicit nodes, leading to suboptimal effectiveness [19, 34].

Therefore, we present a new Multigraph Discrepancy module (MGD) to address the
issue. MGD consists of three technical designs: (i) directed discrepancy-aware
message passing with sum pooling, (ii) layer-wise learnable transformations,
and (iii) an attention mechanism over directional representations, to learn
expressive representations. MGD is discrepancy-aware, in the sense that, it
transforms and passes not only node representations but also the discrepancies
between nodes via a carefully designed message passing mechanism on
multigraphs. Furthermore, given a target node $v$, MGD considers the
discrepancies of its incoming and outgoing neighbors separately, since a node
can behave differently when being either a sender or a receiver of
transactions. As validated in our experiments, MGD is highly expressive to
learn distinguishable representations for illicit account detection, when
compared with existing counterparts.

In DIAM, let $L$ be the total number of MGD modules stacked together. The
first MGD layer takes the representations ${\mathbf{h}_{v}}$ of nodes $v\in V$
learned by Edge2Seq in Section IV-B as input. Without ambiguity, let
${\mathbf{h}_{v}}^{(\ell=0)}$ represent the input of the first MGD layer. As
shown in Eq. (5), the $\ell$-th MGD first applies a layer-wise linear
transformation with learnable weights $\mathbf{W}_{2}^{(\ell)}$ and
$\mathbf{b}_{2}^{(\ell)}$ to convert representation
${\mathbf{h}^{(\ell-1)}_{v}}$ to intermediate ${\mathbf{z}^{(\ell)}_{v}}$ via
a one-layer MLP. Then for an in-neighbor $u\in N_{in}(v)$, the message passed
from $u$ to $v$ in the $\ell$-th MGD is
$\mathbf{W}_{3}^{(\ell)}({\mathbf{z}^{(\ell)}_{u}}||({\mathbf{z}^{(\ell)}_{v}}-{\mathbf{z}^{(\ell)}_{u}}))$,
which includes both in-neighbor $u$’s representation
${\mathbf{z}^{(\ell)}_{u}}$ and its discrepancy
$({\mathbf{z}^{(\ell)}_{v}}-{\mathbf{z}^{(\ell)}_{u}})$ with target node $v$,
followed by a learnable linear transformation using $\mathbf{W}_{3}^{(\ell)}$.
Aggregating all such information for every $u\in N_{in}(v)$, we obtain
${\mathbf{r}^{(\ell)}_{v_{in}}}$ that is the discrepancy-aware incoming
message that node $v$ receives from its incoming neighborhood. Note that
$N_{in}(v)$ is a multiset of node $v$’s in-neighbors in the input multigraph
$G$, and thus, we consider parallel edges during the message passing.
Similarly, we can get the discrepancy-aware outgoing message
${\mathbf{r}^{(\ell)}_{v_{out}}}$ that $v$ receives from its outgoing
neighborhood $N_{out}(v)$, as shown in Eq. (5). Specifically,
${\mathbf{r}^{(\ell)}_{v_{out}}}$ considers every out-neighbor $u$’s
representation as well as its discrepancy with $v$. Finally, we develop an
attention mechanism to integrate the three aspects, namely $v$’s
representation ${\mathbf{z}^{(\ell)}_{v}}$, discrepancy-aware incoming and
outgoing messages ${\mathbf{r}^{(\ell)}_{v_{in}}}$ and
${\mathbf{r}^{(\ell)}_{v_{out}}}$, via attention $\alpha_{v,1}$,
$\alpha_{v,2}$, and $\alpha_{v,3}$, to get node representation
${\mathbf{h}^{(\ell)}_{v}}$ at the $\ell$-th MGD.

$\begin{split}&{\mathbf{z}^{(\ell)}_{v}}=\mathbf{W}_{2}^{(\ell)}{\mathbf{h}^{(\ell-1)}_{v}}+\mathbf{b}_{2}^{(\ell)},\\\
&{\mathbf{r}^{(\ell)}_{v_{in}}}=\sum_{\forall u\in
N_{in}(v)}\mathbf{W}_{3}^{(\ell)}({\mathbf{z}^{(\ell)}_{u}}||({\mathbf{z}^{(\ell)}_{v}}-{\mathbf{z}^{(\ell)}_{u}})),\\\
&{\mathbf{r}^{(\ell)}_{v_{out}}}=\sum_{\forall u\in
N_{out}(v)}\mathbf{W}_{3}^{(\ell)}({\mathbf{z}^{(\ell)}_{u}}||({\mathbf{z}^{(\ell)}_{v}}-{\mathbf{z}^{(\ell)}_{u}})),\\\
&{\mathbf{h}^{(\ell)}_{v}}=\alpha_{v,1}{\mathbf{z}^{(\ell)}_{v}}+\alpha_{v,2}{\mathbf{r}^{(\ell)}_{v_{in}}}+\alpha_{v,3}{\mathbf{r}^{(\ell)}_{v_{out}}},\\\
\end{split}$ (5)

where $N_{in}(v)$ and $N_{out}(v)$ are the multisets of $v$’s incoming and
outgoing neighbors respectively;
$\mathbf{W}_{2}^{(\ell)}\in\mathbb{R}^{c\times c}$,
$\mathbf{b}_{2}^{(\ell)}\in\mathbb{R}^{c}$, and
$\mathbf{W}_{3}^{(\ell)}\in\mathbb{R}^{c\times 2c}$ are learnable parameters;
$\alpha_{v,1}$, $\alpha_{v,2}$, and $\alpha_{v,3}$ are attention weights.

Attentions $\alpha_{v,1}$, $\alpha_{v,2}$, and $\alpha_{v,3}$ are calculated
by Eq. (6). A larger attention weight indicates that the corresponding aspect
is more important in the message passing process, which provides a flexible
way to aggregate the messages in Eq. (5).

$\small\begin{split}&{w}_{v,1}=\sigma({\mathbf{z}^{(\ell)}_{v}}\cdot\mathbf{q});{w}_{v,2}=\sigma({\mathbf{r}^{(\ell)}_{v_{in}}}\cdot\mathbf{q});{w}_{v,3}=\sigma({\mathbf{r}^{(\ell)}_{v_{out}}}\cdot\mathbf{q}),\\\
&\alpha_{v,k}=\mathrm{softmax}(({w}_{v,1},{w}_{v,2},{w}_{v,3}))_{k},\end{split}$
(6)

where $\sigma$ is the LeakyReLU activation function,
$\mathbf{q}\in\mathbb{R}^{c}$ is the learnable attention vector, softmax is a
normalization function, and $k=1,2,3$.

Discussion. There are several ways to handle the discrepancy issue in
literature. Here we discuss the technical differences of MGD compared with
existing work [39, 34, 19, 21, 20]. Moreover, we experimentally compare MGD
with these methods in Section V. The first way is to design new GNN layers
that are able to distinguish the discrepancies between neighboring nodes,
e.g., GDN in AEGIS [34], FRAUDRE [39], and the proposed MGD in this section.
The GNN layer (dubbed as FRA) in FRAUDRE (Eq. (2) in [39]) does not have the
latter two designs in MGD and uses mean pooling. As analyzed in [50], sum
pooling yields higher expressive power than mean pooling, particularly for
multiset neighborhoods of multigraphs in this paper. Further, the attention
mechanism and learnable layer-wise transformations in MGD enable the flexible
pass and aggregation of both incoming and outgoing discrepancy-aware messages
along parallel edges. Thus, MGD is technically different from FRAUDRE. In
[34], GDN only aggregates the representation differences between a target node
and its neighbors, while omitting neighbor representations themselves (Eq. (1)
and (2) in [34]). Contrarily, our MGD passes richer messages containing both
neighbor discrepancies and neighbor representations. In addition to designing
new GNN layers, there are also different methodologies in [19, 20, 21]. In
[19, 20], they train samplers to identify discrepant neighbors, e.g., via
reinforcement learning in [19]. DCI [21] adopts self-supervised learning and
clustering to decouple representation learning and classification. In
experiments, DIAM outperforms these existing methods for illicit account
detection on directed multigraphs with edge attributes. Moreover, in Section
V-C, we replace our MGD in DIAM by FRA [39] and GDN [34], and compare their
performance (Figure 3). The results indicate that DIAM with MGD achieves the
best performance, which further validates that MGD is effective and is
different from the existing techniques above.

Algorithm 1 DIAM

0: A directed multigraph $G$, the set of observed node labels
$Y_{\mathcal{L}}$, the set of unobserved node labels $Y_{\mathcal{U}}$, the
number of MGD layers $L$, the number of training epochs $J$, batch size $b$

0: Predicted labels of unobserved nodes in $Y_{\mathcal{U}}$

1: Initialize model parameters $\boldsymbol{\Theta}$;

2: Generate incoming and outgoing edge attribute sequences $X^{in}_{v}$ and
$X^{out}_{v}$ for nodes $v$ in $G$;

3: for $j\leftarrow 1,\cdots,J$ do

4: Randomly split target nodes $Y_{\mathcal{L}}$ into batches $\mathcal{B}$
with batch size $b$;

5: for each batch $\mathcal{B}$ do

6: Randomly sample $L$-hop neighbors of all target nodes in $\mathcal{B}$ and
add them into $\mathcal{B}$

7: Use Edge2Seq to get ${\mathbf{h}_{v}}$ for nodes $v$ in $\mathcal{B}$
(Sect. IV-B);

8: for $\ell\leftarrow 1,\cdots,L$ do

9: Get ${\mathbf{h}^{(\ell)}_{v}}$ for target nodes $v\in\mathcal{B}$ by MGD
(Sect. IV-C);

10: end for

11: Get the predicted illicit probability $p_{v}$ of target nodes $v$ in
$\mathcal{B}$ by Eq.(7)

12: Compute $\mathrm{Loss}(\boldsymbol{\Theta})$ by Eq.(8);

13: Update $\boldsymbol{\Theta}$ through back-propagation;

14: end for

15: end for

16: Return: Predict labels for unobserved $Y_{\mathcal{U}}$;

###  IV-D Objective and Algorithm

DIAM works in an end-to-end manner to detect illicit accounts on directed
multigraphs with edge attributes. At the last $L$-th MGD layer of DIAM, we get
the final representations ${\mathbf{h}^{(L)}_{v}}$ of nodes $v$. For all
labeled nodes $v$, we send their representations into a binary classifier,
which is a 2-layer MLP network with a sigmoid unit as shown in Eq. (7), to
generate the illicit probability $p_{v}$ of a node $v$. Obviously, $1-p_{v}$
is the normal probability of node $v$.

$p_{v}=\mathrm{sigmoid}(\mathrm{MLP}({\mathbf{h}^{(L)}_{v}}))$ (7)

We adopt a binary cross-entropy loss for training,

$\mathrm{Loss}(\boldsymbol{\Theta})=-\sum_{y_{v}\in
Y_{\mathcal{L}}}(y_{v}\log(p_{v})+(1-y_{v})\log(1-p_{v})),$ (8)

where $Y_{\mathcal{L}}$ is the set of groundtruth node labels, $y_{v}$ is the
label of node $v$, $\boldsymbol{\Theta}$ contains all parameters of DIAM.

We employ Adam optimizer and mini-batch training [30]. Algorithm 1 presents
the pseudo code of DIAM for training. At Line 1, we initialize model
parameters $\boldsymbol{\Theta}$ by Xavier initialization. Then at Line 2, we
generate the incoming and outgoing edge attribute sequences $X^{in}_{v}$ and
$X^{out}_{v}$ for nodes $v$ in $G$, for later usage. From Lines 3 to 15, we
use mini-batch training to train DIAM by $J$ epochs. In every epoch, at Line
4, we first split target nodes with observed labels in $Y_{\mathcal{L}}$ into
batches with batch size $b$. Then for each batch $\mathcal{B}$ (Line 5), we
first sample the $L$-hop neighbors of each target node in $\mathcal{B}$ and
add the sampled neighbors into the batch (Line 6). For each hop, following
convention [30], we randomly sample a fixed-size set of neighbors. The sample
size per hop is explained in experiments. Then at Line 7, we apply Edge2Seq to
get ${\mathbf{h}_{v}}$ for every node $v$ in $\mathcal{B}$ based on Section
IV-B, and then from Lines 8 to 10, we use $L$ stacked MGD modules in Section
IV-C to get the discrepancy-aware representations ${\mathbf{h}^{(L)}_{v}}$ of
all target node $v\in\mathcal{B}$, which are then used to calculate the
illicit probabilities $p_{v}$ (Line 11) and training loss (Line 12). Then
model parameters are updated by back propagation at Line 13. After training
the model, Algorithm 1 returns the predicted labels for unobserved nodes in
$Y_{\mathcal{U}}$ as results at Line 16.

Time Complexity. We provide the time complexity analysis of DIAM. In Edge2Seq,
the time complexities of one-layer MLP transformation, GRU, max-pooling are
$\mathcal{O}(T_{\max}|V|dc)$, $\mathcal{O}(T_{\max}|V|c^{2})$, and
$\mathcal{O}(T_{\max}|V|c)$ respectively, where $T_{\max}$ is the maximum
sequence length, $|V|$ is the number of nodes, $d$ and $c$ are the dimensions
of edge attributes and hidden representations. The overall time complexity of
Edge2Seq is $\mathcal{O}(T_{\max}|V|c(c+d))$. In MGD, the time complexity of
message passing operation on incoming and outgoing neighbors is the same as
vanilla message passing-based GNNs like Sage [30] and GAT [17], which is
$\mathcal{O}(|V|c^{2}+|E|c)$, where $|E|$ is the number of edges. The time
complexity of attention mechanism is $\mathcal{O}(|V|c)$, and the time
complexity of the two-layer MLP is $\mathcal{O}(|V|(c^{2}+2c))$. Combining the
time of all above components, we get the time complexity of DIAM as
$\mathcal{O}(T_{\max}|V|c(c+d)+|E|c)$.

TABLE II: Statistics of the datasets.

Dataset | #Nodes | #Edges | #Edge attribute | #Illicit | #Normal | Illicit:Normal
---|---|---|---|---|---|---
Ethereum-S [51] | 1,329,729 | 6,794,521 | 2 | 1,660 | 1,700 | 1:1.02
Ethereum-P [8] | 2,973,489 | 13,551,303 | 2 | 1,165 | 3,418 | 1:2.93
Bitcoin-M [52] | 2,505,841 | 14,181,316 | 5 | 46,930 | 213,026 | 1:4.54
Bitcoin-L | 20,085,231 | 203,419,765 | 8 | 362,391 | 1,271,556 | 1: 3.51

##  V Experiments

We experimentally evaluate DIAM against 14 baselines on 4 real-world
transaction networks of cryptocurrency datasets, with the aim to answer the
following 5 research questions:

  * •

RQ1: How does DIAM perform in terms of effectiveness, compared with existing
state of the art?

  * •

RQ2: How does the MGD module perform, compared with existing counterparts?

  * •

RQ3: How does the Edge2Seq module perform, compared with manual feature
engineering?

  * •

RQ4: How is the training efficiency of DIAM?

  * •

RQ5: How does DIAM perform in sensitivity analysis?

###  V-A Experimental Setup

Datasets. We evaluate on 4 real cryptocurrency datasets, including 2 Ethereum
datasets and 2 Bitcoin datasets. The statistics of the datasets are listed in
Table II. The first three datasets are from existing works, and we create the
last largest Bitcoin dataset with more than 20 million nodes and 203 million
edges. We obtain ground-truth labels into the datasets by crawling illicit and
normal account labels from reliable sources, including Etherscan [44] and
WalletExplorer [43]. Ethereum-S [51] and Ethereum-P [8] are two Ethereum
transaction networks. In both datasets, every edge has two attributes:
transaction amount and timestamp. The labeled illicit nodes are the addresses
that conduct phishing scams in these two datasets. For Ethereum-P dataset from
[8], it only contains illicit node labels. We enhance the dataset by
identifying the benign accounts (e.g., wallets and finance services) in
Ethereum-P from Etherscan [44] as normal node labels. Bitcoin-M [52] is a
medium-sized dataset containing the first 1.5 million transactions from June
2015. As explained in Section III-A, a Bitcoin transaction can involve
multiple senders and receivers. After built as a multigraph, Bitcoin-M has
about 2.5 million nodes and 14 million edges. In Bitcoin-M, an edge has 5
attributes: input amount, output amount, number of inputs, number of outputs,
and timestamp. We build the largest Bitcoin-L based on all transactions
happened from June to September 2015. Bitcoin-L has more than 20 million nodes
and 200 million edges, and each edge has 8 attributes: input amount, output
amount, number of inputs, number of outputs, fee, total value of all inputs,
total value of all outputs, and timestamp. We obtain the labeled data in
Bitcoin-M and Bitcoin-L by crawling from WalletExplorer [43]. Bitcoin
addresses belonging to gambling and mixing services are regarded as illicit
accounts, while the addresses in other types are normal accounts. Parallel
edges between nodes are common in the datasets. For instance, in Ethereum-P,
there are 5,353,834 connected node pairs, and 1,287,910 of them have more than
one edge (24.06%).

TABLE III: Overall results on all datasets (in percentage %). Bold: best.
Underline: runner-up. Relative improvements by DIAM over runner-ups in
brackets.

Method | Ethereum-S | Ethereum-P | Bitcoin-M | Bitcoin-L
---|---|---|---|---
Precision | Recall | F1 | AUC | Precision | Recall | F1 | AUC | Precision | Recall | F1 | AUC | Precision | Recall | F1 | AUC
GCN | 81.21 | 96.35 | 88.09 | 87.52 | 86.07 | 80.15 | 82.97 | 87.98 | 79.90 | 81.21 | 80.49 | 88.33 | 80.11 | 83.35 | 81.68 | 88.72
Sage | 92.92 | 89.95 | 91.39 | 91.71 | 90.49 | 91.14 | 90.81 | 94.04 | 87.17 | 83.27 | 85.16 | 90.28 | 83.16 | 84.79 | 83.92 | 89.93
GAT | 85.99 | 93.55 | 89.60 | 89.52 | 85.11 | 85.37 | 85.06 | 90.23 | 86.16 | 81.45 | 83.71 | 89.27 | 79.45 | 65.73 | 71.80 | 80.44
GATE | 66.49 | 90.66 | 76.70 | 73.62 | 88.66 | 85.41 | 86.98 | 90.95 | 71.28 | 67.06 | 68.96 | 80.52 | 67.76 | 36.86 | 47.58 | 65.87
GINE | 75.65 | 88.63 | 81.58 | 80.66 | 82.45 | 81.75 | 82.02 | 88.07 | 64.68 | 61.88 | 63.14 | 77.17 | 70.06 | 55.45 | 61.70 | 74.27
TransConv | 90.97 | 86.16 | 88.47 | 89.00 | 84.92 | 91.25 | 87.95 | 93.03 | 70.55 | 56.43 | 62.62 | 75.61 | 73.93 | 64.09 | 68.52 | 78.79
GDN | 85.55 | 83.79 | 84.63 | 85.14 | 82.42 | 84.00 | 83.19 | 89.13 | 81.56 | 74.76 | 77.99 | 85.51 | 73.68 | 45.92 | 56.57 | 70.62
CARE-GNN | 79.81 | 88.53 | 83.93 | 83.61 | 72.72 | 82.76 | 77.41 | 86.42 | 33.41 | 71.93 | 45.36 | 70.04 | 31.02 | 73.29 | 43.57 | 63.50
DCI | 71.77 | 92.18 | 80.71 | 78.86 | 75.44 | 76.95 | 76.19 | 84.47 | 82.19 | 51.47 | 63.30 | 74.50 | 81.18 | 51.77 | 62.53 | 73.91
PC-GNN | 83.34 | 81.28 | 82.26 | 82.87 | 79.18 | 89.38 | 83.96 | 90.93 | 36.89 | 73.01 | 48.87 | 72.72 | 30.04 | 82.68 | 44.07 | 64.01
FRAUDRE | 73.3 | 95.26 | 82.83 | 81.1 | 84.06 | 80.28 | 82.10 | 82.89 | 36.05 | 72.97 | 48.23 | 72.27 | 33.46 | 76.67 | 46.59 | 66.69
SigTran | 87.10 | 93.33 | 90.11 | 90.23 | 69.41 | 55.47 | 61.66 | 73.90 | 75.97 | 52.24 | 61.91 | 74.30 | 83.25 | 75.22 | 79.03 | 85.45
Pdetector | 79.27 | 91.60 | 84.99 | 84.65 | 82.37 | 83.58 | 82.97 | 88.98 | 80.43 | 58.77 | 67.92 | 77.81 | 77.08 | 52.76 | 62.64 | 74.14
EdgeProp | 81.59 | 85.36 | 83.30 | 83.38 | 89.49 | 91.78 | 90.57 | 94.15 | 73.82 | 69.21 | 71.39 | 81.88 | 72.39 | 67.09 | 69.51 | 79.84
DIAM | 97.11 | 96.68 | 96.89 | 96.97 | 94.82 | 92.95 | 93.86 | 95.66 | 92.83 | 90.39 | 91.59 | 94.43 | 97.72 | 95.40 | 96.55 | 97.39
(+4.5%) | (+0.3%) | (+6.0%) | (+5.7%) | (+4.8%) | (+1.3%) | (+3.4%) | (+1.6%) | (+6.5%) | (+8.6%) | (+7.6%) | (+4.6%) | (+17.4%) | (+12.5%) | (+15.1%) | (+8.3%)

Baselines. To comprehensively evaluate our method, we compare with 14
competitors in 3 categories.

  * •

Cryptocurrency illicit account detection methods, including Pdetector [8],
SigTran [10], and EdgeProp [15]. In particular, Pdetector leverages GCN and
autoencoder to detect Ethereum phishing scams. SigTran employs feature
engineering and node2vec [26] to learn node representations that are used to
train a logistic regression classifier for illicit account detection. EdgeProp
also uses handcrafted features to train a GNN model to identify illicit
accounts.

  * •

Graph-based anomaly detection methods, including CARE-GNN [19], DCI [21], PC-
GNN[38], GDN from AEGIS [34], and FRAUDRE [39]. As a message passing module in
AEGIS, GDN modifies GAT by using feature differences between neighboring nodes
in message passing and attention mechanism, to address the discrepancy issue
discussed in Section IV-C. Note that AEGIS itself is unsupervised, which is
different from the supervised setting in this paper, and thus it is not
compared. DCI decouples node representation learning and anomaly detection
classification, and adopts self-supervised learning for anomaly detection.
CARE-GNN is based on reinforcement learning for anomaly detection on relation
graphs. PC-GNN develops node sampler to alleviate class imbalance of fraud
detection. FRAUDRE considers neighborhood differences and also develops a loss
function to remedy class imbalance. CARE-GNN, PC-GNN, and FRAUDRE are designed
for relation graphs, and we set the number of relations as 1, to run them on
the datasets.

  * •

GNN models, including GCN [16], Sage [30], GAT [17], GATE [17], GINE [32], and
TransConv [33]. GCN is widely used to learn node representations via graph
convolutions. Sage is a general inductive framework to learn embeddings by
sampling and aggregating local neighborhood features. GAT employs self-
attention to assign importance to neighbors, and GATE extends GAT by edge
attributes. GINE also uses edge attributes for message passing. TransConv is a
graph transformer network.

Since all baselines require initial node features as input, following the way
in SigTran [10], we obtain node features, such as node degree and total
received/sent amount, by feature engineering for the baselines. Particularly,
in this way, we get 48, 48, 69, and 89 node features for datasets Ethereum-P,
Ethereum-S, Bitcoin-M, and Bitcoin-L respectively. In terms of Pdetector, we
extract the 8 specific node features suggested in its paper [8] for its
training, in order to make a fair comparison. GDN, EdgeProp, as well as the
GNN-based models, are not originally designed for the binary classification
task in this paper. Therefore, we regard them as the encoder to generate node
representations, which are then sent to a 2-layer MLP classifier with the same
objective in Section IV-D.

Implementation Details. We implement DIAM and GNN-based models using Pytorch
and Pytorch Geometric. We also use Pytorch to implement GDN and Pdetector
following the respective papers. For the other competitors, we use their
original codes provided by the respective authors. All experiments are
conducted on a Linux server with Intel Xeon Gold 6226R 2.90GHz CPU and an
Nvidia RTX 3090 GPU card.

Parameter Settings. We set node representation dimension ($c=128$), the number
of GNN layers (2), learning rate (0.001), dropout rate (0.2). In DIAM, we set
maximum sequence length $T_{max}=32$. We will study the impact of $T_{max}$ in
Section V-F. For all methods, we adopt Adam optimizer, mini-batch training
[30] with batch size 128, and, if not specified, rectified linear units (ReLU)
is used as the activation function. For all GNN models, GDN, EdgeProp, and our
method that require neighborhood sampling, given a target node, we randomly
sample its 1 and 2-hop neighbors with sample size 25 and 10 respectively. For
other settings in baselines, we follow the instructions in their respective
papers. The number of training epochs is set as 30 in Ethereum-S, Ethereum-P,
and Bitcoin-M, and set as 10 in Bitcoin-L.

Evaluation Settings. We adopt 4 evaluation metrics: Precision, Recall, F1
score, and Area Under ROC curve (AUC for short). All metrics indicate better
performance when they are higher. For each dataset, we split all labeled nodes
into training, validation, and testing sets with ratio 2:1:1. Each model is
trained on the training set. When a model achieves the highest F1 score on the
validation set, we report the evaluation results on the testing set as the
model’s performance. For each method, we train it for 5 times and report the
average value of each evaluation metric. We also study the training time in
Section V-E and the impact when varying training set size as well as the
percentage of illicit node labels in Section V-F.

###  V-B Overall Effectiveness (RQ1)

Table III reports the overall results of DIAM and all competitors on all
datasets. First, observe that DIAM consistently achieves the highest accuracy
by all evaluation metrics over all datasets, outperforming all baselines often
by a significant margin. For instance, on Ethereum-S, DIAM achieves $96.89\%$
F1 score, while the F1 of the best competitor Sage is $91.39\%$, indicating a
relative improvement of $6\%$. On Ethereum-P, DIAM has precision $94.82\%$,
outperforming the best competitor by a relative improvement of $4.8\%$. On
Bitcoin-M and Bitcoin-L, DIAM also achieves the highest accuracy for illicit
account detection. In particular, DIAM achieves 91.59% and 96.55% F1 scores on
Bitcoin-M and Bitcoin-L, 7.6% and 15.1% relatively higher than the best
baselines, respectively.

Another observation is that the performance gain of DIAM is larger on the
largest Bitcoin-L (e.g., 17.4% precision improvement over the best competitor
SigTran as shown in Table III). The reason is that DIAM with Edge2Seq is able
to take advantage of the abundant edge attributes in the multigraph of
Bitcoin-L, to automatically extract informative representations for accurate
detection of illicit accounts. Existing solutions, such as SigTran, require
manual feature engineering, and thus, could not effectively leverage the
large-scale data to preserve the intrinsic transaction patterns of accounts.
In Section V-D, we conduct an evaluation to further reveal the effectiveness
of Edge2Seq, compared with handcrafted features.

The overall results in Table III demonstrate that DIAM is able to learn
effective node representations that preserve the unique transaction patterns
of both illicit and benign nodes, validating the effectiveness of the
techniques proposed in Section IV. In particular, compared with existing
solutions that rely on feature engineering, DIAM automatically learns deep
representations via Edge2Seq in Section IV-B, which considers incoming and
outgoing edge sequence dependencies, as well as edge attributes. Further, DIAM
employs the proposed MGD layers in Section IV-C, to propagate both
representations and the discrepancies between neighbors and target nodes, via
an attention mechanism, so as to generate distinguishable representations for
illicit accounts. All these techniques together in DIAM can leverage the rich
semantics of the directed multigraph model for cryptocurrency transactions, in
order to achieve superior performance.

(a) Ethereum-S

(b) Ethereum-P

(c) Bitcoin-M

(d) Bitcoin-L

Figure 3: Compare the MGD module with existing GNN layers including Sage, GAT,
GDN, and FRA.

###  V-C Study on MGD (RQ2)

As we have discussed in Section IV-C, our MGD is different from existing work.
To further test the effectiveness of MGD in DIAM, we replace MGD with
different GNN layers, namely, Sage layer [30], GAT layer [48], GDN layer in
AEGIS [34], and FRA layer in FRAUDRE [39], and compare their performance. All
these layers are different from each other. In particular, given a target node
$v$, Sage and GAT layers do not consider discrepancies, GDN layer only passes
and aggregates the representation differences of its neighbors to it. Compared
with the FRA layer, our MGD employs sum pooling, layer-wise learnable
transformations, and an attention mechanism to flexibly pass and aggregate
both incoming and outgoing neighbor discrepancies and neighbor
representations.

We replace the MGD layers in DIAM by the existing GNN layers above, and then,
in Figure 3, we report the F1 and AUC performance of DIAM with the 5 different
GNN layers over all datasets. Observe that DIAM with MGD always achieves the
highest F1 and AUC scores on all datasets, and outperforms GDN, Sage, GAT, and
FRA layers. The results demonstrate the effectiveness of our MGD to preserve
the differentiable representations of both illicit and benign nodes with the
consideration of the discrepancies when conducting message passing over the
multigraph topology. Particularly, MGD outperforms FRA due to the proposed
learnable linear transformation and attention mechanism for both incoming and
outgoing discrepancy-aware representations in MGD. Moreover, among existing
GNN layers, GDN layer performs better than Sage, GAT, and FRA layers on
Ethereum-P in Figure 3(b), while being inferior on the other three datasets.
This indicates that it is also important to propagate and aggregate neighbor
representations to target nodes in the input multigraph, rather than only
considering node representation differences, for effective illicit account
detection.

TABLE IV:  Manual features v.s., learned representations by Edge2Seq: results
on Bitcoin-L when applying manual features or the representations
automatically learned by Edge2Seq as the input of Sage, GAT, and MGD (in
percentage %). Relative improvements of Edge2Seq over Manual are in brackets.

GNN Layer | Variant | F1 | AUC
---|---|---|---
Sage | Manual | 83.92 | 89.93
Edge2Seq | 92.80 (+10.6%) | 94.30 (+4.9%)
GAT | Manual | 71.80 | 80.44
Edge2Seq | 92.75 (+29.2%) | 94.46 (+17.4%)
MGD | Manual | 85.29 | 92.39
Edge2Seq | 96.55 (+13.2%) | 97.39 (+5.4%)

###  V-D Study on Edge2Seq (RQ3)

The Edge2Seq technique in Section IV-B automatically learns node
representations by applying GRUs over the incoming and outgoing edge sequences
of nodes. On the other hand, as explained, existing solutions mostly rely on
tedious feature engineering to get shallow statistical node features.

We demonstrate the power of Edge2Seq by interchanging it with the handcrafted
features as the input of Sage, GAT, and our MGD, and report the evaluation
results on Bitcoin-L in Table IV. Specifically, in Table IV, Manual indicates
to have the handcrafted node features introduced in Section V-A as the initial
input of node representations for training, while Edge2Seq indicates to have
the automatically learned representations by Edge2Seq for training. As shown
in Table IV, comparing against Sage (resp. GAT) with manual features, Sage
(resp. GAT) with Edge2Seq always achieves higher F1 and AUC by a significant
margin. For instance, GAT with Edge2Seq improves GAT with manual features by a
significant margin of 29.2%. The results indicate the superiority of Edge2Seq,
compared with manual feature engineering. Further, the result of our MGD with
manual features in Table IV (i.e., DIAM without Edge2Seq) also indicates that
Edge2Seq is important for the problem studied in this paper. Our method DIAM
assembling Edge2Seq and MGD together obtains the best performance, as shown in
Table IV.

TABLE V: Training time per epoch (Seconds)

Method | Ethereum-S | Ethereum-P | Bitcoin-M | Bitcoin-L
---|---|---|---|---
GCN | 0.29 | 0.65 | 14.47 | 274.20
Sage | 0.31 | 0.67 | 13.76 | 270.80
GAT | 0.75 | 1.14 | 18.25 | 307.70
GATE | 0.57 | 0.92 | 13.42 | 130.08
GINE | 0.13 | 0.39 | 8.92 | 104.23
TransConv | 0.22 | 0.66 | 14.72 | 181.82
EdgeProp | 0.17 | 0.39 | 9.73 | 105.22
GDN | 0.39 | 0.74 | 18.47 | 294.64
CARE-GNN | 0.62 | 1.80 | 29.19 | 257.45
DCI | 1.06 | 1.37 | 46.27 | 972.52
PC-GNN | 1.62 | 6.10 | 90.70 | 6525.68
FRAUDRE | 1.34 | 2.58 | 75.40 | 884.20
DIAM | 0.45 | 0.70 | 35.92 | 330.73

###  V-E Training Efficiency (RQ4)

Table V reports the average training time per epoch of DIAM and the
competitors in seconds on all datasets. First, observe that anomaly detection
methods (GDN, CARE-GNN, DCI, PC-GNN, and FRAUDRE) and our method DIAM are
generally slower than the common GNN models listed in the first group of Table
V, e.g., GCN and Sage, which is because of the unique designs for
illicit/anomaly detection in these methods. However, as reported in Section
V-B, compared with DIAM, common GNN models yield inferior accuracy since they
are not dedicated to the task of illicit account detection. Second, DIAM is
faster than most graph-based anomaly detection methods. Specifically, on
Ethereum-S and Ethereum-P, DIAM is faster than CARE-GNN, DCI, PC-GNN, and
FRAUDRE. On Bitcoin-M and Bitcoin-L, DIAM is faster than DCI, PC-GNN, and
FRAUDRE. In addition, although EdgeProp is fast, it is not as accurate as DIAM
as shown in Section V-B. The training time per epoch in Table V does not
include SigTran and Pdetector, since they are not trained in an epoch manner.
Considering together the training efficiency in Table V and the effectiveness
in Table III, we can conclude that DIAM has superior accuracy for illicit
account detection, while being reasonably efficient, on large-scale datasets.

###  V-F Sensitivity Analysis (RQ5)

(a) Ethereum-S

(b) Ethereum-P

(c) Bitcoin-M

(d) Bitcoin-L

Figure 4: Varying training set size ratio

Varying training data volume. To compare the performance of DIAM with
baselines under the situation with insufficient training data, we vary the
percentage of training data from $10\%$ to $50\%$. The F1 results on all
datasets are reported in Figure 4, where DIAM and the top-2 best baselines per
dataset are evaluated. The overall observation is that the F1 scores of all
methods decrease as the amount of training data decrease; meanwhile, DIAM
keeps achieving the highest effectiveness. On Ethereum-S in Figure 4(a), we
compare DIAM with the top-2 baselines Sage and GCN of the dataset (see Table
III). For different sizes of training data, DIAM keeps outperforming the
baselines. Similarly, we compare DIAM with Sage and EdgeProp on Ethereum-P in
Figure 4(b), compare DIAM with Sage and GAT on Bitcoin-M in Figure 4(c),
compare DIAM with Sage and GCN on Bitcoin-L in in Figure 4(d). The results in
all figures show that DIAM consistently achieves the highest F1 scores,
regardless of the volume of training data. Another observation is that the
performance of DIAM is relatively stable on the largest Bitcoin-L. Compared to
training with 50% of the data, training with 10% of the data only resulted in
a 9.6% decrease in model performance. While the two other competitors
decreased 18.3% (Sage) and 41.7% (GCN), respectively, which validates the
capability of DIAM to leverage abundant data to obtain expressive
representations for illicit account detection.

(a) F1-score

(b) Training time

Figure 5: Varying $T_{max}$ Figure 6: Varying illicit ratio on all datasets.

Varying the maximum sequence length $T_{max}$. We vary $T_{max}$ in Edge2Seq
from 2 to 128 and report the performance of DIAM in Figure 5(a), and average
training time per epoch (seconds) in Figure 5(b). The result of $T_{max}=128$
on Bitcoin-L is not reported due to out of GPU memory. In Figure 5(a), observe
that as $T_{max}$ increases, F1 score on Ethereum-S is relatively stable, F1
score on Ethereum-P and Bitcoin-L increases first and then becomes stable, and
F1 score on Bitcoin-M increases first and then decreases after $T_{max}$ is
beyond 32. As discussed in [23], the decrease in Bitcoin-M may be caused by
the noise introduced among distant elements when considering very long
sequences in sequence models. Therefore, we choose $T_{max}=32$ as default in
experiments. In terms of training time per epoch in Figure 5(b), when
$T_{max}$ increases, it takes more time for training on all datasets, which is
intuitive since there are longer sequences to be handled by Edge2Seq. The
increasing trend of training time is consistent with the time complexity
analysis in Section IV-D.

TABLE VI: Ablation Study (in percentage %) Methods | Ethereum-S | Ethereum-P | Bitcoin-M | Bitcoin-L
---|---|---|---|---
F1 | AUC | F1 | AUC | F1 | AUC | F1 | AUC
DIAM \MGD | 95.17 | 95.26 | 82.23 | 88.66 | 69.81 | 81.87 | 72.96 | 81.77
DIAM \A | 96.75 | 96.83 | 93.28 | 95.62 | 89.94 | 92.93 | 95.36 | 96.65
DIAM | 97.11 | 96.97 | 93.86 | 95.66 | 91.59 | 94.43 | 97.72 | 97.39

Ablation Study. To validate the effectiveness of every component in DIAM, we
conduct extra ablation study by evaluating DIAM without MGD in Section IV-C
(denoted as DIAM \MGD), and DIAM without the attention mechanism in Eq. (6)
(i.e., set $\alpha_{v,1}=\alpha_{v,2}=\alpha_{v,3}=1$ in Eq. (5)), denoted as
DIAM \A. Table VI presents their performance compared with the complete
version DIAM. First, observe that the performance on all four datasets
increases as we add more techniques, validating the effectiveness of the
proposed MGD and attention mechanism. Further, note that essentially DIAM \MGD
is only with Edge2Seq (i.e., only considering a node’s local transaction
features), and thus, it has inferior performance as shown in Table VI. This
observation indicates the importance of incorporating the multigraph topology
for illicit account detection. Moreover, the effectiveness of Edge2Seq
compared with manual features has been evaluated in Section V-D.

Varying illicit ratio. As shown in Table II, the number of illicit accounts is
relatively high compared with normal nodes, particularly on Ethereum-S and
Ethereum-P datasets. In order to stress test DIAM and the baselines when the
illicit node labels are scarce, we have conducted experiments to vary the
illicit ratio from 1% to 9%, by randomly sampling a subset of illicit nodes in
training on every dataset. The illicit ratio is the proportion of illicit
nodes in all labeled training nodes. Figure 6 reports the performance of all
methods on all datasets. The overall observation is that DIAM outperforms
existing methods under most illicit ratios, except the AUC at 1% on
Ethereum-S. As the illicit ratio decreases, the performance of all methods
drops on all datasets, since all methods would be under-trained with limited
labels. Further, the superiority of DIAM is more obvious on larger datasets.
The reason is that our method can better leverage the abundant data to
automatically extract meaningful features via Edge2Seq and MGD in DIAM. The
results in Figure 6 demonstrate the effectiveness of the proposed DIAM when
labels are scarce.

##  VI Conclusion

We present DIAM, an effective discrepancy-aware multigraph neural network for
the problem of illicit account detection on cryptocurrency transaction
networks. The core techniques in DIAM include Edge2Seq that leverages sequence
models to automatically learn node representations capturing both incoming and
outgoing transaction patterns, and a new Multigraph Discrepancy module MGD,
which is able to learn high-quality representations to distinguish the
discrepancies between illicit and normal nodes. We conduct extensive
experiments on 4 large cryptocurrency datasets, and compare DIAM against 14
existing solutions. The comprehensive experimental results show that DIAM
consistently achieves superior performance. Note that the multigraph model in
this paper can also describe other transaction networks besides
cryptocurrencies, such as online payment data by tech firms, e.g., AliPay and
PayPal. Hence, in the future, in addition to cryptocurrency transaction
networks, we plan to apply our method on other types of transaction networks.

## References

  * [1] Alipay, “Accessible digital payments for everyone,” 2023. [Online]. Available: https://global.alipay.com/platform/site/ihome
  * [2] Paypal, “Digital wallets, money management, and more,” 2023. [Online]. Available: https://www.paypal.com/
  * [3] Wechat, “Wechat pay,” 2023. [Online]. Available: https://pay.weixin.qq.com/index.php/public/wechatpay
  * [4] Bitcoin, “Open source p2p money,” 2023. [Online]. Available: https://bitcoin.org/en/
  * [5] Ethereum, “Welcome to ethereum,” 2023. [Online]. Available: https://ethereum.org/en/
  * [6] CoinMarketCap, “Cryptocurrency prices, charts and market capitalizations,” Jan 2023. [Online]. Available: https://coinmarketcap.com/
  * [7] W. Chen, X. Guo, Z. Chen, Z. Zheng, and Y. Lu, “Phishing scam detection on ethereum: Towards financial security for blockchain ecosystem.” in _IJCAI_ , 2020, pp. 4506–4512.
  * [8] L. Chen, J. Peng, Y. Liu, J. Li, F. Xie, and Z. Zheng, “Phishing scams detection in ethereum transaction network,” _ACM TOIT_ , vol. 21, no. 1, pp. 1–16, 2020.
  * [9] J. Wu, Q. Yuan, D. Lin, W. You, W. Chen, C. Chen, and Z. Zheng, “Who are the phishers? phishing scam detection on ethereum via network embedding,” _IEEE Transactions on Systems, Man, and Cybernetics: Systems_ , 2020.
  * [10] F. Poursafaei, R. Rabbany, and Z. Zilic, “Sigtran: Signature vectors for detecting illicit activities in blockchain transaction networks.” in _PAKDD_ , 2021, pp. 27–39.
  * [11] W. Chen, Z. Zheng, J. Cui, E. Ngai, P. Zheng, and Y. Zhou, “Detecting ponzi schemes on ethereum: Towards healthier blockchain technology,” in _WWW_ , 2018, pp. 1409–1418.
  * [12] C. G. Akcora, Y. Li, Y. R. Gel, and M. Kantarcioglu, “Bitcoinheist: Topological data analysis for ransomware prediction on the bitcoin blockchain,” in _IJCAI_ , 2020, pp. 4439–4445.
  * [13] M. Weber, G. Domeniconi, J. Chen, D. K. I. Weidele, C. Bellei, T. Robinson, and C. E. Leiserson, “Anti-money laundering in bitcoin: Experimenting with graph convolutional networks for financial forensics,” _arXiv preprint arXiv:1908.02591_ , 2019.
  * [14] Chainalysis, “Crypto crime trends for 2022: Illicit transaction activity reaches all-time high in value, all-time low in share of all cryptocurrency activity,” Jan 2022. [Online]. Available: https://blog.chainalysis.com/reports/2022-crypto-crime-report-introduction
  * [15] D. S. H. Tam, W. C. Lau, B. Hu, Q. F. Ying, D. M. Chiu, and H. Liu, “Identifying illicit accounts in large scale e-payment networks–a graph representation learning approach,” _arXiv:1906.05546_ , 2019.
  * [16] T. N. Kipf and M. Welling, “Semi-supervised classification with graph convolutional networks,” in _ICLR_ , 2017.
  * [17] P. Veličković, G. Cucurull, A. Casanova, A. Romero, P. Lio, and Y. Bengio, “Graph attention networks,” _arXiv preprint arXiv:1710.10903_ , 2017.
  * [18] J. Zhu, Y. Yan, L. Zhao, M. Heimann, L. Akoglu, and D. Koutra, “Beyond homophily in graph neural networks: Current limitations and effective designs,” _arXiv preprint arXiv:2006.11468_ , 2020.
  * [19] Y. Dou, Z. Liu, L. Sun, Y. Deng, H. Peng, and P. S. Yu, “Enhancing graph neural network-based fraud detectors against camouflaged fraudsters,” in _CIKM_ , 2020, pp. 315–324.
  * [20] Z. Liu, Y. Dou, P. S. Yu, Y. Deng, and H. Peng, “Alleviating the inconsistency problem of applying graph neural network to fraud detection,” in _SIGIR_ , 2020, pp. 1569–1572.
  * [21] Y. Wang, J. Zhang, S. Guo, H. Yin, C. Li, and H. Chen, “Decoupling representation learning and classification for gnn-based anomaly detection,” in _SIGIR_ , 2021, pp. 1239–1248.
  * [22] K. Ding, Q. Zhou, H. Tong, and H. Liu, “Few-shot network anomaly detection via cross-network meta-learning,” in _Proceedings of the Web Conference 2021_ , 2021, pp. 2448–2456.
  * [23] C. Liu, L. Sun, X. Ao, J. Feng, Q. He, and H. Yang, “Intention-aware heterogeneous graph attention networks for fraud transactions detection,” in _ACM SIGKDD_ , 2021, pp. 3280–3288.
  * [24] T. Chen and C. Guestrin, “Xgboost: A scalable tree boosting system,” in _ACM SIGKDD_ , 2016, pp. 785–794.
  * [25] G. Ke, Q. Meng, T. Finley, T. Wang, W. Chen, W. Ma, Q. Ye, and T.-Y. Liu, “Lightgbm: A highly efficient gradient boosting decision tree,” _NeurIPS_ , vol. 30, pp. 3146–3154, 2017.
  * [26] A. Grover and J. Leskovec, “node2vec: Scalable feature learning for networks,” in _ACM SIGKDD_ , 2016, pp. 855–864.
  * [27] X. Ma, G. Qin, Z. Qiu, M. Zheng, and Z. Wang, “Riwalk: Fast structural node embedding via role identification,” in _ICDM_ , 2019, pp. 478–487.
  * [28] S. Li, F. Xu, R. Wang, and S. Zhong, “Self-supervised incremental deep graph learning for ethereum phishing scam detection,” _arXiv preprint arXiv:2106.10176_ , 2021.
  * [29] J. Wang, R. Wen, C. Wu, Y. Huang, and J. Xion, “Fdgars: Fraudster detection via graph convolutional networks in online app review system,” in _Companion Proceedings of The 2019 World Wide Web Conference_ , 2019, pp. 310–316.
  * [30] W. L. Hamilton, R. Ying, and J. Leskovec, “Inductive representation learning on large graphs,” in _NeurIPS_ , 2017, pp. 1025–1035.
  * [31] M. McPherson, L. Smith-Lovin, and J. M. Cook, “Birds of a feather: Homophily in social networks,” _Annual review of sociology_ , vol. 27, no. 1, pp. 415–444, 2001.
  * [32] W. Hu, B. Liu, J. Gomes, M. Zitnik, P. Liang, V. Pande, and J. Leskovec, “Strategies for pre-training graph neural networks,” in _ICLR_ , 2019.
  * [33] Y. Shi, Z. Huang, S. Feng, H. Zhong, W. Wang, and Y. Sun, “Masked label prediction: Unified message passing model for semi-supervised classification,” _arXiv preprint arXiv:2009.03509_ , 2020.
  * [34] K. Ding, J. Li, N. Agarwal, and H. Liu, “Inductive anomaly detection on attributed networks,” in _IJCAI_ , 2021, pp. 1288–1294.
  * [35] I. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio, “Generative adversarial nets,” _NeurIPS_ , vol. 27, 2014.
  * [36] S. Zhou, Q. Tan, Z. Xu, X. Huang, and F.-l. Chung, “Subtractive aggregation for attributed network anomaly detection,” in _CIKM_ , 2021, pp. 3672–3676.
  * [37] T. Zhao, C. Deng, K. Yu, T. Jiang, D. Wang, and M. Jiang, “Error-bounded graph anomaly loss for gnns,” in _CIKM_ , 2020, pp. 1873–1882.
  * [38] Y. Liu, X. Ao, Z. Qin, J. Chi, J. Feng, H. Yang, and Q. He, “Pick and choose: A gnn-based imbalanced learning approach for fraud detection,” in _Proceedings of the Web Conference 2021_ , 2021, pp. 3168–3177.
  * [39] G. Zhang, J. Wu, J. Yang, A. Beheshti, S. Xue, C. Zhou, and Q. Z. Sheng, “Fraudre: Fraud detection dual-resistant to graph inconsistency and imbalance,” in _ICDM_ , 2021, pp. 867–876.
  * [40] J. Wu, J. Liu, Y. Zhao, and Z. Zheng, “Analysis of cryptocurrency transactions from a network perspective: An overview,” _Journal of Network and Computer Applications_ , p. 103139, 2021.
  * [41] L. Wu, Y. Hu, Y. Zhou, H. Wang, X. Luo, Z. Wang, F. Zhang, and K. Ren, “Towards understanding and demystifying bitcoin mixing services,” in _Proceedings of the Web Conference_ , 2021, pp. 33–44.
  * [42] Z. Zheng, S. Xie, H. Dai, X. Chen, and H. Wang, “An overview of blockchain technology: Architecture, consensus, and future trends,” in _IEEE international congress on big data_ , 2017, pp. 557–564.
  * [43] WalletExplorer, “Walletexplorer.com: Smart bitcoin block explorer,” 2023. [Online]. Available: https://www.walletexplorer.com/
  * [44] Etherscan, “Etherscan.io - ethereum (eth) blockchain explorer,” 2023. [Online]. Available: https://etherscan.io/labelcloud
  * [45] K. Cho, B. Van Merriënboer, D. Bahdanau, and Y. Bengio, “On the properties of neural machine translation: Encoder-decoder approaches,” _arXiv preprint arXiv:1409.1259_ , 2014.
  * [46] X. Huang, Q. Song, Y. Li, and X. Hu, “Graph recurrent networks with attributed random walks,” in _ACM SIGKDD_ , 2019, pp. 732–740.
  * [47] T. Chen, Z. Li, Y. Zhu, J. Chen, X. Luo, J. C.-S. Lui, X. Lin, and X. Zhang, “Understanding ethereum via graph analysis,” _ACM TOIT_ , vol. 20, no. 2, pp. 1–32, 2020.
  * [48] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is all you need,” in _NeurIPS_ , 2017, pp. 5998–6008.
  * [49] R. Zhang, H. Lee, and D. Radev, “Dependency sensitive convolutional neural networks for modeling sentences and documents,” _arXiv preprint arXiv:1611.02361_ , 2016.
  * [50] K. Xu, W. Hu, J. Leskovec, and S. Jegelka, “How powerful are graph neural networks?” in _ICLR_ , 2018.
  * [51] Z. Yuan, Q. Yuan, and J. Wu, “Phishing detection on ethereum via learning representation of transaction subgraphs,” in _International Conference on Blockchain and Trustworthy Systems_. Springer, 2020, pp. 178–191.
  * [52] J. Wu, J. Liu, W. Chen, H. Huang, Z. Zheng, and Y. Zhang, “Detecting mixing services via mining bitcoin transaction network with hybrid motifs,” _IEEE Transactions on Systems, Man, and Cybernetics: Systems_ , 2021.