tx · DhKW8r5JZ2sYUvutKRrUo9kB13yuFYcxDrGgP5YaWq9N

3Mrnje6z2xa3xuXyU2Lk6ynKy8tsRnnt4Bv:  -0.01400000 Waves

2021.12.30 03:42 [1856247] smart account 3Mrnje6z2xa3xuXyU2Lk6ynKy8tsRnnt4Bv > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DhKW8r5JZ2sYUvutKRrUo9kB13yuFYcxDrGgP5YaWq9N",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1640824916440,
    "version": 2,
    "chainId": 84,
    "sender": "3Mrnje6z2xa3xuXyU2Lk6ynKy8tsRnnt4Bv",
    "senderPublicKey": "28sGn7FYnmxceAmnGYiDiKuMK1QyXiqX8zQXfKDnrc8t",
    "proofs": [
        "3MUrqXC8m8JYtbmK5na2jFTqjNnGjxa35T8FQpUYzSut3ypiVEWWWCb1vfqguvoLCdq9Aksf98Xo9iXXfsV17dGT"
    ],
    "script": "base64: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",
    "height": 1856247,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: Ca7KtkLxtbwNP2y3Xgc51g9E4oKbuhL4Ekd5YxDPtcer
Next: CdwF3wcsvdW7hoDPoqVZJUFLJK2zvDdeEDmi6mMLMKsV

Diff: 
Old
New
Differences
174
174
 
    let decimals = info.decimals
175
175
 
    let NewVotingStatus = "P"
176
176
 
    let VotingStatus = valueOrErrorMessage(getString(this, ("Voting_Status_" + EnterAssetID)), ("Voting Status is Missing for " + EnterAssetID))
177
-
    let LPissue = Issue((("LP-" + name) + "-USDT"), (((("LP-" + name) + "-USDT") + " is a Liquidity Provider Token Issued Against ") + EnterAssetID), (1 * pow(10, 0, fraction((decimals + 6), 1, 2), 0, 0, UP)), fraction((decimals + 6), 1, 2), true)
177
+
    let LPissue = Issue((("LP-" + take(name, 8)) + "-USDT"), (((("LP-" + name) + "-USDT") + " is a Liquidity Provider Token Issued Against ") + EnterAssetID), (1 * pow(10, 0, fraction((decimals + 6), 1, 2), 0, 0, UP)), fraction((decimals + 6), 1, 2), true)
178
178
 
    let LPid = calculateAssetId(LPissue)
179
179
 
    if ((adminrights != calleraddress))
180
180
 
        then throw((("Your are not allowded to Issue LP Token. Only " + adminrights) + " can issue the LP Token."))
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 4 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let USDTAssetID = base58'Zn3cLHW7aAVPm5aACcTjvg7e7iEy2cKDtbowok5qa9H'
5
5
 
6
6
 
let BalletAssetID = base58'44Mq8KqUhM94t93MiBq3S22iiuGczMxpKmse5dBy2w5y'
7
7
 
8
8
 
let CollectBalletFeeAddress = addressFromPublicKey(base58'GKmJ6BchUgQfwKp4mp5eX8Y9xLioYRm6e1gDfFgdAcCr')
9
9
 
10
10
 
let IssueBalletFeeAddress = addressFromPublicKey(base58'GKmJ6BchUgQfwKp4mp5eX8Y9xLioYRm6e1gDfFgdAcCr')
11
11
 
12
12
 
let CollectUSDTSwapFeeAddress = addressFromPublicKey(base58'GKmJ6BchUgQfwKp4mp5eX8Y9xLioYRm6e1gDfFgdAcCr')
13
13
 
14
14
 
let CollectAssetSwapFeeAddress = addressFromPublicKey(base58'GKmJ6BchUgQfwKp4mp5eX8Y9xLioYRm6e1gDfFgdAcCr')
15
15
 
16
16
 
@Callable(i)
17
17
 
func IssueBallet () = {
18
18
 
    let pmt = value(i.payments[0])
19
19
 
    let currentKey = toBase58String(i.caller.bytes)
20
20
 
    let PricePerBallet = getIntegerValue(this, "BALLET/TN")
21
21
 
    let NewBalletToUser = fraction(100000, pmt.amount, PricePerBallet)
22
22
 
    let PreviousIssuedBallet = getIntegerValue(this, "Total_Issued_Ballet:")
23
23
 
    let TotalIssuedBallet = (PreviousIssuedBallet + NewBalletToUser)
24
24
 
    let PreviousBalletReserveValue = getIntegerValue(this, "Total_Ballet_Reserve_In_TN:")
25
25
 
    let BalletReserveValue = (PreviousBalletReserveValue + pmt.amount)
26
26
 
    let PreviousBalletBackupPrice = getIntegerValue(this, "Ballet_Backup_Value_In_TN:")
27
27
 
    let BalletBackupPrice = fraction(100000, BalletReserveValue, TotalIssuedBallet)
28
28
 
    let FeePercentage = 1
29
29
 
    let BalanceTokensReturnedToUser = (100 - FeePercentage)
30
30
 
    if (isDefined(pmt.assetId))
31
31
 
        then throw("Incorrect asset attached, please attach TN.")
32
32
 
        else if ((5000000 > pmt.amount))
33
33
 
            then throw("Please Attach minimum 0.05 TN To Issue Ballet Asset.")
34
34
 
            else [IntegerEntry("Total_Issued_Ballet:", TotalIssuedBallet), IntegerEntry("Total_Ballet_Reserve_In_TN:", BalletReserveValue), IntegerEntry("Ballet_Backup_Value_In_TN:", BalletBackupPrice), StringEntry("message", "<h1>Ballet Issued Successfully!</h1><br>"), Reissue(BalletAssetID, NewBalletToUser, true), ScriptTransfer(i.caller, ((NewBalletToUser * BalanceTokensReturnedToUser) / 100), BalletAssetID), ScriptTransfer(IssueBalletFeeAddress, ((NewBalletToUser * FeePercentage) / 100), BalletAssetID)]
35
35
 
    }
