A possibilidade de conduzir MEV com código moderno otimizado para GPU – Economia

As bolsas descentralizadas (DEXs) dependem de reservas de tokens para determinar os preços de swap, permitindo negociações sem permissão, mas também introduzindo oportunidades de MEV involuntariamente. Como os invasores podem reordenar, inserir ou remover transações em torno de negociações DEX, eles podem explorar discrepâncias temporárias de preços para extrair lucro por meio de arbitragem ou ataques sanduíche.

A pesquisa MEV é um problema de otimização: dado um mempool e um ambiente DEX, queremos avaliar milhares, às vezes milhões de pacotes de transações possíveis e escolher o mais lucrativo.

Para diagnosticar os gargalos, reproduzimos sete exemplos históricos de arbitragem MEV (veja o Apêndice) usando duas ferramentas de última geração:

• Foundry, o EVM do lado da CPU mais rápido em Rust
• Lanturn, um pesquisador MEV em TypeScrip

Ambiente:

• Intel i7
• RTX3090Ti 24G
• SSD 1T
• Ubuntu 22.04

Executamos 1.000 replays para cada ferramenta e medimos como o tempo é dividido nos três estágios principais:

1. Bifurcação do estado mainnet
2. Gerando pacotes de entrada
3. Executando contratos inteligentes

Nossas descobertas correspondem a pesquisas anteriores: a geração de entrada é trivial (<1%), mas a execução e a bifurcação de EVM dominam a latência de ponta a ponta. Gastos com fundição:

• 80,89% de seu tempo na bifurcação (27,87 ms)
• 18,82% na execução de swaps (6,49 ms)

Lanturn tem desempenho ainda pior: sua execução EVM é 17,8× mais lento e bifurcação 1,98× mais lento do que o Foundry, apesar do multi-threading.

Resumindo: a pesquisa MEV é limitada pela velocidade de execução da CPU, e as CPUs simplesmente não conseguem explorar o espaço de pesquisa com rapidez suficiente.

Para sair desse gargalo de CPU, usamos GPU:

1. Escreva o bot MEV no Solidity (por exemplo, um roteador realizando arbitragem multi-hop)
2. Compile o contrato inteligente para LLVM IR usando mau
3. Gere código PTX (montagem CUDA) usando backend LLVM
4. Execute-o nativamente em threads de GPU

Aqui está o bot Solidity que usamos como exemplo de execução. Seu manipulador de fallback analisa um formato de byte compactado que descreve as trocas, determina o tipo de DEX e chama o correto swap() função:

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.7.6;

import "./libraries/uniswapv2/UniswapV2Pair.sol";
import "./libraries/uniswapv3/UniswapV3Pair.sol";
import "./libraries/sushiswap/SushiswapPair.sol";
import "./libraries/pancakeswap/PancakeswapPair.sol";

contract MEV {
    fallback(bytes calldata data) external payable returns (bytes memory) {
        uint256 amount = abi.decode(data(:32), (uint256));
        uint32 swap_len = uint32(abi.decode(data(32:), (bytes4)));
        
        uint32() memory swap_vec = new uint32()(swap_len);
        uint32() memory token_vec = new uint32()(swap_len);
        
        uint32 calldata_size = uint32(data.length);
        uint32 swaps_buf_size = (calldata_size - 32 - 4) / 2;
        for (uint32 i = 0; i < swap_len; i++) {
            swap_vec(i) = uint32(abi.decode(data(36 + i * 4:), (bytes4)));
            uint256 token_word = abi.decode(data(36 + swaps_buf_size + 32 * (i / 8):), (uint256));
            token_vec(i) = uint32(token_word >> (256 - 32 * (i % 8 + 1)));
        }
        for (uint32 i = 0; i < swap_len; i++) {
            bool reversed = token_vec(i) > token_vec((i + 1) % swap_len);
            uint32 swap_u32 = swap_vec(i);
            uint8 dex_type = uint8(swap_u32 >> 24);
            address dex = address(swap_u32 & 0xFFFFFF);

            if (dex_type == 1) {
                    amount = UniswapV2Pair(dex).swap(reversed, amount);
            } else if (dex_type == 2) {
                    amount = UniswapV3Pair(dex).swap(reversed, amount)
            } else if (dex_type == 3) {
                    amount = SushiswapPair(dex).swap(reversed, amount);
            } else if (dex_type == 4) {
                    amount = PancakeswapPair(dex).swap(reversed, amount);
            } else if (dex_type == 5) {
                continue;
            }
        }
        return abi.encodePacked(amount);
    }
}

Uma vez compilado para PTX, este bot se torna um código GPU executável. Em vez de avaliar um pacote de cada vez, como fazem as CPUs, lançamos dezenas de milhares de threads, cada uma testando um pacote candidato diferente.

Um algoritmo genético paralelo (GA) é usado para pesquisar pacotes na GPU. Cada thread de GPU representa um indivíduo (ou seja, um pacote) em uma população. Em cada geração, o algoritmo executa:

1. Seleção – escolha os pacotes com maior lucro
2. Cruzamento – recombiná-los em novos pacotes como descendentes
3. Mutação – ajuste DEXs, tokens ou pedidos para obter novos pacotes como invariantes
4. Avaliação – execute o bot MEV com os pacotes invariantes na GPU

Este fluxo de trabalho nos permite explorar um vasto espaço de pesquisa com extrema rapidez. Múltiplas populações podem ser avaliadas simultaneamente, permitindo uma cobertura de pesquisa ampla e profunda.

Tabela: Novas oportunidades de MEV identificadas em blocos do primeiro trimestre de 2025 (ETH)

Em todos os experimentos, alcançamos de 3,3 milhões a 5,1 milhões de transações por segundo, superando o Lanturn em aproximadamente 100.000×. Com base em dados reais do primeiro trimestre de 2025, o sistema estimou oportunidades de MEV abrangendo de 2 a 14 transações, totalizando 426,43 ETH em lucro extraível.

Observe que o preço do gás depende do mercado naquele momento. Nós

O MEVISOR introduz dois tipos de sobrecarga: inicialização a frio e sobrecarga por pesquisa.

Cold Boost (uma vez)

Antes de pesquisar, a GPU deve carregar o bot PTX e inicializar a memória.
Isso custa 7,03 segundos, mas acontece apenas uma vez e é amortizado em todas as pesquisas futuras.

Sobrecarga de tempo de execução

O principal custo de tempo de execução é carregar instantâneos de estado DEX na memória da GPU.

À medida que escalamos de 64 para 540 pools DEX:

• A latência de carregamento permanece estável em aproximadamente 0,30 segundos
• O uso de memória da GPU aumenta linearmente (774 MB → 1,58 GB)

Mesmo com centenas de DEXs, o MEVISOR permanece confortavelmente abaixo dos limites de VRAM das GPUs comuns e mantém uma sobrecarga baixa e previsível.

Exemplos de motivação