Saltar al contenido 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 fue traducida automáticamente por IA. La versión en inglés es la fuente autorizada.Ver versión en inglés →

​
La curva de tabla de búsqueda

El AMM estable reemplaza la fórmula x·y=k con una tabla de búsqueda dispersa de tuplas (x, y, precio). Cuando se cotiza un intercambio, el programa:
  1. Calcula la relación actual del pool a partir de las reservas.
  2. Busca binariamente en la tabla para encontrar las dos entradas que enmarcan esa relación.
  3. Interpola linealmente entre ellas para obtener un precio intermedio.
  4. Aplica comisiones y devuelve la cotización.
Este enfoque cambia el determinismo de una fórmula por flexibilidad del administrador en la formación de precios, y es lo suficientemente eficiente para caber en el presupuesto de cálculo de Solana.

​
Diseño de tabla y búsqueda binaria

ModelDataInfo contiene hasta 50,000 entradas DataElement, indexadas por el administrador. Solo las primeras valid_data_count están activas. Cada entrada: 
DataElement {
  x: u64,      // Coordenada X (cantidad del lado de moneda, escalada)
  y: u64,      // Coordenada Y (cantidad del lado de PC, escalada)
  price: u64,  // precio = x/y, escalado por multiplicador
}
Para encontrar un precio en las reservas actuales del pool (x_real, y_real):
  1. Calcula la relación: target_ratio = (x_real * multiplier) / y_real.
  2. Busca binariamente entradas donde (element.x * multiplier) / element.y enmarque target_ratio.
  3. Cuando se encuentra un intervalo [min_idx, max_idx], interpola.
El código de búsqueda binaria del programa ocupa ~150 líneas en state.rs::ModelDataInfo::get_mininum_range_by_xy_real. El invariante clave: las entradas deben estar ordenadas (x ascendente, y descendente, precio ascendente) para que la búsqueda funcione.

​
Interpolación lineal

Una vez que dos puntos de tabla enmarcan la relación, la interpolación calcula un precio intermedio y un par de reservas: 
target = (x_real * multiplier) / y_real

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

// Interpola precio
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)
El resultado es una curva lineal por partes que conecta suavemente los puntos de la tabla.

​
Escalado: el multiplicador

Las reservas del pool y los precios se almacenan en escalas diferentes. El campo multiplier en ModelDataInfo tiene esto en cuenta. Un patrón común:
  • La moneda tiene 6 decimales, PC tiene 18 decimales.
  • Multiplicador = 10^6 (o similar).
  • Las entradas de la tabla se almacenan en una escala reducida para caber en los límites de u64.
El programa reescala en lectura/escritura mediante: 
real_value = table_value * ratio / multiplier
table_value = real_value * multiplier / ratio

​
Precios de intercambio: SwapBaseIn y SwapBaseOut

​
SwapBaseIn (entrada exacta)

Dada la cantidad de entrada amount_in:
  1. Obtén la relación actual de (coin_vault, pc_vault).
  2. Encuentra entradas de tabla que enmarquen e interpola para obtener la relación en espacio de tabla.
  3. Convierte la entrada al espacio de tabla: dx_table = amount_in * multiplier / ratio.
  4. Consulta la tabla en la nueva coordenada X para encontrar la Y nueva.
  5. dy_table = y_old - y_new.
  6. Convierte de vuelta: dy_real = dy_table * ratio / multiplier.
  7. Aplica comisión de intercambio: dy_output = dy_real - (dy_real * trade_fee_numerator / trade_fee_denominator).
  8. Devuelve dy_output.

​
SwapBaseOut (salida exacta)

Simétrico: dada la amount_out deseada, resuelve la amount_in requerida. Ambas rutas cierran órdenes completadas de OpenBook primero (mediante lógica interna similar a MonitorStep), por lo que las reservas efectivas reflejan cualquier llenado del bloque anterior.

​
Aplicación de comisiones

Idéntica a AMM v4: consulta products/amm-v4/math para la derivación completa. 
gross_fee = amount_in * (swap_fee_numerator / swap_fee_denominator)    // p. ej., 0,25%
lp_portion = gross_fee - (gross_fee * pnl_numerator / pnl_denominator) // p. ej., 0,22%
pnl_portion = gross_fee * (pnl_numerator / pnl_denominator)            // p. ej., 0,03%
La pnl_portion va a need_take_pnl_* y es retirada por el administrador mediante WithdrawPnl. La lp_portion permanece en el bóveda, inflando k y beneficiando a los tenedores de tokens LP.

​
MonitorStep y OpenBook

Como en AMM v4, MonitorStep es una instrucción crank que:
  1. Cierra llenados de órdenes de OpenBook pendientes (mueve tokens de bóvedas al pool).
  2. Actualiza AmmInfo.target_orders con una nueva cuadrícula de ranuras de órdenes limitadas.
  3. Publica la nueva cuadrícula en OpenBook.
La cuadrícula se calcula a partir de la tabla: el programa utiliza la tabla de búsqueda para encontrar puntos de precio y los traduce en órdenes de OpenBook. Costo de cálculo de MonitorStep: ~150k–180k CU (similar a AMM v4).

​
Resumen: por qué funciona

El diseño de tabla de búsqueda + interpolación es eficiente y flexible:
  • Eficiencia: La búsqueda binaria es O(log 50,000) ≈ 16 iteraciones, cada una ~ 300–500 CU. La interpolación es algunos multiplicaciones/divisiones. El costo total de cotización es ~5k–15k CU, mucho más barato que recomputar una fórmula en cada intercambio.
  • Flexibilidad: El administrador puede codificar cualquier curva lineal por partes. Los pares de monedas estables obtienen alta densidad alrededor de 1:1; los pares colateralizados obtienen curvas personalizadas.
  • Composabilidad de OpenBook: La misma lógica MonitorStep / TargetOrders de AMM v4 se aplica. El descubrimiento de precios a través de la tabla alimenta la generación de cuadrícula de órdenes.
Para análisis profundos de la lógica de interpolación, consulta raydium-stable/program/src/state.rs, métodos get_data_by_x, get_data_by_y, get_dy_by_dx_base_in, etc.

​
Dónde ir a continuación

  • Cuentas — referencia de campos ModelDataInfo y DataElement.
  • Instrucciones — InitModelData, UpdateModelData para rellenar la tabla.
  • Comisiones — aplicación de comisiones y WithdrawPnl.
  • products/amm-v4/math — para la lógica de precios de órdenes inclusiva de comisiones de OpenBook.
Fuentes:
  • raydium-stable/program/src/state.rs (implementaciones de interpolación y búsqueda binaria)
  • raydium-stable/program/src/math.rs (utilidades de calculadora)