36
36
 
37
37
 
38
38
 
39
39
 
@Callable(i)
40
40
 
func Liquidate () = {
41
41
 
    let currentKey = toBase58String(i.callerPublicKey)
42
42
 
    let pmt = value(i.payments[0])
43
43
 
    let PreviousIssuedBallet = getIntegerValue(this, "Total_Issued_Ballet:")
44
44
 
    let TotalIssuedBallet = (PreviousIssuedBallet - pmt.amount)
45
45
 
    let PreviousBalletReserveValue = getIntegerValue(this, "Total_Ballet_Reserve_In_TN:")
46
46
 
    let PreviousBalletBackupPrice = getIntegerValue(this, "Ballet_Backup_Value_In_TN:")
47
47
 
    let calculateburnvalue = fraction(PreviousBalletBackupPrice, pmt.amount, 100000)
48
48
 
    let BalletReserveValue = (PreviousBalletReserveValue - calculateburnvalue)
49
49
 
    let BalletBackupPrice = fraction(100000, BalletReserveValue, TotalIssuedBallet)
50
50
 
    if ((pmt.assetId != BalletAssetID))
51
51
 
        then throw("Kindly Deposit Only 44Mq8KqUhM94t93MiBq3S22iiuGczMxpKmse5dBy2w5y (Ballet).")
52
52
 
        else if ((100000 > pmt.amount))
53
53
 
            then throw("Attach Amount must be greater than 0.001 Ballet.")
54
54
 
            else [Burn(BalletAssetID, pmt.amount), IntegerEntry("Total_Issued_Ballet:", TotalIssuedBallet), IntegerEntry("Total_Ballet_Reserve_In_TN:", BalletReserveValue), IntegerEntry("Ballet_Backup_Value_In_TN:", BalletBackupPrice), StringEntry("message", "<h1>Ballet Liquidated Successfully!</h1><br>"), ScriptTransfer(i.caller, calculateburnvalue, unit)]
55
55
 
    }
56
56
 
57
57
 
58
58
 
59
59
 
@Callable(i)
60
60
 
func RegisterPairForVoting (EnterAssetID,days) = {
61
61
 
    let pmt1 = value(i.payments[0])
62
62
 
    let pmt2 = value(i.payments[1])
63
63
 
    let maximumvotingdays = 90
64
64
 
    let currentKey = toBase58String(i.caller.bytes)
65
65
 
    let TN = !(isDefined(pmt2.assetId))
66
66
 
    let oneday = 1440
67
67
 
    let NoOfDaysBlocks = (oneday * days)
68
68
 
    let gap = (NoOfDaysBlocks - 43199)
69
69
 
    let votesrequired = ((100000 + ((11574 * gap) / 10000)) * 100000000)
70
70
 
    let votingExpire = (height + NoOfDaysBlocks)
71
71
 
    let fetchpair = getString(this, ("Pair_UV_" + EnterAssetID))
72
72
 
    let votingstatus = "F"
73
73
 
    let assetinfopmt2 = fromBase58String(EnterAssetID)
74
74
 
    if ((43 > size(EnterAssetID)))
75
75
 
        then throw("Wrong AssetID is Entered for Voting. Please Enter a Valid AssetID. Probably you entered an AssetID less than 43 Chars.")
76
76
 
        else if ((29 >= days))
77
77
 
            then throw("Enter no. of days in between 30 to 90.")
78
78
 
            else if ((days > maximumvotingdays))
79
79
 
                then throw("You Entered days greater than 90 please Enter no. of days in between 1 to 90.")
80
80
 
                else if ((fetchpair == EnterAssetID))
81
81
 
                    then throw("Pair Already Exist in Voting List.")
82
82
 
                    else if ((size(i.payments) != 2))
83
83
 
                        then throw("Two attached assets expected as payment. Kindly Attach payment1 = Ballet Token & payment2 = Token you want to List for Voting.")
84
84
 
                        else if ((pmt1.assetId != BalletAssetID))
85
85
 
                            then throw("Incorrect asset attached for Voting in payment[1], please attach 1000 Ballet Token only.")
86
86
 
                            else if ((pmt1.amount != 10000000))
87
87
 
                                then throw((((("You attached only " + toString(fraction(pmt1.amount, 1, 100000000))) + ".") + toString(fraction(pmt1.amount, 1, 10000000))) + " Ballet for Voting in payment[1], please attach 1000 Ballet Token only."))
88
88
 
                                else if ((pmt2.assetId != assetinfopmt2))
89
89
 
                                    then throw("Input String & Attached AssetID in payment2 is not matching.")
90
90
 
                                    else if ((TN == true))
91
91
 
                                        then throw("You Attached TN Asset ID for Voting, please attach the Token You want to list in payment[2].")
92
92
 
                                        else if ((pmt2.assetId == BalletAssetID))
93
93
 
                                            then throw("You Attached Ballet asset for Voting in both payments, please attach the Token You want to list in payment[2].")
94
94
 
                                            else [StringEntry(("Pair_UV_" + EnterAssetID), EnterAssetID), StringEntry(("Voting_Status_" + EnterAssetID), votingstatus), IntegerEntry(("Voting_SH_" + EnterAssetID), height), IntegerEntry(("Voting_EH_" + EnterAssetID), votingExpire), IntegerEntry(("Voting_Period_" + EnterAssetID), NoOfDaysBlocks), IntegerEntry(("Listing_Fee_" + EnterAssetID), pmt1.amount), IntegerEntry(("Votes_Req_" + EnterAssetID), votesrequired), IntegerEntry(("Votes_Rcvd_" + EnterAssetID), 0), ScriptTransfer(CollectBalletFeeAddress, pmt1.amount, BalletAssetID)]
95
95
 
    }
