No "escuro bosque" de Solana, quando você recebe um sinal de atualização de conta do módulo Scout, a competição já entrou nos últimos milissegundos. Se você ainda precisar enviar a transação de volta para o nó RPC para "simular" e obter uma cotação, então, quando você obtiver o resultado, a oportunidade já foi muitas vezes roubada por aqueles que completaram os cálculos localmente.
Um verdadeiro profissional Searcher nunca espera o feedback do RPC. Eles mantêm uma imagem do estado do AMM na memória local e, assim que recebem os dados binários, calculam diretamente o preço ótimo através de um modelo matemático.
Este artigo irá desmontar como construir um motor de precificação local eficiente para Raydium (CPMM) e Orca (CLMM).
1. Conceito central: Cálculo local vs. Simulação RPC
1.1 Por que escolher preços locais?
Latência extrema: simulações RPC geralmente levam de 50ms a 200ms, enquanto cálculos puramente matemáticos locais levam apenas microssegundos.
Capacidade de concorrência: o cálculo local não consome o desempenho dos nós RPC, podendo rapidamente avaliar milhares de caminhos de arbitragem.
Determinismo: através da análise de dados de conta brutos (Account Data), você pode obter um controle de estado mais fundamental do que na simulação.
2. Raydium (CPMM): A arte do produto constante
Os pools padrão da Raydium seguem a clássica fórmula x×y=k. Embora a lógica seja simples, a implementação engenheiral precisa lidar com pequenas discrepâncias de precisão e taxas.
2.1 Fórmula central de cotação
No cenário com taxa, a fórmula para calcular a versão inteira de amount_out é:
Entrada com taxa: AmountInwith_fee=AmountIn×(FeeDenominator−FeeNumerator)AmountInwith_fee=AmountIn×(FeeDenominator−FeeNumerator)
Cálculo de saída: AmountOut=AmountInwith_fee×ReserveoutReservein×FeeDenominator+AmountInwith_feeAmountOut=Reservein×FeeDenominator+AmountInwith_feeAmountInwith_fee×Reserveout
2.2 Jogo de precisão: A necessidade do U256
Na Solana, a quantidade de tokens é geralmente u64. Mas ao calcular o numerador (Numerator) da fórmula acima, multiplicar dois grandes u64 resulta imediatamente em estouro.
Solução: introduzir U256 na camada de cálculo intermediária. Embora a biblioteca oficial Rust não forneça isso diretamente, através de macros uint ou da biblioteca primitive-types, podemos garantir a precisão absoluta mesmo sob alta volatilidade (grandes entradas).
3. Orca Whirlpool (CLMM): análise precisa da liquidez concentrada
Comparado ao CPMM, o modelo de liquidez concentrada (CLMM) da Orca é muito mais complexo. Ele envolve não apenas preço, mas também Tick (intervalo de preço) e profundidade de liquidez.
3.1 A representação do preço: Q64.64 sqrtPrice
A Orca utiliza preço quadrático (sqrtPrice) e armazena em formato de ponto flutuante Q64.64.
Fórmula: Price=(sqrtPriceX64264)2Price=(264sqrtPriceX64)2
Durante a análise, precisamos lidar com inteiros super grandes de 128 bits, extraindo o preço real por meio de operações de deslocamento.
3.2 Análise rápida: Método de fatias Offset
A estrutura da conta da Orca é muito grande (inclui vários conjuntos de recompensas, parâmetros de taxa, etc.), e se usar a desserialização completa (Borsh Deserialize), a perda de desempenho é enorme.
Solução de otimização de nível industrial:
Localizar diretamente os dados binários da conta com deslocamento (Offset). Como a estrutura do pool é fixa, podemos ler as bytes-chave diretamente.
data[49..65] -> Liquidez (Liquidity)
data[65..81] -> Preço (sqrtPrice)
data[81..85] -> Tick atual
Esse método é mais de 10 vezes mais rápido do que a análise completa.
4. Design de arquitetura: camada de cotação
Para que a camada de estratégia (Strategy) não precise se preocupar com as diferenças matemáticas entre DEXs, precisamos construir um motor de cotação unificado:
fluxograma LR
RawData[Dados de conta brutos] -->|Análise| AMMState[Imagem de memória do AMM]
AMMState -->|Valor de entrada| LocalMath[Modelo matemático local]
LocalMath -->|Saída| AmountOut[Cotação estruturada]
subgraph "Camada de poder computacional local"
LocalMath
AMMState
end
Este motor irá manter em tempo real o saldo do pool Vault. Quando o Scout detecta qualquer alteração em um Vault, o motor de cotação recalcula imediatamente a cotação completa para aquele par de tokens.
5. Otimização de engenharia: velocidade nos detalhes
Cálculo de alocação zero: evite alocação de memória (Heap Allocation) durante o cálculo, utilizando tipos nativos na pilha.
Processar requisições RPC em lote: embora a precificação seja local, o saldo do cofre ainda precisa ser sincronizado. Use getMultipleAccounts para obter em lote todos os estados do Vault relevantes, reduzindo a latência de rede.
Pré-cálculo: para parâmetros fixos, como taxas, realize a análise na fase de inicialização fria, não calcule repetidamente a cada milissegundo no Hot Path.
6. Demonstração técnica: Lógica de cotação CPMM (versão Python)
Embora o ambiente de produção busque o desempenho extremo do Rust, sua lógica matemática central pode ser claramente demonstrada em Python:
# Simulação de cálculos de cotação local de alto desempenho
def calculate_local_quote(amount_in, res_in, res_out, fee_pct=0.0025):
"""
Cotação local CPMM: x * y = k
"""
# Simulação de cálculo U256 para evitar estouro
fee_numerator = int(fee_pct * 10000)
fee_denominator = 10000
# 1. Calcular o valor efetivo de entrada após deduzir taxas
amount_in_with_fee = amount_in * (fee_denominator - fee_numerator)
# 2. Calcular a saída de acordo com a fórmula
numerator = amount_in_with_fee * res_out
denominator = (res_in * fee_denominator) + amount_in_with_fee
amount_out = numerator // denominator
# 3. Calcular o impacto de preço (Price Impact)
price_impact = (amount_out / res_out) if res_out > 0 else 1
return amount_out, price_impact
# Simulação: 1 SOL troca por USDC, o pool tem 1000 SOL / 100.000 USDC
out, impact = calculate_local_quote(1 10*9, 1000 10*9, 100000 10*6)
print(f"[*] Estimativa de saída: {out / 10**6} USDC")
print(f"[*] Impacto de preço: {impact:.4%}")
7. Resumo: poder computacional é lucro
No mundo da MEV da Solana, a capacidade de precificação local determina seu nível de competição.
Jogadores iniciantes dependem de simulações RPC, apenas podendo pegar o que sobra.
Jogadores intermediários implementam CPMM localmente.
Jogadores avançados podem analisar com precisão cada Tick do CLMM e implementar arbitragem atomizada com Jito.
Próximo passo previsto
Agora que temos o "Scout" e o "Cérebro (AMM Math)", vamos entrar na parte mais emocionante: como elaborar estratégias de arbitragem entre DEXs? Diante de um cenário complexo com múltiplos caminhos e protocolos, como encontrar o caminho mais lucrativo?
Este artigo foi escrito por Levi.eth. Na Solana, cada otimização das fórmulas matemáticas pode se traduzir em ganhos reais on-chain.
