Saltar para o conteúdo principal

Documentation Index

Fetch the complete documentation index at: https://docs.raydium.io/llms.txt

Use this file to discover all available pages before exploring further.

Esta página foi traduzida automaticamente por IA. A versão em inglês é a fonte oficial.Ver versão em inglês →

​
A curva da tabela de consulta

O Stable AMM substitui a fórmula x·y=k por uma tabela de consulta esparsa de tuplas (x, y, price). Ao precificar um swap, o programa:
  1. Calcula a razão atual do pool a partir das reservas.
  2. Faz busca binária na tabela para encontrar as duas entradas que envolvem essa razão.
  3. Interpola linearmente entre elas para obter um preço intermediário.
  4. Aplica taxas e retorna a cotação.
Esta abordagem troca o determinismo de uma fórmula pela flexibilidade do admin na moldagem de preços, sendo eficiente o suficiente para caber no orçamento de compute da Solana.

​
Layout da tabela e busca binária

O ModelDataInfo armazena até 50.000 entradas DataElement, indexadas pelo admin. Apenas as primeiras valid_data_count estão ativas. Cada entrada: 
DataElement {
  x: u64,      // coordenada X (quantidade do lado da moeda, escalonada)
  y: u64,      // coordenada Y (quantidade do lado da PC, escalonada)
  price: u64,  // price = x/y, escalonado pelo multiplicador
}
Para encontrar um preço nas reservas atuais do pool (x_real, y_real):
  1. Calcule a razão: target_ratio = (x_real * multiplier) / y_real.
  2. Faça busca binária por entradas onde (element.x * multiplier) / element.y envolve target_ratio.
  3. Quando um intervalo [min_idx, max_idx] é encontrado, interpole.
O código de busca binária do programa ocupa ~150 linhas em state.rs::ModelDataInfo::get_mininum_range_by_xy_real. O invariante-chave: as entradas devem estar ordenadas (x ascendente, y descendente, price ascendente) para a busca funcionar.

​
Interpolação linear

Quando dois pontos da tabela envolvem a razão, a interpolação calcula um preço intermediário e um par de reservas: 
target = (x_real * multiplier) / y_real

[x1, y1, p1] = table[min_idx]
[x2, y2, p2] = table[max_idx]

// Interpola preço
p = p1 + (p2 - p1) * (target - ratio1) / (ratio2 - ratio1)

// Interpola reserva
x = x1 + (x2 - x1) * (target - ratio1) / (ratio2 - ratio1)
y = y1 + (y2 - y1) * (target - ratio1) / (ratio2 - ratio1)
O resultado é uma curva linear por partes que conecta suavemente os pontos da tabela.

​
Escalonamento: o multiplicador

As reservas do pool e os preços são armazenados em escalas diferentes. O campo multiplier em ModelDataInfo leva isto em conta. Um padrão comum:
  • A moeda tem 6 casas decimais, a PC tem 18 casas decimais.
  • Multiplicador = 10^6 (ou similar).
  • As entradas da tabela são armazenadas em uma escala reduzida para caber nos limites de u64.
O programa reescalona na leitura/escrita via: 
real_value = table_value * ratio / multiplier
table_value = real_value * multiplier / ratio

​
Precificação de swap: SwapBaseIn e SwapBaseOut

​
SwapBaseIn (entrada exata)

Dado um valor de entrada amount_in:
  1. Obtenha a razão atual de (coin_vault, pc_vault).
  2. Encontre as entradas da tabela que envolvem e interpole para obter a razão no espaço da tabela.
  3. Converta a entrada para o espaço da tabela: dx_table = amount_in * multiplier / ratio.
  4. Consulte a tabela na nova coordenada X para encontrar o novo Y.
  5. dy_table = y_old - y_new.
  6. Converta de volta: dy_real = dy_table * ratio / multiplier.
  7. Aplique taxa de negociação: dy_output = dy_real - (dy_real * trade_fee_numerator / trade_fee_denominator).
  8. Retorne dy_output.

​
SwapBaseOut (saída exata)

Simétrico: dado o amount_out desejado, resolva para o amount_in necessário. Ambos os caminhos liquidam pedidos OpenBook preenchidos primeiro (via lógica interna semelhante a MonitorStep), de modo que as reservas efetivas refletem qualquer preenchimento do bloco anterior.

​
Aplicação de taxa

Idêntica ao AMM v4: consulte products/amm-v4/math para a derivação completa. 
gross_fee = amount_in * (swap_fee_numerator / swap_fee_denominator)    // ex: 0,25%
lp_portion = gross_fee - (gross_fee * pnl_numerator / pnl_denominator) // ex: 0,22%
pnl_portion = gross_fee * (pnl_numerator / pnl_denominator)            // ex: 0,03%
A pnl_portion vai para need_take_pnl_* e é recolhida pelo admin via WithdrawPnl. A lp_portion permanece no vault, inflacionando k e beneficiando os detentores de tokens LP.

​
MonitorStep e OpenBook

Como no AMM v4, MonitorStep é uma instrução crank que:
  1. Liquida preenchimentos de pedidos OpenBook pendentes (move tokens dos vaults para o pool).
  2. Atualiza AmmInfo.target_orders com uma nova grade de slots de pedidos limitados.
  3. Publica a nova grade no OpenBook.
A grade é calculada a partir da tabela: o programa usa a tabela de consulta para encontrar pontos de preço e os traduz em pedidos OpenBook. Custo de compute de MonitorStep: ~150k–180k CU (similar ao AMM v4).

​
Resumo: por que isto funciona

O design de tabela de consulta + interpolação é eficiente e flexível:
  • Eficiência: a busca binária é O(log 50.000) ≈ 16 iterações, cada uma ~300–500 CU. A interpolação é algumas multiplicações/divisões. O custo total de cotação é ~5k–15k CU, muito mais barato do que recomputar uma fórmula a cada swap.
  • Flexibilidade: o admin pode codificar qualquer curva linear por partes. Pares de stablecoin ficam com alta densidade ao redor de 1:1; pares colateralizados ficam com curvas personalizadas.
  • Composabilidade OpenBook: a mesma lógica de MonitorStep / TargetOrders do AMM v4 se aplica. A descoberta de preço via tabela alimenta a geração da grade de pedidos.
Para aprofundamentos na lógica de interpolação, consulte raydium-stable/program/src/state.rs, métodos get_data_by_x, get_data_by_y, get_dy_by_dx_base_in, etc.

​
Próximos passos

  • Contas — referência de campos de ModelDataInfo e DataElement.
  • Instruções — InitModelData, UpdateModelData para preencher a tabela.
  • Taxas — aplicação de taxa e WithdrawPnl.
  • products/amm-v4/math — para a lógica de precificação de pedidos inclusiva de taxa do OpenBook.
Fontes:
  • raydium-stable/program/src/state.rs (implementações de interpolação e busca binária)
  • raydium-stable/program/src/math.rs (utilitários de calculadora)