96
96
 
97
97
 
98
98
 
99
99
 
@Callable(i)
100
100
 
func DoVoting (EnterAssetID) = {
101
101
 
    let pmt = if ((size(i.payments) == 1))
102
102
 
        then i.payments[0]
103
103
 
        else throw("Ballet Token is required as Attached payment")
104
104
 
    let calleraddress = toBase58String(i.caller.bytes)
105
105
 
    let NewVotingStatus = "P"
106
106
 
    let checkendheight = getIntegerValue(this, ("Voting_EH_" + EnterAssetID))
107
107
 
    let checkpairisavailableornot = getString(this, ("Pair_UV_" + EnterAssetID))
108
108
 
    let checkvotesrequired = getIntegerValue(this, ("Votes_Req_" + EnterAssetID))
109
109
 
    let checkvotesreceived = getIntegerValue(this, ("Votes_Rcvd_" + EnterAssetID))
110
110
 
    let VotingStatus = getStringValue(this, ("Voting_Status_" + EnterAssetID))
111
111
 
    let currentvotes =     match getInteger(this, ("Votes_Rcvd_" + EnterAssetID)) {
112
112
 
        case a: Int => 
113
113
 
            a
114
114
 
        case _ => 
115
115
 
            0
116
116
 
    }
117
117
 
    let newvotescount = (currentvotes + pmt.amount)
118
118
 
    let individualvotes =     match getInteger(this, ((("Votes_Rcvd_" + calleraddress) + "_") + EnterAssetID)) {
119
119
 
        case b: Int => 
120
120
 
            b
121
121
 
        case _ => 
122
122
 
            0
123
123
 
    }
124
124
 
    let individualvotescount = (individualvotes + pmt.amount)
125
125
 
    let checkwhitelist = (checkvotesreceived >= checkvotesrequired)
126
126
 
    let info = valueOrErrorMessage(assetInfo(fromBase58String(EnterAssetID)), (("Asset " + EnterAssetID) + " doesn't exist"))
127
127
 
    if ((checkpairisavailableornot != EnterAssetID))
128
128
 
        then throw("Pair is not available in Voting List.")
129
129
 
        else if ((height > checkendheight))
130
130
 
            then throw((("Voting timeline for " + EnterAssetID) + " is expired."))
131
131
 
            else if ((pmt.assetId != BalletAssetID))
132
132
 
                then throw((("Kindly Attach Only " + toBase58String(BalletAssetID)) + " Token."))
133
133
 
                else if ((VotingStatus == NewVotingStatus))
134
134
 
                    then throw((("Voting for " + EnterAssetID) + " pair is completed & it’s available in whitelist."))
135
135
 
                    else if (checkwhitelist)
136
136
 
                        then [StringEntry(("Voting_Status_" + EnterAssetID), NewVotingStatus), IntegerEntry(((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)), 0), IntegerEntry(((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID), 0), IntegerEntry(("Total_of_Pair_Txns_" + EnterAssetID), 0), IntegerEntry(((("Total_Swap_Fee_Collected_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)), 0), IntegerEntry(("Total_Swap_Fee_Collected_" + EnterAssetID), 0), IntegerEntry(((("Votes_Rcvd_" + calleraddress) + "_") + EnterAssetID), individualvotescount)]
137
137
 
                        else [IntegerEntry(("Votes_Rcvd_" + EnterAssetID), newvotescount), IntegerEntry(((("Votes_Rcvd_" + calleraddress) + "_") + EnterAssetID), individualvotescount)]
138
138
 
    }
139
139
 
140
140
 
141
141
 
142
142
 
@Callable(i)
143
143
 
func WithdrawVotedTokens (EnterAssetID) = {
144
144
 
    let pmt = if ((size(i.payments) == 1))
145
145
 
        then i.payments[0]
146
146
 
        else throw("0.1 TN Token is required as Attached payment.")
147
147
 
    let calleraddress = toBase58String(i.caller.bytes)
148
148
 
    let checkendheight = getIntegerValue(this, ("Voting_EH_" + EnterAssetID))
149
149
 
    let checkpairisavailableornot = getString(this, ("Pair_UV_" + EnterAssetID))
150
150
 
    let checkuservotingbalance = valueOrErrorMessage(getInteger(this, ((("Votes_Rcvd_" + calleraddress) + "_") + EnterAssetID)), (calleraddress + " Address never voted & exist in list."))
151
151
 
    let pendingblocksforprojectexpire = (checkendheight - height)
152
152
 
    if ((checkpairisavailableornot != EnterAssetID))
153
153
 
        then throw("Pair is not available in Voting List.")
154
154
 
        else if ((checkendheight > height))
155
155
 
            then throw((("Voting Already Running. You can withdraw your Ballet Token after " + toString(pendingblocksforprojectexpire)) + " blocks"))
156
156
 
            else if ((0 >= checkuservotingbalance))
157
157
 
                then throw("You don't have any dues of ballet balance in this Voting Pair.")
158
158
 
                else if (isDefined(pmt.assetId))
159
159
 
                    then throw("Don't attach any other asset. Please attach 0.1 TN as a fee to release your token")
160
160
 
                    else if ((pmt.amount != 10000000))
161
161
 
                        then throw("Please attach 0.1 TN as a fee to release your token.")
162
162
 
                        else [IntegerEntry(((("Votes_Rcvd_" + calleraddress) + "_") + EnterAssetID), 0), ScriptTransfer(i.caller, checkuservotingbalance, BalletAssetID)]
163
163
 
    }
164
164
 
165
165
 
166
166
 
167
167
 
@Callable(i)
168
168
 
func IssueLPToken (EnterAssetID) = {
169
169
 
    let adminrights = valueOrErrorMessage(getString(this, "LP_Admin_Rights"), "LP Admin Rights are Not Included into Smart Contract. Deploy Admin Rights First.")
170
170
 
    let calleraddress = toBase58String(i.caller.bytes)
171
171
 
    let checkpairisavailableornot = valueOrErrorMessage(getString(this, ("Pair_UV_" + EnterAssetID)), "Asset not Found in Whitelisted Token")
172
172
 
    let info = valueOrErrorMessage(assetInfo(fromBase58String(EnterAssetID)), (("Asset " + EnterAssetID) + " doesn't exist"))
173
173
 
    let name = info.name
174
174
 
    let decimals = info.decimals
175
175
 
    let NewVotingStatus = "P"
176
176
 
    let VotingStatus = valueOrErrorMessage(getString(this, ("Voting_Status_" + EnterAssetID)), ("Voting Status is Missing for " + EnterAssetID))
177
-
    let LPissue = Issue((("LP-" + name) + "-USDT"), (((("LP-" + name) + "-USDT") + " is a Liquidity Provider Token Issued Against ") + EnterAssetID), (1 * pow(10, 0, fraction((decimals + 6), 1, 2), 0, 0, UP)), fraction((decimals + 6), 1, 2), true)
177
+
    let LPissue = Issue((("LP-" + take(name, 8)) + "-USDT"), (((("LP-" + name) + "-USDT") + " is a Liquidity Provider Token Issued Against ") + EnterAssetID), (1 * pow(10, 0, fraction((decimals + 6), 1, 2), 0, 0, UP)), fraction((decimals + 6), 1, 2), true)
178
178
 
    let LPid = calculateAssetId(LPissue)
179
179
 
    if ((adminrights != calleraddress))
180
180
 
        then throw((("Your are not allowded to Issue LP Token. Only " + adminrights) + " can issue the LP Token."))
181
181
 
        else if ((checkpairisavailableornot != EnterAssetID))
182
182
 
            then throw("Pair is not available in Voting List.")
183
183
 
            else if ((VotingStatus != NewVotingStatus))
184
184
 
                then throw("LP Token must be a Whitelisted Token.")
185
185
 
                else if ((("LP_" + EnterAssetID) == getString(this, ("LP_" + EnterAssetID))))
186
186
 
                    then throw(("LP Token Already Issued for " + EnterAssetID))
187
187
 
                    else [LPissue, StringEntry(("LP_" + EnterAssetID), toBase58String(LPid))]
188
188
 
    }
189
189
 
190
190
 
191
191
 
192
192
 
@Callable(i)
193
193
 
func SwapAssetToUSDTPairEntry (EnterAssetID) = {
194
194
 
    let calleraddress = toBase58String(i.caller.bytes)
195
195
 
    let pmt = if ((size(i.payments) == 1))
196
196
 
        then i.payments[0]
197
197
 
        else throw("Whitelisted Token is required as Attached payment[1].")
198
198
 
    let checkpairisavailableornot = getString(this, ("Pair_UV_" + EnterAssetID))
199
199
 
    let VotingStatus = getStringValue(this, ("Voting_Status_" + EnterAssetID))
200
200
 
    let CheckUSDTBalance = getIntegerValue(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)))
201
201
 
    let CheckAssetBalance = getIntegerValue(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID))
202
202
 
    let newbalanceofUSDT = fraction(CheckUSDTBalance, CheckAssetBalance, (CheckAssetBalance + pmt.amount))
203
203
 
    let quantityofpriceasset = (CheckUSDTBalance - newbalanceofUSDT)
204
204
 
    let CurrentVotingStatus = "F"
205
205
 
    let SwapFee = 3
206
206
 
    let SwapFeetoreceive = ((quantityofpriceasset * SwapFee) / 1000)
207
207
 
    let userbalancetoreceive = (quantityofpriceasset - SwapFeetoreceive)
208
208
 
    let SumupofAssetToUSDTSwapFee =     match getInteger(this, ((("Total_Swap_Fee_Collected_" + EnterAssetID) + "_") + toBase58String(USDTAssetID))) {
209
209
 
        case a: Int => 
210
210
 
            a
211
211
 
        case _ => 
212
212
 
            0
213
213
 
    }
214
214
 
    let NewSumupofAssetToUSDTSwapFee = (SumupofAssetToUSDTSwapFee + SwapFeetoreceive)
215
215
 
    let SumupAssetBalance =     match getInteger(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID)) {
216
216
 
        case a: Int => 
217
217
 
            a
218
218
 
        case _ => 
219
219
 
            0
220
220
 
    }
221
221
 
    let NewSumupofAssetBalance = (CheckAssetBalance + pmt.amount)
222
222
 
    let SumupUSDTBalance =     match getInteger(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID))) {
223
223
 
        case a: Int => 
224
224
 
            a
225
225
 
        case _ => 
226
226
 
            0
227
227
 
    }
228
228
 
    let NewSumupofUSDTBalance = (CheckUSDTBalance - quantityofpriceasset)
229
229
 
    let TOPT =     match getIntegerValue(this, ("Total_of_Pair_Txns_" + EnterAssetID)) {
230
230
 
        case a: Int => 
231
231
 
            a
232
232
 
        case _ => 
233
233
 
            0
234
234
 
    }
235
235
 
    let NewTPT = (TOPT + 1)
236
236
 
    if ((EnterAssetID == toBase58String(USDTAssetID)))
237
237
 
        then throw("Input can Never be a USDT AssetID. Enter Whitelisted AssetID in input & Attach Whitelisted Asset as an attachment Token in payment[1].")
238
238
 
        else if ((checkpairisavailableornot != EnterAssetID))
239
239
 
            then throw("Pair is not available in Whitelisted Asset.")
240
240
 
            else if ((VotingStatus == CurrentVotingStatus))
241
241
 
                then throw((EnterAssetID + " is not A Whitelisted Token Yet."))
242
242
 
                else if ((pmt.assetId == USDTAssetID))
243
243
 
                    then throw("You can't Attach USDT as an Attached Payment. Only Whitelisted Tokens are accepted.")
244
244
 
                    else if ((pmt.assetId != fromBase58String(EnterAssetID)))
245
245
 
                        then throw(("Incorrect asset attached, please attach or send " + EnterAssetID))
246
246
 
                        else if ((CheckUSDTBalance == 0))
247
247
 
                            then throw("Swap Pair Need to Add Liquidity first into Pool. Only After that Pair will be activated for Swapping.")
248
248
 
                            else if ((CheckAssetBalance == 0))
249
249
 
                                then throw("Swap Pair Need to Add Liquidity first into Pool. Only After that Pair will be activated for Swapping.")
250
250
 
                                else if ((10000000 > quantityofpriceasset))
251
251
 
                                    then throw((("Your Attached Asset Amount is very low. Attach More " + EnterAssetID) + " Tokens to Claim the minimum Amount of 10 dollar atleast."))
252
252
 
                                    else if ((quantityofpriceasset > CheckUSDTBalance))
253
253
 
                                        then throw((("Pool Only has a Liquidity of " + toString((CheckUSDTBalance / pow(10, 0, 6, 0, 0, UP)))) + " USDT. Add Liquidity into Pool."))
254
254
 
                                        else [IntegerEntry(((("Total_Swap_Fee_Collected_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)), NewSumupofAssetToUSDTSwapFee), IntegerEntry(("Total_of_Pair_Txns_" + EnterAssetID), NewTPT), IntegerEntry(((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID), NewSumupofAssetBalance), IntegerEntry(((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)), NewSumupofUSDTBalance), ScriptTransfer(i.caller, userbalancetoreceive, USDTAssetID), ScriptTransfer(CollectUSDTSwapFeeAddress, SwapFeetoreceive, USDTAssetID)]
255
255
 
    }
256
256
 
257
257
 
258
258
 
259
259
 
@Callable(i)
260
260
 
func SwapUSDTToAssetPairEntry (EnterAssetID) = {
261
261
 
    let calleraddress = toBase58String(i.caller.bytes)
262
262
 
    let pmt = if ((size(i.payments) == 1))
263
263
 
        then i.payments[0]
264
264
 
        else throw("Only USDT Token is required as an Attached payment[1].")
265
265
 
    let CheckUSDTBalance = getIntegerValue(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)))
266
266
 
    let CheckAssetBalance = getIntegerValue(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID))
267
267
 
    let newbalanceofAsset = fraction(CheckUSDTBalance, CheckAssetBalance, (CheckUSDTBalance + pmt.amount))
268
268
 
    let quantityofpriceasset = (CheckAssetBalance - newbalanceofAsset)
269
269
 
    let checkpairisavailableornot = getString(this, ("Pair_UV_" + EnterAssetID))
270
270
 
    let VotingStatus = getStringValue(this, ("Voting_Status_" + EnterAssetID))
271
271
 
    let CurrentVotingStatus = "F"
272
272
 
    let SwapFee = 3
273
273
 
    let SwapFeetoreceive = ((quantityofpriceasset * SwapFee) / 1000)
274
274
 
    let userbalancetoreceive = (quantityofpriceasset - SwapFeetoreceive)
275
275
 
    let SumupofUSDTToAssetSwapFee =     match getInteger(this, ("Total_Swap_Fee_Collected_" + EnterAssetID)) {
276
276
 
        case a: Int => 
277
277
 
            a
278
278
 
        case _ => 
279
279
 
            0
280
280
 
    }
281
281
 
    let NewSumupofUSDTToAssetSwapFee = (SumupofUSDTToAssetSwapFee + SwapFeetoreceive)
282
282
 
    let SumupAssetBalance =     match getInteger(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID)) {
283
283
 
        case a: Int => 
284
284
 
            a
285
285
 
        case _ => 
286
286
 
            0
287
287
 
    }
288
288
 
    let NewSumupofAssetBalance = (CheckAssetBalance - quantityofpriceasset)
289
289
 
    let SumupUSDTBalance =     match getInteger(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID))) {
290
290
 
        case a: Int => 
291
291
 
            a
292
292
 
        case _ => 
293
293
 
            0
294
294
 
    }
