Struct RawPoolState 

pub struct RawPoolState {

    pub variant: CurveVariant,
    pub balances: Vec<U256>,
    pub token_decimals: Vec<u8>,
    pub amp: U256,
    pub fee: Option<U256>,
    pub mid_fee: Option<U256>,
    pub out_fee: Option<U256>,
    pub fee_gamma: Option<U256>,
    pub offpeg_fee_multiplier: Option<U256>,
    pub price_scale: Option<Vec<U256>>,
    pub d: Option<U256>,
    pub gamma: Option<U256>,
    pub dynamic_rates: Option<Vec<Option<U256>>>,
    pub precisions: Option<Vec<U256>>,
    pub eth_variant: Option<bool>,
}

Raw on-chain pool state, as collected by a transport (RPC, Substreams, etc.).

The consumer fills in the fields relevant to the pool’s CurveVariant, then calls build_pool to get a crate::evm::protocol::curve::math::Pool ready for swap computation.

Fields

variant: CurveVariant

Which Curve variant this pool is.

balances: Vec<U256>

Token balances in native token units (wei). Updates every block.

Length determines coin count (2, 3, or 4+).

Gotchas

StableSwapNG: balances(i) on-chain returns balanceOf(pool) - admin_balances[i], excluding uncollected admin fees. An indexer tracking ERC20 Transfer events sees balanceOf changes, not balances(). The difference is small but causes wei-level mismatches. Use the balances() getter, not balanceOf.

Rebase tokens (e.g. stETH): balances change without Transfer events — the token rebases in-place. Requires calling balanceOf(pool) on the rebase token each block.

token_decimals: Vec<u8>

Token decimals for each coin (e.g. [18, 6] for ETH/USDC). Must have the same length as balances.

amp: U256

Amplification parameter — already interpolated for the target block. Semi-static: only changes during A ramping (rare admin events, days apart).

This value must match what the on-chain _A() internal function returns at the target block’s timestamp. It includes the variant’s precision scaling (A_PRECISION=100 for StableSwap V2+, A_MULTIPLIER=10000 for CryptoSwap, 1 for V0/V1).

How to obtain this value

RPC consumer: Call the pool’s A() view function at the target block. Returns the already-interpolated value in a single RPC call.

let amp = pool_contract.A().block(block_number).call().await?;

Warning: for all A_PRECISION=100 variants (V2, Meta, NG, ALend), A() returns initial_A / A_PRECISION via integer division, losing the remainder:

initial_A = 79258
A() = 79258 / 100 = 792      (truncated)
A() * 100 = 79200 ≠ 79258    (lost 58)

For exact precision, read initial_A() directly when no ramping (initial_A == future_A), or use interpolate_a during ramps.

Substreams / storage-based consumer: Read initial_A, future_A, initial_A_time, future_A_time from contract storage, then interpolate for the current block’s timestamp:

let amp = curve_adapter::interpolate_a(
    initial_a, future_a,
    initial_a_time, future_a_time,
    block_timestamp,
);

For V0/V1 pools that store a single A value (no ramping), pass that value directly.

Caution with factory deploy events: PlainPoolDeployed and MetaPoolDeployed events emit A as the user-provided value (e.g. 400), NOT the raw on-chain value (e.g. 40000). Multiply by A_PRECISION (100 for V2/NG/Meta/ALend) before passing here.

fee: Option<U256>

StableSwap fee. Static (set at pool creation). Required for all StableSwap variants.

mid_fee: Option<U256>

CryptoSwap mid fee. Static. Required for all CryptoSwap variants.

out_fee: Option<U256>

CryptoSwap out fee. Static. Required for all CryptoSwap variants.

fee_gamma: Option<U256>

CryptoSwap fee gamma. Static. Required for all CryptoSwap variants.

offpeg_fee_multiplier: Option<U256>

Dynamic fee multiplier. Static. Required for StableSwapNG and StableSwapALend.

price_scale: Option<Vec<U256>>

Price scale(s). Updates every block. TwoCrypto: 1 element, TriCrypto: 2 elements. Required for all CryptoSwap variants.

d: Option<U256>

Pool invariant D. Updates every block. Required for all CryptoSwap variants.

gamma: Option<U256>

Gamma parameter. Semi-static (only changes during admin ramp). Required for TwoCryptoV1, TwoCryptoNG, TriCryptoV1, TriCryptoNG. NOT required for TwoCryptoStable (gamma is ignored).

dynamic_rates: Option<Vec<Option<U256>>>

Per-token dynamic rates for StableSwap variants. Depends on token type.

If None, rates are computed from token_decimals as 10^(36 - decimals). This is correct for v6+ crvUSD factory pools (balances variant) which use static decimal-based rates and have no stored_rates() getter.

If Some, must have the same length as balances. Each element:

• Some(rate) — use this dynamic rate (oracle, ERC4626, etc.)
• None — compute from decimals as 10^(36 - decimals)

When to provide dynamic rates

StableSwapNG with oracle tokens: Call stored_rates() on the pool contract each block. Plain tokens return static rates, but ERC4626/oracle tokens return rates that change per-block.

MetaPools: rates[last] must be base_pool.get_virtual_price(). To find the base pool address: try pool.base_pool() first. MetaPool Factory proxy pools lack this getter — use factory.get_base_pool(pool) instead. Do not assume the base pool is 3pool; BTC meta pools use sBTC.

Gotchas

Fee-on-transfer tokens: actual received amount differs from the transfer parameter. Curve pools generally do not support these tokens, but if encountered, balances will be incorrect.

Tokens with 0 decimals: rate becomes 10^36 — valid but rounding impact is outsized. Every wei of such a token is worth 10^36 in normalized space.

precisions: Option<Vec<U256>>

On-chain precisions for CryptoSwap variants. Immutable.

If Some, used directly instead of computing from token_decimals. Read from the pool contract’s precisions() getter.

This is important because some tokens report incorrect decimals() (e.g. Spectra PT tokens), and the factory computes the correct precisions at deployment time.

If None, precisions are computed as 10^(18 - decimals).

eth_variant: Option<bool>

Selects the deployed Vyper flavour for TwoCryptoV1 only. Immutable.

Legacy 2-coin CryptoSwap V1 pools ship in two flavours whose Newton get_y solver differs by a single mul2 integer-division grouping (see [crate::evm::protocol::curve::math::core::twocrypto_v1]). Some(true) selects the ETH pool grouping (all factory/proxy and WETH-paired legacy pools); Some(false) selects the non-ETH legacy direct-deploy grouping.

Required for TwoCryptoV1 — build_pool returns BuildError::MissingField if it is None. Ignored for every other variant. Obtain it via detect_eth_variant.

Trait Implementations

impl Clone for RawPoolState

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RawPoolState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RawPoolState

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RawPoolState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RawPoolState

impl PartialEq for RawPoolState

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for RawPoolState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RawPoolState