Liquidity using guide

amount-in: The number of tokens
reserve-in: The token reserve
reserve-out: Output token reserve
fee-rate: Processing rate

amount-in-with-fee = amount-in * fee-rate
amount-out = (amount-in-with-fee * reserve-out) / (reserve-in * 10000 + amount-in-with-fee)

amount-in = (reserve-in * amount-out * 10000) / (reserve-out - amount-out * fee-rate) + 1

// Calculate how many output tokens a user can obtain
public fun get_amount_out(
    amount_in: u64,
    reserve_in: u64,
    reserve_out: u64,
    fee_rate: u64,
): u64 {
    assert!(amount_in > 0, ErrorInputTokenAmount); // Make sure the input amount is greater than 0
    assert!(reserve_in > 0 && reserve_out > 0, ErrorInsufficientLiquidity); // Ensure that the pool is fluid enough

    let amount_in_with_fee = (amount_in as u128) * (fee_rate as u128); // Calculate the gas fee
    // Based on the constant product formula: (x + Δx)(y - Δy) = xy Calculate the output amount
    let numerator = amount_in_with_fee * (reserve_out as u128);
    let denominator = (reserve_in as u128) * 10000u128 + amount_in_with_fee;
    ((numerator / denominator) as u64)
}

// Calculate how many input tokens are required to obtain a specific number of output tokens
public fun get_amount_in(
    amount_out: u64,
    reserve_in: u64,
    reserve_out: u64,
    fee_rate: u64
): u64 {
    assert!(amount_out > 0, ErrorOutputTokenAmount);
    assert!(reserve_in > 0 && reserve_out > 0, ErrorInsufficientLiquidity);

    // Calculate in reverse from the constant product formula, add 1 to ensure that there is enough input
    let numerator = (reserve_in as u128) * (amount_out as u128) * 10000u128;
    let denominator = ((reserve_out as u128) - (amount_out as u128)) * (fee_rate as u128);
    (((numerator / denominator) as u64) + 1u64)
}

point = x / x pool * 100%
y = y pool * point