295
295
 
    let NewSumupofUSDTBalance = (CheckUSDTBalance + pmt.amount)
296
296
 
    let TOPT =     match getIntegerValue(this, ("Total_of_Pair_Txns_" + EnterAssetID)) {
297
297
 
        case a: Int => 
298
298
 
            a
299
299
 
        case _ => 
300
300
 
            0
301
301
 
    }
302
302
 
    let NewTPT = (TOPT + 1)
303
303
 
    if ((checkpairisavailableornot != EnterAssetID))
304
304
 
        then throw("Pair is not available in Whitelisted Asset.")
305
305
 
        else if ((VotingStatus == CurrentVotingStatus))
306
306
 
            then throw((EnterAssetID + " is not A Whitelisted Token Yet."))
307
307
 
            else if ((EnterAssetID == toBase58String(USDTAssetID)))
308
308
 
                then throw("Input can Never be a USDT AssetID. Enter Whitelisted AssetID in input & Attach USDT as an attachment Token in payment[1].")
309
309
 
                else if ((pmt.assetId != USDTAssetID))
310
310
 
                    then throw("You can Attach USDT as an Attached Payment[1] to Swap USDT To Required Token. Any other asset else than USDT will be rejected.")
311
311
 
                    else if ((10000000 > pmt.amount))
