plasma-amm-sdk 0.1.0

Plasma AMM SDK
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use std::fmt::Display;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PlasmaError {
    InvariantViolation(u128, u128),
    MismatchedFees(u128, u128),
    UninitializedPool,
    SwapAmountMismatch,
    Overflow,
    Underflow,
    UnexpectedArgument,
    MissingExpectedArgument,
    BelowMinimumLpSharesRequired,
    BelowMinimumWithdrawaRequired {
        quote_amount_to_withdraw: u64,
        base_amount_to_withdraw: u64,
    },
    VestingPeriodNotOver,
    IncorrectProtocolFeeRecipient,
    TooManyShares,
    SwapExactOutTooLarge,
    SwapExactInTooLarge,
    SwapOutputGreaterThanOrEqualToReserves(u128, u128),
}

impl Display for PlasmaError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            PlasmaError::InvariantViolation(k_start, k_end) => {
                write!(
                    f,
                    "InvariantViolation: k_end {} is less than k_start {} ",
                    k_end, k_start
                )
            }
            PlasmaError::MismatchedFees(expected, actual) => {
                write!(
                    f,
                    "MismatchedFees: Expected {} but got {}",
                    expected, actual
                )
            }
            PlasmaError::UninitializedPool => write!(f, "Pool is uninitialized"),
            PlasmaError::SwapAmountMismatch => write!(f, "SwapAmountMismatch"),
            PlasmaError::Overflow => write!(f, "Calculation overflowed"),
            PlasmaError::Underflow => write!(f, "Difference underflowed"),
            PlasmaError::UnexpectedArgument => write!(f, "Unexpected argument"),
            PlasmaError::MissingExpectedArgument => write!(f, "Missing expected argument"),
            PlasmaError::BelowMinimumLpSharesRequired => {
                write!(f, "Must mint at least 1 LP share")
            }
            PlasmaError::BelowMinimumWithdrawaRequired {
                quote_amount_to_withdraw,
                base_amount_to_withdraw,
            } => write!(
                f,
                "Must withdraw at least 1 base token (actual: {} base) and 1 quote token (actual: {} quote)",
                base_amount_to_withdraw, quote_amount_to_withdraw
            ),
            PlasmaError::VestingPeriodNotOver => write!(f, "Previous vesting period not over"),
            PlasmaError::IncorrectProtocolFeeRecipient => {
                write!(
                    f,
                    "Given protocol fee recipient is not one of the protocol fee recipients"
                )
            }
            PlasmaError::TooManyShares => write!(f, "Too many shares supplied"),
            PlasmaError::SwapExactOutTooLarge => write!(f, "SwapExactOut amount too large"),
            PlasmaError::SwapExactInTooLarge => write!(f, "SwapExactIn amount too large"),
            PlasmaError::SwapOutputGreaterThanOrEqualToReserves(input, reserves) => {
                write!(
                    f,
                    "Swap output {} is greater than or equal to reserves {}",
                    input, reserves
                )
            }
        }
    }
}