dexter-stable-pool 1.1.1

A Dexter DEX pool implementing the stableswap and metastable AMM models
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use crate::math::{MAX_AMP, MAX_AMP_CHANGE, MIN_AMP_CHANGING_TIME};
use cosmwasm_std::{
    CheckedMultiplyRatioError, ConversionOverflowError, Decimal, OverflowError, StdError, CheckedFromRatioError,
};
use thiserror::Error;

/// ## Description
/// This enum describes pair contract errors!
#[derive(Error, Debug, PartialEq)]
pub enum ContractError {
    #[error("{0}")]
    Std(#[from] StdError),

    #[error("{0}")]
    CheckedMultiplyRatioError(#[from] CheckedMultiplyRatioError),

    #[error("Unauthorized")]
    Unauthorized {},

    #[error("Repeated assets in asset infos")]
    RepeatedAssets {},

    #[error("LP token already set")]
    LpTokenAlreadySet {},

    #[error(
        "Invalid number of assets. This pool type supports at least 2 and at most 5 assets within a stable pool"
    )]
    InvalidNumberOfAssets {},

    #[error("Prices update for twap failed")]
    PricesUpdateFailed {},

    #[error("Operation non supported")]
    NonSupported {},

    #[error("Event of zero transfer")]
    InvalidZeroAmount {},

    #[error("Operation exceeds max spread limit. Current spread = {spread_amount}")]
    MaxSpreadAssertion { spread_amount: Decimal },

    #[error("Provided spread amount exceeds allowed limit")]
    AllowedSpreadAssertion {},

    #[error("Operation exceeds max splippage tolerance")]
    MaxSlippageAssertion {},

    #[error("Doubling assets in asset infos")]
    DoublingAssets {},

    #[error("Asset mismatch between the requested and stored in contract")]
    AssetMismatch {},

    #[error("Pair type mismatch. Check factory pair configs")]
    PoolTypeMismatch {},

    #[error(
        "Amp coefficient must be greater than 0 and less than or equal to {}",
        MAX_AMP
    )]
    IncorrectAmp {},

    #[error(
        "The difference between the old and new amp value must not exceed {} times",
        MAX_AMP_CHANGE
    )]
    MaxAmpChangeAssertion {},

    #[error(
        "Amp coefficient cannot be changed more often than once per {} seconds",
        MIN_AMP_CHANGING_TIME
    )]
    MinAmpChangingTimeAssertion {},

    #[error("The asset {0} does not belong to the pair")]
    InvalidAsset(String),

    #[error("The greatest token precision must be less than or equal to 18")]
    InvalidGreatestPrecision,

    #[error("This pool doesn't support scaling factors or manager update")]
    ScalingFactorUpdateNotSupported,

    #[error("Unsupport asset")]
    UnsupportedAsset,

    #[error("Invalid scaling factor. Scaling factor should be postive non-zero value")]
    InvalidScalingFactor,

    #[error("Invalid scaling factor asset infos. Scaling factor asset infos should be a subset of the pool asset infos")]
    InvalidScalingFactorAssetInfo,

    #[error("Scaling factor manager must be specified")]
    ScalingFactorManagerNotSpecified,

    #[error("Scaling factor manager shouldn't be specified if scaling factor is not updatable")]
    ScalingFactorManagerSpecified,

    #[error("Invalid max allowed spread. Max allowed spread should be positive non-zero value less than 1")]
    InvalidMaxAllowedSpread,
    
    #[error("Duplicate asset info in scaling factors")]
    DuplicateAssetInfoInScalingFactors,

    #[error("Invalid contract version for upgrade. Expected version: {expected_version} Found: {current_version}")]
    InvalidContractVersion { 
        current_version: String,
        expected_version: String,
    },

    #[error("Invalid contract name for upgrade. Expected name: {expected_name} Found: {contract_name}")]
    InvalidContractName { 
        contract_name: String,
        expected_name: String,
    },
}

impl From<OverflowError> for ContractError {
    fn from(o: OverflowError) -> Self {
        StdError::from(o).into()
    }
}

impl From<ConversionOverflowError> for ContractError {
    fn from(o: ConversionOverflowError) -> Self {
        StdError::from(o).into()
    }
}

impl From<CheckedFromRatioError> for ContractError {
    fn from(o: CheckedFromRatioError) -> Self {
        StdError::generic_err(o.to_string()).into()
    }
}