312
312
 
                        then throw("Your Attached USDT Amount is very low. Attach Atleast 10 USDT to Claim the minimum Tokens.")
313
313
 
                        else if ((CheckUSDTBalance == 0))
314
314
 
                            then throw("Swap Pair Need to Add Liquidity first into Pool. Only After that Pair will be activated for Swapping.")
315
315
 
                            else if ((CheckAssetBalance == 0))
316
316
 
                                then throw("Swap Pair Need to Add Liquidity first into Pool. Only After that Pair will be activated for Swapping.")
317
317
 
                                else if ((quantityofpriceasset > CheckAssetBalance))
318
318
 
                                    then throw((("Pool Only has a Liquidity of " + toString(CheckAssetBalance)) + " Tokens. Add Liquidity into Pool."))
319
319
 
                                    else [IntegerEntry(("Total_Swap_Fee_Collected_" + EnterAssetID), NewSumupofUSDTToAssetSwapFee), IntegerEntry(("Total_of_Pair_Txns_" + EnterAssetID), NewTPT), IntegerEntry(((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID), NewSumupofAssetBalance), IntegerEntry(((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)), NewSumupofUSDTBalance), ScriptTransfer(i.caller, userbalancetoreceive, fromBase58String(EnterAssetID)), ScriptTransfer(CollectAssetSwapFeeAddress, SwapFeetoreceive, fromBase58String(EnterAssetID))]
320
320
 
    }
