Struct cardano_serialization_lib::plutus::ExUnitPrices

source ·

pub struct ExUnitPrices { /* private fields */ }

Implementations§

source §

pub fn mem_price(&self) -> UnitInterval

Examples found in repository ?

src/fees.rs (line 68)

pub fn calculate_ex_units_ceil_cost(
    ex_units: &ExUnits,
    ex_unit_prices: &ExUnitPrices,
) -> Result<Coin, JsError> {
    type Ratio = (BigInt, BigInt);
    fn mult(sc: &SubCoin, x: &BigNum) -> Result<Ratio, JsError> {
        let n: BigInt = BigInt::from_str(&sc.numerator.to_str())?;
        let d: BigInt = BigInt::from_str(&sc.denominator.to_str())?;
        let m: BigInt = BigInt::from_str(&x.to_str())?;
        Ok((n.mul(&m), d))
    }
    fn sum(a: &Ratio, b: &Ratio) -> Ratio {
        // Ratio Addition: a/x + b/y = ((a*y) + (b*x))/(x*y)
        let (a_num, a_denum) = &a;
        let (b_num, b_denum) = &b;
        if a_num.is_zero() {
            return b.clone();
        }
        if b_num.is_zero() {
            return a.clone();
        }
        let a_num_fixed = &a_num.mul(b_denum);
        let b_num_fixed = &b_num.mul(a_denum);
        let a_b_num_sum = a_num_fixed.add(b_num_fixed);
        let common_denum = a_denum.mul(b_denum);
        (a_b_num_sum, common_denum)
    }
    let mem_ratio: Ratio = mult(&ex_unit_prices.mem_price(), &ex_units.mem())?;
    let steps_ratio: Ratio = mult(&ex_unit_prices.step_price(), &ex_units.steps())?;
    let (total_num, total_denum) = sum(&mem_ratio, &steps_ratio);
    match total_num.div_ceil(&total_denum).as_u64() {
        Some(coin) => Ok(coin),
        _ => Err(JsError::from_str(&format!(
            "Failed to calculate ceil from ratio {}/{}",
            total_num.to_str(),
            total_denum.to_str(),
        ))),
    }
}

source

pub fn step_price(&self) -> UnitInterval

Examples found in repository ?

src/fees.rs (line 69)

pub fn calculate_ex_units_ceil_cost(
    ex_units: &ExUnits,
    ex_unit_prices: &ExUnitPrices,
) -> Result<Coin, JsError> {
    type Ratio = (BigInt, BigInt);
    fn mult(sc: &SubCoin, x: &BigNum) -> Result<Ratio, JsError> {
        let n: BigInt = BigInt::from_str(&sc.numerator.to_str())?;
        let d: BigInt = BigInt::from_str(&sc.denominator.to_str())?;
        let m: BigInt = BigInt::from_str(&x.to_str())?;
        Ok((n.mul(&m), d))
    }
    fn sum(a: &Ratio, b: &Ratio) -> Ratio {
        // Ratio Addition: a/x + b/y = ((a*y) + (b*x))/(x*y)
        let (a_num, a_denum) = &a;
        let (b_num, b_denum) = &b;
        if a_num.is_zero() {
            return b.clone();
        }
        if b_num.is_zero() {
            return a.clone();
        }
        let a_num_fixed = &a_num.mul(b_denum);
        let b_num_fixed = &b_num.mul(a_denum);
        let a_b_num_sum = a_num_fixed.add(b_num_fixed);
        let common_denum = a_denum.mul(b_denum);
        (a_b_num_sum, common_denum)
    }
    let mem_ratio: Ratio = mult(&ex_unit_prices.mem_price(), &ex_units.mem())?;
    let steps_ratio: Ratio = mult(&ex_unit_prices.step_price(), &ex_units.steps())?;
    let (total_num, total_denum) = sum(&mem_ratio, &steps_ratio);
    match total_num.div_ceil(&total_denum).as_u64() {
        Some(coin) => Ok(coin),
        _ => Err(JsError::from_str(&format!(
            "Failed to calculate ceil from ratio {}/{}",
            total_num.to_str(),
            total_denum.to_str(),
        ))),
    }
}