/
validation.go
142 lines (120 loc) · 4.73 KB
/
validation.go
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
136
137
138
139
140
141
142
package types
import (
fmt "fmt"
"strings"
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
)
// ValidateInput verifies whether the given input is legal
func ValidateInput(input Input) error {
if !(input.Coin.IsValid() && input.Coin.IsPositive()) {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "invalid input (%s)", input.Coin.String())
}
if strings.HasPrefix(input.Coin.Denom, LptTokenPrefix) {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid input denom, should not begin with (%s)", LptTokenPrefix)
}
if _, err := sdk.AccAddressFromBech32(input.Address); err != nil {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid input address (%s)", err)
}
return nil
}
// ValidateOutput verifies whether the given output is legal
func ValidateOutput(output Output) error {
if !(output.Coin.IsValid() && output.Coin.IsPositive()) {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "invalid output (%s)", output.Coin.String())
}
if strings.HasPrefix(output.Coin.Denom, LptTokenPrefix) {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid output denom, should not begin with (%s)", LptTokenPrefix)
}
if _, err := sdk.AccAddressFromBech32(output.Address); err != nil {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid output address (%s)", err)
}
return nil
}
// ValidateDeadline verifies whether the given deadline is legal
func ValidateDeadline(deadline int64) error {
if deadline <= 0 {
return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, fmt.Sprintf("deadline %d must be greater than 0", deadline))
}
return nil
}
// ValidateMaxToken verifies whether the maximum token is legal
func ValidateMaxToken(maxToken sdk.Coin) error {
if !(maxToken.IsValid() && maxToken.IsPositive()) {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "invalid maxToken (%s)", maxToken.String())
}
if strings.HasPrefix(maxToken.Denom, LptTokenPrefix) {
return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "max token must be non-liquidity token")
}
return nil
}
// ValidateToken verifies whether the exact token is legal
func ValidateToken(exactToken sdk.Coin) error {
if !(exactToken.IsValid() && exactToken.IsPositive()) {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "invalid exactToken (%s)", exactToken.String())
}
if strings.HasPrefix(exactToken.Denom, LptTokenPrefix) {
return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "token must be non-liquidity token")
}
return nil
}
// ValidateCounterpartyDenom verifies whether the counterparty denom is legal
func ValidateCounterpartyDenom(counterpartydenom string) error {
if counterpartydenom == "" {
return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "counterparty denom should not be empty")
}
return nil
}
// ValidateExactStandardAmt verifies whether the standard token amount is legal
func ValidateExactStandardAmt(standardAmt sdkmath.Int) error {
if !standardAmt.IsPositive() {
return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "standard token amount must be positive")
}
return nil
}
// ValidateLiquidity verifies whether the minimum liquidity is legal
func ValidateLiquidity(minLiquidity sdkmath.Int) error {
if minLiquidity.IsNegative() {
return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "liquidity can not be negative")
}
return nil
}
// ValidateMinToken verifies whether the minimum token amount is legal
func ValidateMinToken(minToken sdkmath.Int) error {
if minToken.IsNegative() {
return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "minimum token amount can not be negative")
}
return nil
}
// ValidateWithdrawLiquidity verifies whether the given liquidity is legal
func ValidateWithdrawLiquidity(liquidity sdk.Coin) error {
if !liquidity.IsValid() || !liquidity.IsPositive() {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "invalid withdrawLiquidity (%s)", liquidity.String())
}
if err := ValidateLptDenom(liquidity.Denom); err != nil {
return err
}
return nil
}
// ValidateMinStandardAmt verifies whether the minimum standard amount is legal
func ValidateMinStandardAmt(minStandardAmt sdkmath.Int) error {
if minStandardAmt.IsNegative() {
return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, fmt.Sprintf("minimum standard token amount %s can not be negative", minStandardAmt.String()))
}
return nil
}
// ValidateLptDenom returns nil if the Liquidity pool token denom is valid
func ValidateLptDenom(lptDenom string) error {
if _, err := ParseLptDenom(lptDenom); err != nil {
return sdkerrors.Wrap(ErrInvalidDenom, lptDenom)
}
return nil
}
// ValidatePoolSequenceId returns nil if the pool id is valid
func ValidatePoolSequenceId(poolId uint64) error {
if poolId == 0 {
return sdkerrors.Wrap(ErrReservePoolNotExists, "pool-id is not valid")
}
return nil
}