> ## 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. # Contas do Stable AMM > AmmInfo, ModelDataInfo, DataElement, Fees e layout de vault. O inventário completo de contas de um pool Stable AMM (um programa Raydium puro, dedicado a AMM). **Esta página foi traduzida automaticamente por IA. A versão em inglês é a fonte oficial.** [Ver versão em inglês →](/products/stable/accounts) Stable AMM é seu próprio programa; sua estrutura de contas no lado do pool se assemelha ao AMM v4 (AmmInfo, vaults, authority), e adicionalmente possui uma conta `ModelDataInfo` que armazena a tabela de consulta. Esta página cobre ambas. ## Inventário **AMM puro.** Stable AMM mantém toda a liquidez em seus próprios vaults e não depende do OpenBook. Ele carregava um caminho de market-making do OpenBook no início de sua vida, mas esse caminho ficou inativo por anos, e a [atualização de 2026-06-22](/pt/reference/changelog) removeu o código remanescente. As contas de mercado `serum_*` e `amm_open_orders` abaixo são, portanto, **legado**: podem ainda aparecer em transações de layout antigo para compatibilidade com versões anteriores, mas o programa não as valida ou lê, e as instruções de novo layout as omitem inteiramente. O inventário ativo agora é inteiramente no lado do pool: | Categoria | Conta | Proprietário | Função | | --------- | ------------------------------------ | --------------- | ------------------------------------------------------------------------------------------------------------- | | Pool | `AmmInfo` | Programa Stable | Estado do pool, referências aos vaults e à conta de dados do modelo. | | Pool | `amm_authority` | Programa Stable | PDA de propriedade do programa que assina movimentos de vault. Compartilhado entre todos os pools Stable AMM. | | Pool | `amm_target_orders` | Programa Stable | Conta de grid no lado do pool (retida em layouts; não mais impulsiona ordens do OpenBook). | | Pool | `pool_coin_token_account` | SPL Token | Vault no lado da moeda do pool. | | Pool | `pool_pc_token_account` | SPL Token | Vault no lado do pc do pool. | | Pool | `lp_mint` | SPL Token | Mint de LP fungível. | | Modelo | **`model_data_account`** | Programa Stable | **A tabela de consulta: 50.000 × DataElement.** | | Legado | `amm_open_orders` | OpenBook | A antiga conta `OpenOrders` do OpenBook do pool. **Não utilizada.** | | Legado | `serum_market` | OpenBook | Mercado OpenBook. **Não utilizado.** | | Legado | `serum_bids`, `serum_asks` | OpenBook | Filas de bid/ask. **Não utilizadas.** | | Legado | `serum_event_queue` | OpenBook | Fila de eventos. **Não utilizada.** | | Legado | `serum_coin_vault`, `serum_pc_vault` | SPL Token | Vaults de nível de mercado do OpenBook. **Não utilizados.** | | Legado | `serum_vault_signer` | OpenBook | Assinante de vault de nível de mercado. **Não utilizado.** | ## `AmmInfo` Conta de estado raiz. O layout é quase idêntico ao AMM v4 — parâmetros do pool, decimais, taxas, referências de vault/mint — com uma adição: um campo `model_data_key` apontando para a tabela de consulta. ```rust theme={null} // raydium-stable/program/src/state.rs (abridged) pub struct AmmInfo { pub account_type: u64, // = 0 (AmmAccount) pub status: u64, // bitmask: swap/deposit/withdraw/crank enabled pub nonce: u64, // bump for amm_authority pub order_num: u64, pub depth: u64, pub coin_decimals: u64, pub pc_decimals: u64, pub state: u64, // state machine (IdleState, etc.) pub reset_flag: u64, pub min_size: u64, pub vol_max_cut_ratio: u64, pub amount_wave: u64, pub coin_lot_size: u64, // mirrors OpenBook pub pc_lot_size: u64, pub min_price_multiplier: u64, pub max_price_multiplier: u64, pub sys_decimal_value: u64, pub abort_trade_factor: u64, pub price_tick_multiplier: u64, pub price_tick: u64, pub fees: Fees, // see below pub out_put: OutPutData, // PnL, swaps, punish amounts pub coin_vault: Pubkey, pub pc_vault: Pubkey, pub coin_mint: Pubkey, pub pc_mint: Pubkey, pub lp_mint: Pubkey, pub model_data_key: Pubkey, // ← THE LOOKUP TABLE pub open_orders: Pubkey, // legacy: OpenBook OpenOrders (unused post-decoupling) pub serum_market: Pubkey, // legacy: unused post-decoupling pub serum_program: Pubkey, // legacy: unused post-decoupling pub target_orders: Pubkey, pub amm_admin: Pubkey, // admin key pub client_order_id: u64, pub lp_amount: u64, // LP supply pub lp_net: u64, // LP value metric pub padding: [u64; 61], } pub struct Fees { pub min_separate_numerator: u64, pub min_separate_denominator: u64, pub trade_fee_numerator: u64, // 25 pub trade_fee_denominator: u64, // 10_000 → 0.25% pub pnl_numerator: u64, // 12 pub pnl_denominator: u64, // 100 → 12% of fee = 0.03% of volume pub swap_fee_numerator: u64, // 25 pub swap_fee_denominator: u64, // 10_000 } pub struct OutPutData { pub need_take_pnl_coin: u64, // accrued protocol fee (coin) pub need_take_pnl_pc: u64, // accrued protocol fee (pc) pub total_pnl_pc: u64, pub total_pnl_coin: u64, pub pool_open_time: u64, pub punish_pc_amount: u64, pub punish_coin_amount: u64, pub orderbook_to_init_time: u64, pub swap_coin_in_amount: u128, pub swap_pc_out_amount: u128, pub swap_pc_in_amount: u128, pub swap_coin_out_amount: u128, pub swap_pc_fee: u64, pub swap_coin_fee: u64, } ``` Campos principais para integradores: * **`model_data_key`** — o endereço da tabela de consulta. Deve ser passado para cada instrução. * **`fees`** — estrutura idêntica ao AMM v4. Padrão de 0,25% de taxa de negociação, divisão de 0,22% LP / 0,03% protocolo. * **`coin_vault`**, **`pc_vault`** — os vaults dos pools. * **`status`** — bitmask controlando swap/deposit/withdraw/crank. * **`out_put.need_take_pnl_*`** — removido por `WithdrawPnl`. ## `ModelDataInfo` A tabela de consulta. Um grande array esparso de pontos de preço/quantidade. ```rust theme={null} // raydium-stable/program/src/state.rs pub const ELEMENT_SIZE: usize = 50000; pub struct DataElement { pub x: u64, // table X (e.g., coin amount) pub y: u64, // table Y (e.g., pc amount) pub price: u64, // price at (x, y) } pub struct ModelDataInfo { pub account_type: u64, // = 2 (ModleDataAccount) pub status: u64, // Initialized or Uninitialized pub multiplier: u64, // scale factor for x, y (e.g., 10^6) pub valid_data_count: u64, // how many elements are populated pub elements: [DataElement; 50000], // the table itself } ``` **Ciclo de vida:** As instruções de configuração que construíram essas tabelas — `InitModelData` (criou a conta) e `UpdateModelData` (preencheu elementos, definindo `valid_data_count`) — foram **removidas na atualização de 2026-06-22**. As tabelas em pools existentes agora são **fixas**. Em tempo de execução, as instruções chamáveis restantes ainda as consomem: * **Swap / deposit / withdraw** chamam funções de consulta que fazem busca binária e interpolação dentro de `elements[0..valid_data_count]`. ## `DataElement` A entrada atômica na tabela. Deve estar ordenada (x ascendente, y descendente, preço ascendente) para que a busca binária funcione. ```rust theme={null} pub struct DataElement { pub x: u64, // X coordinate (e.g., token_a balance, scaled by multiplier) pub y: u64, // Y coordinate (e.g., token_b balance, scaled by multiplier) pub price: u64, // price (x/y in scaled form, scaled by multiplier) } ``` Ao preencher a tabela, o administrador especifica esses pré-escalados. O programa não valida a ordem de classificação on-chain (por velocidade), então uma classificação incorreta causa cotações incorretas. ## Authority e vaults Igual ao AMM v4: * **`amm_authority`** é um único PDA de programa derivado com seed `["amm authority"]`. Ele possui todos os vaults do pool e assina seus movimentos. * **Vaults** são contas SPL Token cujo proprietário é `amm_authority`, não ATAs. Token-2022 **não** é suportado. ## Bitmask de status Idêntico ao AMM v4. Controla se swap/deposit/withdraw/crank estão habilitados. ## Rastreamento de taxa e PnL A struct `out_put` rastreia: * **`need_take_pnl_coin`**, **`need_take_pnl_pc`** — taxas de protocolo acumuladas mas ainda não removidas. `WithdrawPnl` move essas para fora. * **`swap_coin_in_amount`**, `swap_pc_in_amount`, etc. — contadores de análise. **Cálculo de ativos do pool (pós-desacoplamento).** Como nenhum fundo é mais mantido em custódia como ordens abertas do OpenBook, os ativos totais do pool agora são calculados inteiramente a partir dos vaults: ``` Antigo: ativos totais = saldos de vault + fundos de ordem aberta (native_coin_total / native_pc_total) − PnL pendente (need_take_pnl) Novo: ativos totais = saldos de vault − PnL pendente (need_take_pnl) ``` Indexadores e código de cotação que reconstruíram o valor do pool a partir de saldos de OpenOrders devem descartar esse termo. ## Tamanho da conta O **`ModelDataInfo` é grande** (\~1,2 MB, já que 50.000 elementos × 24 bytes por elemento). É por isso que criar um pool Stable requer alocação explícita de rent e pré-alocação de conta. O SDK e ferramentas do Raydium lidam com isso de forma transparente; integradores raramente precisam alocar manualmente. ## Derivando contas do zero Como AMM v4, Stable AMM usa **chaves com seed** (não PDAs puras). A identidade canônica do pool é derivada via: ``` ammId = createWithSeed( owner: ammAuthority, seed: marketPubkey.toBase58().slice(0, 32), programId: STABLE_PROGRAM_ID, ) ``` Similarmente para vaults, LP mint, target orders, etc. Na prática, use o SDK ou API para buscar endereços pré-computados. ## O que ler onde * **Listas de contas de instrução**: [`products/stable/instructions`](/pt/products/stable/instructions). * **Como a interpolação usa a tabela**: [`products/stable/math`](/pt/products/stable/math). * **Estrutura de taxa e WithdrawPnl**: [`products/stable/fees`](/pt/products/stable/fees). * **O desacoplamento do OpenBook de 2026-06-22**: [`reference/changelog`](/pt/reference/changelog). Fontes: * [`reference/program-addresses`](/pt/reference/program-addresses)