321
321
 
322
322
 
323
323
 
324
324
 
@Callable(i)
325
325
 
func AddLiquidity (EnterAssetID) = {
326
326
 
    let calleraddress = toBase58String(i.caller.bytes)
327
327
 
    let pmt1 = value(i.payments[0])
328
328
 
    let pmt2 = value(i.payments[1])
329
329
 
    let checkpairisavailableornot = getString(this, ("Pair_UV_" + EnterAssetID))
330
330
 
    let VotingStatus = getStringValue(this, ("Voting_Status_" + EnterAssetID))
331
331
 
    let ReissueassetId = fromBase58String(valueOrErrorMessage(getString(this, ("LP_" + EnterAssetID)), "LP Token is Missing or May be not Generated."))
332
332
 
    let CurrentVotingStatus = "F"
333
333
 
    let CheckUSDTBalance = getIntegerValue(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)))
334
334
 
    let CheckAssetBalance = getIntegerValue(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID))
335
335
 
    let decimalsinfo = valueOrErrorMessage(assetInfo(fromBase58String(EnterAssetID)), (("Asset " + EnterAssetID) + " doesn't exist"))
336
336
 
    let decimals = decimalsinfo.decimals
337
337
 
    let arg1 = pow((CheckUSDTBalance / pow(10, 6, 6, 0, 0, UP)), 0, 1, 0, 0, UP)
338
338
 
    let arg2 = pow((CheckAssetBalance / pow(10, decimals, decimals, 0, 0, UP)), 0, 1, 0, 0, UP)
339
339
 
    let args3 = pow((((arg1 * 1000000) / arg2) * pow(10, 0, decimals, 0, 0, UP)), 0, 1, 0, 0, UP)
340
340
 
    let bothassetsdecimals = (6 + decimals)
341
341
 
    let sharedecimals = (bothassetsdecimals / 2)
342
342
 
    let quantityofEnterAssetID = fraction(args3, pmt1.amount, pow(10, 0, bothassetsdecimals, 0, 0, UP))
