-
Notifications
You must be signed in to change notification settings - Fork 28
/
validation.go
143 lines (121 loc) · 4.76 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
143
package types
import (
fmt "fmt"
"strings"
errorsmod "cosmossdk.io/errors"
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 errorsmod.Wrapf(sdkerrors.ErrInvalidCoins, "invalid input (%s)", input.Coin.String())
}
if strings.HasPrefix(input.Coin.Denom, LptTokenPrefix) {
return errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "invalid input denom, should not begin with (%s)", LptTokenPrefix)
}
if _, err := sdk.AccAddressFromBech32(input.Address); err != nil {
return errorsmod.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 errorsmod.Wrapf(sdkerrors.ErrInvalidCoins, "invalid output (%s)", output.Coin.String())
}
if strings.HasPrefix(output.Coin.Denom, LptTokenPrefix) {
return errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "invalid output denom, should not begin with (%s)", LptTokenPrefix)
}
if _, err := sdk.AccAddressFromBech32(output.Address); err != nil {
return errorsmod.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 errorsmod.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 errorsmod.Wrapf(sdkerrors.ErrInvalidCoins, "invalid maxToken (%s)", maxToken.String())
}
if strings.HasPrefix(maxToken.Denom, LptTokenPrefix) {
return errorsmod.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 errorsmod.Wrapf(sdkerrors.ErrInvalidCoins, "invalid exactToken (%s)", exactToken.String())
}
if strings.HasPrefix(exactToken.Denom, LptTokenPrefix) {
return errorsmod.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 errorsmod.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 errorsmod.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 errorsmod.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 errorsmod.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 errorsmod.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 errorsmod.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 errorsmod.Wrap(ErrInvalidDenom, lptDenom)
}
return nil
}
// ValidatePoolSequenceId returns nil if the pool id is valid
func ValidatePoolSequenceId(poolId uint64) error {
if poolId == 0 {
return errorsmod.Wrap(ErrReservePoolNotExists, "pool-id is not valid")
}
return nil
}