Lioba/solana_sandwich_attack_dataset

Solana Protected Order Flow Sandwich Attacks

All 28,042,725 sandwich attacks by the 8,631 persistent bots on Solana identified in the paper, between 1 July 2023 and 30 June 2026. They cover 87,963,406 victim transactions. Each sandwich carries its date, bot, pool, AMM, token mints, leg amounts and profit, and every front, back and victim transaction carries its signature, slot and position in the slot.

Heimbach, Solmaz, Öz, Ferreira Torres. No Place to Hide: An Analysis on Protected Order Flow Sandwich Attacks. arXiv:2609.28115, 2026.

The lookup site reads these files directly.

Files

Path	Contents
data_v3/part-0001.bin … data_v3/part-0151.bin	Sandwich records in chronological order. Each file is under 100 MB, and no record spans two files.
data_v3/MANIFEST.tsv	Per file: bytes and sha256.
index_v3/000.bin … index_v3/fff.bin	Lookup index: every signature to its sandwich record (see below).

Total	Count
Sandwiches	28,042,725
Front-leg transactions	28,155,377
Back-leg transactions	28,410,058
Victim transactions	87,963,406

A sandwich can have several front or back legs (split or evasive legs) and several victims. A transaction can appear in more than one sandwich, for example when two bots sandwich the same victim.

Record layout

Each .bin file is a sequence of records (integers little-endian):

u8   n_front, u8 n_back, u16 n_victims
u32  front_slot, u32 back_slot
u16  day            days since 2023-01-01 (UTC)
u8   type           0 tight, 1 within_slot_wide, 2 cross_slot_wide
u8   flags          1 profitable, 2 evasive
u8   program        0 raydium_v4, 1 pump_amm, 2 pump_amm_v2, 3 raydium_cpmm,
                    4 raydium_launchpad_cpmm, 5 raydium_clmm, 6 orca_whirlpool,
                    7 meteora_dlmm_v2, 8 obric_v2, 9 solfi
u8   reserved
32B  bot (front-leg wallet), 32B pool, 32B mint in, 32B mint out
32B  back-leg wallet        only if evasive
f64  front amount in, front amount out, back amount in, back amount out,
     bot profit             token units; profit is in the input token, before fees
64B  signatures: n_front front legs, n_back back legs, n_victims victims
then, per signature in the same order:
i16  slot - front_slot
u16  position of the transaction in its slot

Keys and signatures are raw bytes; base58-encode them to get the addresses and transaction ids explorers use.

Reading the data

import datetime, struct
import base58  # pip install base58

PROGRAMS = ["raydium_v4", "pump_amm", "pump_amm_v2", "raydium_cpmm", "raydium_launchpad_cpmm",
            "raydium_clmm", "orca_whirlpool", "meteora_dlmm_v2", "obric_v2", "solfi"]
TYPES = ["tight", "within_slot_wide", "cross_slot_wide"]
b58 = lambda b: base58.b58encode(b).decode()

def records(path):
    buf = open(path, "rb").read()
    i = 0
    while i < len(buf):
        nf, nb, nv, fs, bs, day, typ, flags, prog = struct.unpack_from("<BBHIIHBBBx", buf, i)
        i += 18
        bot, pool, mint_in, mint_out = (b58(buf[i + 32 * k: i + 32 * (k + 1)]) for k in range(4))
        i += 128
        bot_back = bot
        if flags & 2:
            bot_back = b58(buf[i: i + 32]); i += 32
        fai, fao, bai, bao, profit = struct.unpack_from("<5d", buf, i); i += 40
        n = nf + nb + nv
        sigs = [b58(buf[i + 64 * k: i + 64 * (k + 1)]) for k in range(n)]; i += 64 * n
        pos = [struct.unpack_from("<hH", buf, i + 4 * k) for k in range(n)]; i += 4 * n
        txs = [(sig, fs + off, idx) for sig, (off, idx) in zip(sigs, pos)]   # (signature, slot, position)
        yield {
            "date": datetime.date(2023, 1, 1) + datetime.timedelta(days=day),
            "type": TYPES[typ], "profitable": bool(flags & 1), "evasive": bool(flags & 2),
            "program": PROGRAMS[prog], "bot": bot, "bot_back": bot_back, "pool": pool,
            "mint_in": mint_in, "mint_out": mint_out,
            "front_in": fai, "front_out": fao, "back_in": bai, "back_out": bao, "profit": profit,
            "front": txs[:nf], "back": txs[nf:nf + nb], "victims": txs[nf + nb:],
        }

for rec in records("data_v3/part-0001.bin"):
    print(rec)
    break

Lookup index

index_v3/ lets you find a transaction without reading 15 GB. It has 4,096 shards, named by the first 12 bits of the raw signature in hex. Each shard holds sorted 16-byte entries, one per signature occurrence (144,528,841 in total):

u64  key      first 8 bytes of the 64-byte signature (big-endian)
u8   part     record file number (data_v3/part-NNNN.bin)
u8   role     0 front leg, 1 back leg, 2 victim
u16  length   record length in bytes (little-endian)
u32  offset   record start in that file (little-endian)

To look up a transaction: base58-decode its signature, fetch index_v3/<first 3 hex digits>.bin, and binary-search the first 8 bytes. For each match, read length bytes at offset of the part file, for example with an HTTP range request, and confirm the full signature appears in that record. A signature in several sandwiches has several entries.

Verifying a download

cd data_v3
tail -n +2 MANIFEST.tsv | awk '{print $3"  "$1}' | sha256sum -c