343
343
 
    let quantityofLPToken1 = pow((fraction(pmt1.amount, 1, pow(10, 0, decimals, 0, 0, UP)) * fraction(pmt2.amount, 1, pow(10, 0, 6, 0, 0, UP))), 0, 5, 1, sharedecimals, DOWN)
344
344
 
    let USDTHoldingInPair =     match getInteger(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID))) {
345
345
 
        case a: Int => 
346
346
 
            a
347
347
 
        case _ => 
348
348
 
            0
349
349
 
    }
350
350
 
    let NewUSDTHoldingInPair = (USDTHoldingInPair + pmt2.amount)
351
351
 
    let AssetHoldingInPair =     match getInteger(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID)) {
352
352
 
        case a: Int => 
353
353
 
            a
354
354
 
        case _ => 
355
355
 
            0
356
356
 
    }
357
357
 
    let NewAssetHoldingInPair = (AssetHoldingInPair + pmt1.amount)
358
358
 
    let LPTokenIssued =     match getIntegerValue(this, ("Total_LP_" + EnterAssetID)) {
359
359
 
        case a: Int => 
360
360
 
            a
361
361
 
        case _ => 
362
362
 
            0
363
363
 
    }
364
364
 
    let NewLPTokenIssued = (LPTokenIssued + quantityofLPToken1)
365
365
 
    if ((checkpairisavailableornot != EnterAssetID))
366
366
 
        then throw("Pair is not available in Whitelisted Asset.")
367
367
 
        else if ((VotingStatus == CurrentVotingStatus))
368
368
 
            then throw((EnterAssetID + " is not A Whitelisted Token Yet."))
369
369
 
            else if ((EnterAssetID == toBase58String(USDTAssetID)))
370
370
 
                then throw("Input can Never be a USDT AssetID. Enter Whitelisted AssetID in input as well as in payment[1] & Attach USDT as an attachment Token in payment[2].")
371
371
 
                else if ((size(i.payments) != 2))
372
372
 
                    then throw("Two attached assets expected as payment in 50%-50%. Kindly Attach payment1 = Token you want to add for Liquidity & payment2 = Equivalent Amount of USDT Token.")
373
373
 
                    else if ((pmt1.assetId == USDTAssetID))
374
374
 
                        then throw("You Attached USDT asset in payment[1], please attach only whitelisted Token in payment[1] along with USDT in payment[2].")
375
375
 
                        else if ((pmt1.assetId != fromBase58String(EnterAssetID)))
376
376
 
                            then throw("Incorrect asset attached for Liquidity in payment[1], please attach String Asset or Whitelisted Token only.")
377
377
 
                            else if ((pmt1.assetId != fromBase58String(EnterAssetID)))
378
378
 
                                then throw("Incorrect asset attached for Liquidity in payment[1], please attach String Asset or Whitelisted Token only.")
379
379
 
                                else if ((pmt2.assetId != USDTAssetID))
380
380
 
                                    then throw("Wrong Asset Attached in payments[2], Please attach payment[1] = Liquidity Token & payment[2] = USDT Token.")
381
381
 
                                    else if ((10000000 > pmt2.amount))
382
382
 
                                        then throw("please attach atleast 10 USDT in payment[2] & Equivalent worth of Token in payment[1]")
383
383
 
                                        else if ((pmt2.amount != quantityofEnterAssetID))
384
384
 
                                            then throw(("Attached payment[2] quantity is not matching as per attached payment[1].payment[2] must be " + toString(quantityofEnterAssetID)))
385
385
 
                                            else [IntegerEntry(((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)), NewUSDTHoldingInPair), IntegerEntry(((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID), NewAssetHoldingInPair), IntegerEntry(("Total_LP_" + EnterAssetID), NewLPTokenIssued), Reissue(ReissueassetId, quantityofLPToken1, true), ScriptTransfer(i.caller, quantityofLPToken1, ReissueassetId)]
386
386
 
    }
387
387
 
388
388
 
389
389
 
390
390
 
@Callable(i)
391
391
 
func RemoveLiquidity (EnterAssetID) = {
392
392
 
    let calleraddress = toBase58String(i.caller.bytes)
393
393
 
    let pmt = if ((size(i.payments) == 1))
394
394
 
        then i.payments[0]
395
395
 
        else throw("No payment attached, Please Attach LP Token as payment[1].")
396
396
 
    let checkpairisavailableornot = getString(this, ("Pair_UV_" + EnterAssetID))
397
397
 
    let VotingStatus = getStringValue(this, ("Voting_Status_" + EnterAssetID))
398
398
 
    let ReissueableassetId = fromBase58String(valueOrErrorMessage(getString(this, ("LP_" + EnterAssetID)), "LP Token is Missing or not Generated."))
399
399
 
    let CurrentVotingStatus = "F"
400
400
 
    let CheckUSDTBalance = getIntegerValue(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)))
401
401
 
    let CheckAssetBalance = getIntegerValue(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID))
402
402
 
    let decimalsinfo = valueOrErrorMessage(assetInfo(fromBase58String(EnterAssetID)), (("Asset " + EnterAssetID) + " doesn't exist"))
403
403
 
    let decimals = decimalsinfo.decimals
404
404
 
    let arg1 = pow((CheckUSDTBalance / pow(10, 6, 6, 0, 0, UP)), 0, 1, 0, 0, UP)
405
405
 
    let arg2 = pow((CheckAssetBalance / pow(10, decimals, decimals, 0, 0, UP)), 0, 1, 0, 0, UP)
