Grcov report - helpers.rs

1

use cosmwasm_std::{CosmosMsg, SubMsg};

2

3

use injective_cosmwasm::InjectiveMsgWrapper;

4

use injective_math::FPDecimal;

5

6

pub fn i32_to_dec(source: i32) -> FPDecimal {

7

    FPDecimal::from(i128::from(source))

8

9

10

pub fn get_message_data(response: &[SubMsg<InjectiveMsgWrapper>], position: usize) -> &InjectiveMsgWrapper {

11

    let sth = match &response.get(position).unwrap().msg {

12

        CosmosMsg::Custom(msg) => msg,

13

        _ => panic!("No wrapped message found"),

14

};

15

sth

16

17

18

14

pub fn round_up_to_min_tick(num: FPDecimal, min_tick: FPDecimal) -> FPDecimal {

19

14

    if num < min_tick {

20

2

        return min_tick;

21

12

22

12

23

12

    let remainder = FPDecimal::from(num.num % min_tick.num);

24

12

25

12

    if remainder.num.is_zero() {

26

8

        return num;

27

4

28

4

29

4

    FPDecimal::from(num.num - remainder.num + min_tick.num)

30

14

31

32

pub trait Scaled {

33

    fn scaled(self, digits: i32) -> Self;

34

35

36

impl Scaled for FPDecimal {

37

2660

    fn scaled(self, digits: i32) -> Self {

38

2660

        self.to_owned() * FPDecimal::from(10i128).pow(FPDecimal::from(digits as i128)).unwrap()

39

2660

40

41

42

pub fn dec_scale_factor() -> FPDecimal {

43

    FPDecimal::ONE.scaled(18)

44

45

46

#[cfg(test)]

47

mod tests {

48

    use super::*;

49

    use std::str::FromStr;

50

51

    #[test]

52

2

    fn test_descale() {

53

2

        let val = FPDecimal::must_from_str("1000000000000000000");

54

2

        let descaled = val.scaled(-18);

55

2

        assert_eq!(descaled, FPDecimal::from(1u128));

56

2

        let scaled = descaled.scaled(18);

57

2

        assert_eq!(scaled, val);

58

2

59

60

    #[test]

61

2

    fn test_round_up_to_min_tick() {

62

2

        let num = FPDecimal::from(37u128);

63

2

        let min_tick = FPDecimal::from(10u128);

64

2

65

2

        let result = round_up_to_min_tick(num, min_tick);

66

2

        assert_eq!(result, FPDecimal::from(40u128));

67

68

2

        let num = FPDecimal::from_str("0.00000153").unwrap();

69

2

        let min_tick = FPDecimal::from_str("0.000001").unwrap();

70

2

71

2

        let result = round_up_to_min_tick(num, min_tick);

72

2

        assert_eq!(result, FPDecimal::from_str("0.000002").unwrap());

73

74

2

        let num = FPDecimal::from_str("0.000001").unwrap();

75

2

        let min_tick = FPDecimal::from_str("0.000001").unwrap();

76

2

77

2

        let result = round_up_to_min_tick(num, min_tick);

78

2

        assert_eq!(result, FPDecimal::from_str("0.000001").unwrap());

79

80

2

        let num = FPDecimal::from_str("0.0000001").unwrap();

81

2

        let min_tick = FPDecimal::from_str("0.000001").unwrap();

82

2

83

2

        let result = round_up_to_min_tick(num, min_tick);

84

2

        assert_eq!(result, FPDecimal::from_str("0.000001").unwrap());

85

2

86