# Get Coin Amounts or Liquidity for Position

## 1. Calculates token amounts from a given liquidity delta.

cetusdlmm/sources/dlmm\_path.move

````rust
/// This function calculates how much of each token corresponds to a given
/// liquidity delta, proportional to the current bin composition.
/// The result is floor-rounded to ensure the bin has sufficient tokens.
///
/// ## Mathematical Formula
/// ```
/// amount_a_out = floor(amount_a * delta_liquidity / liquidity_share)
/// amount_b_out = floor(amount_b * delta_liquidity / liquidity_share)
/// ```
///
/// ## Parameters
/// - `amount_a`: Current amount of token A in the bin
/// - `amount_b`: Current amount of token B in the bin
/// - `delta_liquidity`: The liquidity delta to calculate amounts for
/// - `liquidity_share`: Total liquidity share in the bin
///
/// ## Returns
/// - `(u64, u64)`: Tuple of (amount_a, amount_b) corresponding to the liquidity delta
///
/// ## Errors
/// - `ELiquiditySupplyIsZero`: If liquidity supply is zero
/// - `EInvalidDeltaLiquidity`: If delta liquidity exceeds supply
public fun calculate_amounts_by_liquidity(
    amount_a: u64,
    amount_b: u64,
    delta_liquidity: u128,
    liquidity_share: u128,
): (u64, u64) {
    assert!(liquidity_share > 0, ELiquiditySupplyIsZero);
    assert!(delta_liquidity <= liquidity_share, EInvalidDeltaLiquidity);
    if (delta_liquidity == 0) {
        return (0, 0)
    };

    let out_amount_a = if (amount_a == 0) { 0 } else {
        full_math_u128::mul_div_floor(
            amount_a as u128,
            delta_liquidity,
            liquidity_share,
        )
    };
    let out_amount_b = if (amount_b == 0) { 0 } else {
        full_math_u128::mul_div_floor(
            amount_b as u128,
            delta_liquidity,
            liquidity_share,
        )
    };
    (out_amount_a as u64, out_amount_b as u64)
}
````

## 2.  Calculates liquidity using the constant sum formula.

```
/// This function calculates the total liquidity value based on the amounts
/// of both tokens and the bin's price using the constant sum formula.
///
/// ## Mathematical Formula
/// `L = price * amount_a + amount_b`
///
/// Where:
/// - `L` = Total liquidity
/// - `price` = Bin price in Q64x64 format
/// - `amount_a` = Amount of token A
/// - `amount_b` = Amount of token B
///
/// ## Parameters
/// - `amount_a`: Amount of token A
/// - `amount_b`: Amount of token B
/// - `price`: Bin price in Q64x64 format
///
/// ## Returns
/// - `u128`: Total liquidity value
///
/// ## Errors
/// - `EPriceIsZero`: If the price is zero
/// - `ELiquidityOverflow`: If the calculation results in overflow
public fun calculate_liquidity_by_amounts(amount_a: u64, amount_b: u64, price: u128): u128 {
    assert!(price > 0, EPriceIsZero);
    if (amount_a == 0 && amount_b == 0) {
        return 0
    };
    let liquidity =
        full_math_u128::full_mul(amount_a as u128, price) + (amount_b as u256 << scale_offset!());
    assert!(liquidity < std::u128::max_value!() as u256, ELiquidityOverflow);
    liquidity as u128
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://cetus-1.gitbook.io/cetus-developer-docs/developer/via-dlmm-contract/features-available/get-coin-amounts-or-liquidity-for-position.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.