406
406
 
    let args3 = pow((((arg1 * 1000000) / arg2) * pow(10, 0, decimals, 0, 0, UP)), 0, 1, 0, 0, UP)
407
407
 
    let bothassetsdecimals = (6 + decimals)
408
408
 
    let sharedecimals = (bothassetsdecimals / 2)
409
409
 
    let SquareofAttachedPymt = fraction(pow(pmt.amount, sharedecimals, 2, 0, 6, HALFUP), 1, fraction(args3, 1, pow(10, 0, 6, 0, 0, UP)))
410
410
 
    let SqrtofAttachPymt = pow(SquareofAttachedPymt, 0, 5, 1, sharedecimals, DOWN)
411
411
 
    let UserLPWorth = fraction(args3, SqrtofAttachPymt, pow(10, 0, bothassetsdecimals, 0, 0, UP))
412
412
 
    let USDTHoldingInPair =     match getInteger(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID))) {
413
413
 
        case a: Int => 
414
414
 
            a
415
415
 
        case _ => 
416
416
 
            0
417
417
 
    }
418
418
 
    let NewUSDTHoldingInPair = (USDTHoldingInPair - UserLPWorth)
419
419
 
    let AssetHoldingInPair =     match getInteger(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID)) {
420
420
 
        case a: Int => 
421
421
 
            a
422
422
 
        case _ => 
423
423
 
            0
424
424
 
    }
425
425
 
    let NewAssetHoldingInPair = (AssetHoldingInPair - SqrtofAttachPymt)
426
426
 
    let LPTokenIssued =     match getIntegerValue(this, ("Total_LP_" + EnterAssetID)) {
427
427
 
        case a: Int => 
428
428
 
            a
429
429
 
        case _ => 
430
430
 
            0
431
431
 
    }
432
432
 
    let NewLPTokenIssued = (LPTokenIssued - pmt.amount)
433
433
 
    if ((checkpairisavailableornot != EnterAssetID))
434
434
 
        then throw("Pair is not available in Whitelist.")
435
435
 
        else if ((VotingStatus == CurrentVotingStatus))
436
436
 
            then throw((EnterAssetID + " is not A Whitelist Token Yet."))
437
437
 
            else if ((fromBase58String(EnterAssetID) == USDTAssetID))
438
438
 
                then throw("Don't choose USDT AssetID as Input, Only Whitelisted Asset as Input String & Attach LP Tokens as payment[1]")
439
439
 
                else if ((pmt.assetId != ReissueableassetId))
440
440
 
                    then throw("Wrong Asset is attached in payment[1] or LP Token Not Found or Missing.")
441
441
 
                    else [Burn(ReissueableassetId, pmt.amount), IntegerEntry(("Total_LP_" + EnterAssetID), NewLPTokenIssued), IntegerEntry(((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)), NewUSDTHoldingInPair), IntegerEntry(((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID), NewAssetHoldingInPair), ScriptTransfer(i.caller, UserLPWorth, USDTAssetID), ScriptTransfer(i.caller, SqrtofAttachPymt, fromBase58String(EnterAssetID))]
442
442
 
    }
443
443
 
444
444
 
445
445
 
446
446
 
@Callable(i)
447
447
 
func RemovePairEntry (EnterAssetID) = {
448
448
 
    let adminrights = getStringValue(this, "Polarity_Admin_Rights")
449
449
 
    let checkendheight = getIntegerValue(this, ("Voting_EH_" + EnterAssetID))
450
450
 
    let checkpairisavailableornot = getString(this, ("Pair_UV_" + EnterAssetID))
451
451
 
    let VotingStatus = getStringValue(this, ("Voting_Status_" + EnterAssetID))
452
452
 
    let NewVotingStatus = "P"
453
453
 
    let calleraddress = toBase58String(i.caller.bytes)
454
454
 
    let currentheight = height
455
455
 
    let pendingblocksforprojectexpire = (checkendheight - height)
456
456
 
    if ((checkpairisavailableornot != EnterAssetID))
457
457
 
        then throw("Pair is not available in Voting List.")
458
458
 
        else if ((adminrights != calleraddress))
459
459
 
            then throw((("I know You are not An Admin. Only " + adminrights) + " has rights to remove the pair."))
460
460
 
            else if ((checkendheight > height))
461
461
 
                then throw((("Voting Already Running. You can remove the pair after " + toString(pendingblocksforprojectexpire)) + " Blocks"))
462
462
 
                else if ((VotingStatus == NewVotingStatus))
463
463
 
                    then throw((EnterAssetID + " is now Whitelisted. So you can't remove it."))
464
464
 
                    else [DeleteEntry(("Pair_UV_" + EnterAssetID)), DeleteEntry(("Voting_SH_" + EnterAssetID)), DeleteEntry(("Voting_EH_" + EnterAssetID)), DeleteEntry(("Voting_Period_" + EnterAssetID)), DeleteEntry(("Votes_Req_" + EnterAssetID)), DeleteEntry(("Listing_Fee_" + EnterAssetID)), DeleteEntry(("Voting_Status_" + EnterAssetID)), DeleteEntry(("Votes_Rcvd_" + EnterAssetID))]
465
465
 
    }
466
466
 
467
467
 
468
468
 
@Verifier(tx)
469
469
 
func verify () = match tx {
470
470
 
    case _ => 
471
471
 
        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
472
472
 
}
473
473
 

github/deemru/w8io/169f3d6 
73.38 ms ◑