tx · GG4GknWjTgp6xMt8YJXqLchNud3XFa3c4K1vrNu1x6H7

3Mrnje6z2xa3xuXyU2Lk6ynKy8tsRnnt4Bv:  -0.01400000 Waves

2021.09.01 02:36 [1683189] smart account 3Mrnje6z2xa3xuXyU2Lk6ynKy8tsRnnt4Bv > SELF 0.00000000 Waves

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

View: original | compacted
Prev: GXdbauyZtJctxAX4g3GWmPvfWmRHEmp6d92avUUVVtdE
Next: FdPMye4gza8KiD3qCQkpxmRNCXn1Ef115gYpEw5Cywrk

Diff: 
Old
New
Differences
329
329
 
    let CurrentVotingStatus = "F"
330
330
 
    let CheckUSDTBalance = getIntegerValue(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)))
331
331
 
    let CheckAssetBalance = getIntegerValue(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID))
332
-
    let newpriceofAsset = fraction(CheckUSDTBalance, 1, CheckAssetBalance)
332
+
    let newpriceofAsset = (CheckUSDTBalance / CheckAssetBalance)
333
333
 
    let quantityofEnterAssetID = fraction(1, pmt1.amount, newpriceofAsset)
334
334
 
    let decimalsinfo = valueOrErrorMessage(assetInfo(fromBase58String(EnterAssetID)), (("Asset " + EnterAssetID) + " doesn't exist"))
335
335
 
    let decimals = decimalsinfo.decimals
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 and 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 and 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)]
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 and 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 NewVotingStatus = "P"
175
175
 
    let VotingStatus = valueOrErrorMessage(getString(this, ("Voting_Status_" + EnterAssetID)), ("Voting Status is Missing for " + EnterAssetID))
176
176
 
    let LPissue = Issue((("LP-" + name) + "-USDT"), (((("LP-" + name) + "-USDT") + " is a Liquidity Provider Token Issued Against ") + EnterAssetID), 1, 0, true)
177
177
 
    let LPid = calculateAssetId(LPissue)
178
178
 
    if ((adminrights != calleraddress))
179
179
 
        then throw((("Your are not allowded to Issue LP Token. Only " + adminrights) + " can issue the LP Token."))
180
180
 
        else if ((checkpairisavailableornot != EnterAssetID))
181
181
 
            then throw("Pair is not available in Voting List.")
182
182
 
            else if ((VotingStatus != NewVotingStatus))
183
183
 
                then throw("LP Token must be a Whitelisted Token.")
184
184
 
                else [LPissue, StringEntry(("LP_" + EnterAssetID), toBase58String(LPid))]
185
185
 
    }
186
186
 
187
187
 
188
188
 
189
189
 
@Callable(i)
190
190
 
func SwapAssetToUSDTPairEntry (EnterAssetID) = {
191
191
 
    let calleraddress = toBase58String(i.caller.bytes)
192
192
 
    let pmt = if ((size(i.payments) == 1))
193
193
 
        then i.payments[0]
194
194
 
        else throw("Whitelisted Token is required as Attached payment[1].")
195
195
 
    let checkpairisavailableornot = getString(this, ("Pair_UV_" + EnterAssetID))
196
196
 
    let VotingStatus = getStringValue(this, ("Voting_Status_" + EnterAssetID))
197
197
 
    let CheckUSDTBalance = getIntegerValue(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)))
198
198
 
    let CheckAssetBalance = getIntegerValue(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID))
199
199
 
    let newbalanceofUSDT = fraction(CheckUSDTBalance, CheckAssetBalance, (CheckAssetBalance + pmt.amount))
200
200
 
    let quantityofpriceasset = (CheckUSDTBalance - newbalanceofUSDT)
201
201
 
    let CurrentVotingStatus = "F"
202
202
 
    let SwapFee = 1
203
203
 
    let SwapFeetoreceive = ((quantityofpriceasset * SwapFee) / 100)
204
204
 
    let userbalancetoreceive = (quantityofpriceasset - SwapFeetoreceive)
205
205
 
    let SumupofAssetToUSDTSwapFee =     match getInteger(this, ((("Total_Swap_Fee_Collected_" + EnterAssetID) + "_") + toBase58String(USDTAssetID))) {
206
206
 
        case a: Int => 
207
207
 
            a
208
208
 
        case _ => 
209
209
 
            0
210
210
 
    }
211
211
 
    let NewSumupofAssetToUSDTSwapFee = (SumupofAssetToUSDTSwapFee + SwapFeetoreceive)
212
212
 
    let SumupAssetBalance =     match getInteger(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID)) {
213
213
 
        case a: Int => 
214
214
 
            a
215
215
 
        case _ => 
216
216
 
            0
217
217
 
    }
218
218
 
    let NewSumupofAssetBalance = (CheckAssetBalance + pmt.amount)
219
219
 
    let SumupUSDTBalance =     match getInteger(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID))) {
220
220
 
        case a: Int => 
221
221
 
            a
222
222
 
        case _ => 
223
223
 
            0
224
224
 
    }
225
225
 
    let NewSumupofUSDTBalance = (CheckUSDTBalance - quantityofpriceasset)
226
226
 
    let TOPT =     match getIntegerValue(this, ("Total_of_Pair_Txns_" + EnterAssetID)) {
227
227
 
        case a: Int => 
228
228
 
            a
229
229
 
        case _ => 
230
230
 
            0
231
231
 
    }
232
232
 
    let NewTPT = (TOPT + 1)
233
233
 
    if ((EnterAssetID == toBase58String(USDTAssetID)))
234
234
 
        then throw("Input can Never be a USDT AssetID. Enter Whitelisted AssetID in input and Attach Whitelisted Asset as an attachment Token in payment[1].")
235
235
 
        else if ((checkpairisavailableornot != EnterAssetID))
236
236
 
            then throw("Pair is not available in Whitelisted Asset.")
237
237
 
            else if ((VotingStatus == CurrentVotingStatus))
238
238
 
                then throw((EnterAssetID + " is not A Whitelisted Token Yet."))
239
239
 
                else if ((pmt.assetId == USDTAssetID))
240
240
 
                    then throw("You can't Attach USDT as an Attached Payment. Only Whitelisted Tokens are accepted.")
241
241
 
                    else if ((pmt.assetId != fromBase58String(EnterAssetID)))
242
242
 
                        then throw(("Incorrect asset attached, please attach or send " + EnterAssetID))
243
243
 
                        else if ((CheckUSDTBalance == 0))
244
244
 
                            then throw("Swap Pair Need to Add Liquidity first into Pool. Only After that Pair will be activated for Swapping.")
245
245
 
                            else if ((CheckAssetBalance == 0))
246
246
 
                                then throw("Swap Pair Need to Add Liquidity first into Pool. Only After that Pair will be activated for Swapping.")
247
247
 
                                else if ((10000000 > quantityofpriceasset))
248
248
 
                                    then throw((("Your Attached Asset Amount is very low. Attach More " + EnterAssetID) + " Tokens to Claim the minimum Amount of 10 dollar atleast."))
249
249
 
                                    else if ((quantityofpriceasset > CheckUSDTBalance))
250
250
 
                                        then throw((("Pool Only has a Liquidity of " + toString((CheckUSDTBalance / pow(10, 0, 6, 0, 0, UP)))) + " USDT. Add Liquidity into Pool."))
251
251
 
                                        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)]
252
252
 
    }
253
253
 
254
254
 
255
255
 
256
256
 
@Callable(i)
257
257
 
func SwapUSDTToAssetPairEntry (EnterAssetID) = {
258
258
 
    let calleraddress = toBase58String(i.caller.bytes)
259
259
 
    let pmt = if ((size(i.payments) == 1))
260
260
 
        then i.payments[0]
261
261
 
        else throw("Only USDT Token is required as an Attached payment[1].")
262
262
 
    let CheckUSDTBalance = getIntegerValue(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)))
263
263
 
    let CheckAssetBalance = getIntegerValue(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID))
264
264
 
    let newbalanceofAsset = fraction(CheckUSDTBalance, CheckAssetBalance, (CheckUSDTBalance + pmt.amount))
265
265
 
    let quantityofpriceasset = (CheckAssetBalance - newbalanceofAsset)
266
266
 
    let checkpairisavailableornot = getString(this, ("Pair_UV_" + EnterAssetID))
267
267
 
    let VotingStatus = getStringValue(this, ("Voting_Status_" + EnterAssetID))
268
268
 
    let CurrentVotingStatus = "F"
269
269
 
    let SwapFee = 1
270
270
 
    let SwapFeetoreceive = ((quantityofpriceasset * SwapFee) / 100)
271
271
 
    let userbalancetoreceive = (quantityofpriceasset - SwapFeetoreceive)
272
272
 
    let SumupofUSDTToAssetSwapFee =     match getInteger(this, ("Total_Swap_Fee_Collected_" + EnterAssetID)) {
273
273
 
        case a: Int => 
274
274
 
            a
275
275
 
        case _ => 
276
276
 
            0
277
277
 
    }
278
278
 
    let NewSumupofUSDTToAssetSwapFee = (SumupofUSDTToAssetSwapFee + SwapFeetoreceive)
279
279
 
    let SumupAssetBalance =     match getInteger(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID)) {
280
280
 
        case a: Int => 
281
281
 
            a
282
282
 
        case _ => 
283
283
 
            0
284
284
 
    }
285
285
 
    let NewSumupofAssetBalance = (CheckAssetBalance - quantityofpriceasset)
286
286
 
    let SumupUSDTBalance =     match getInteger(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID))) {
287
287
 
        case a: Int => 
288
288
 
            a
289
289
 
        case _ => 
290
290
 
            0
291
291
 
    }
292
292
 
    let NewSumupofUSDTBalance = (CheckUSDTBalance + pmt.amount)
293
293
 
    let TOPT =     match getIntegerValue(this, ("Total_of_Pair_Txns_" + EnterAssetID)) {
294
294
 
        case a: Int => 
295
295
 
            a
296
296
 
        case _ => 
297
297
 
            0
298
298
 
    }
299
299
 
    let NewTPT = (TOPT + 1)
300
300
 
    if ((checkpairisavailableornot != EnterAssetID))
301
301
 
        then throw("Pair is not available in Whitelisted Asset.")
302
302
 
        else if ((VotingStatus == CurrentVotingStatus))
303
303
 
            then throw((EnterAssetID + " is not A Whitelisted Token Yet."))
304
304
 
            else if ((EnterAssetID == toBase58String(USDTAssetID)))
305
305
 
                then throw("Input can Never be a USDT AssetID. Enter Whitelisted AssetID in input and Attach USDT as an attachment Token in payment[1].")
306
306
 
                else if ((pmt.assetId != USDTAssetID))
307
307
 
                    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.")
308
308
 
                    else if ((10000000 > pmt.amount))
309
309
 
                        then throw("Your Attached USDT Amount is very low. Attach Atleast 10 USDT to Claim the minimum Tokens.")
310
310
 
                        else if ((CheckUSDTBalance == 0))
311
311
 
                            then throw("Swap Pair Need to Add Liquidity first into Pool. Only After that Pair will be activated for Swapping.")
312
312
 
                            else if ((CheckAssetBalance == 0))
313
313
 
                                then throw("Swap Pair Need to Add Liquidity first into Pool. Only After that Pair will be activated for Swapping.")
314
314
 
                                else if ((quantityofpriceasset > CheckAssetBalance))
315
315
 
                                    then throw((("Pool Only has a Liquidity of " + toString(CheckAssetBalance)) + " Tokens. Add Liquidity into Pool."))
316
316
 
                                    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))]
317
317
 
    }
318
318
 
319
319
 
320
320
 
321
321
 
@Callable(i)
322
322
 
func AddLiquidity (EnterAssetID) = {
323
323
 
    let calleraddress = toBase58String(i.caller.bytes)
324
324
 
    let pmt1 = value(i.payments[0])
325
325
 
    let pmt2 = value(i.payments[1])
326
326
 
    let checkpairisavailableornot = getString(this, ("Pair_UV_" + EnterAssetID))
327
327
 
    let VotingStatus = getStringValue(this, ("Voting_Status_" + EnterAssetID))
328
328
 
    let ReissueassetId = fromBase58String(valueOrErrorMessage(getString(this, ("LP_" + EnterAssetID)), "LP Token is Missing or May be not Generated."))
329
329
 
    let CurrentVotingStatus = "F"
330
330
 
    let CheckUSDTBalance = getIntegerValue(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)))
331
331
 
    let CheckAssetBalance = getIntegerValue(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID))
332
-
    let newpriceofAsset = fraction(CheckUSDTBalance, 1, CheckAssetBalance)
332
+
    let newpriceofAsset = (CheckUSDTBalance / CheckAssetBalance)
333
333
 
    let quantityofEnterAssetID = fraction(1, pmt1.amount, newpriceofAsset)
334
334
 
    let decimalsinfo = valueOrErrorMessage(assetInfo(fromBase58String(EnterAssetID)), (("Asset " + EnterAssetID) + " doesn't exist"))
335
335
 
    let decimals = decimalsinfo.decimals
336
336
 
    let quantityofLPToken1 = fraction(pmt2.amount, 1, pow(10, 0, decimals, 0, 0, UP))
337
337
 
    let USDTHoldingInPair =     match getInteger(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID))) {
338
338
 
        case a: Int => 
339
339
 
            a
340
340
 
        case _ => 
341
341
 
            0
342
342
 
    }
343
343
 
    let NewUSDTHoldingInPair = (USDTHoldingInPair + pmt1.amount)
344
344
 
    let AssetHoldingInPair =     match getInteger(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID)) {
345
345
 
        case a: Int => 
346
346
 
            a
347
347
 
        case _ => 
348
348
 
            0
349
349
 
    }
350
350
 
    let NewAssetHoldingInPair = (AssetHoldingInPair + pmt2.amount)
351
351
 
    let LPTokenIssued =     match getIntegerValue(this, ("Total_LP_" + EnterAssetID)) {
352
352
 
        case a: Int => 
353
353
 
            a
354
354
 
        case _ => 
355
355
 
            0
356
356
 
    }
357
357
 
    let NewLPTokenIssued = (LPTokenIssued + quantityofLPToken1)
358
358
 
    if ((checkpairisavailableornot != EnterAssetID))
359
359
 
        then throw("Pair is not available in Whitelisted Asset.")
360
360
 
        else if ((VotingStatus == CurrentVotingStatus))
361
361
 
            then throw((EnterAssetID + " is not A Whitelisted Token Yet."))
362
362
 
            else if ((EnterAssetID == toBase58String(USDTAssetID)))
363
363
 
                then throw("Input can Never be a USDT AssetID. Enter Whitelisted AssetID in input as well as in payment[1] and Attach USDT as an attachment Token in payment[2].")
364
364
 
                else if ((size(i.payments) != 2))
365
365
 
                    then throw("Two attached assets expected as payment in 50%-50%. Kindly Attach payment1 = USDT Token and payment2 = Token you want to add for Liquidity.")
366
366
 
                    else if ((pmt1.assetId != USDTAssetID))
367
367
 
                        then throw("Incorrect asset attached for Liquidity in payment[1], please attach USDT Token only.")
368
368
 
                        else if ((10000000 > pmt1.amount))
369
369
 
                            then throw("please attach atleast 10 USDT in payment[1].")
370
370
 
                            else if ((pmt2.assetId == USDTAssetID))
371
371
 
                                then throw("You Attached USDT asset for Liquidity in both payments, Kindly Attach payment1 = USDT Token and payment2 = Token you want to add for Liquidity.")
372
372
 
                                else if ((pmt2.assetId != fromBase58String(EnterAssetID)))
373
373
 
                                    then throw((("Asset String " + EnterAssetID) + " is not matching with attached payment[2]. String and payment[2] must be same."))
374
374
 
                                    else if ((pmt2.amount != quantityofEnterAssetID))
375
375
 
                                        then throw(("Attached payment[2] quantity is not matching as per attached payment[1] USDT.It must be " + toString(fraction(quantityofEnterAssetID, 1, pow(10, 0, decimals, 0, 0, UP)))))
376
376
 
                                        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)]
377
377
 
    }
378
378
 
379
379
 
380
380
 
381
381
 
@Callable(i)
382
382
 
func RemoveLiquidity (EnterAssetID) = {
383
383
 
    let calleraddress = toBase58String(i.caller.bytes)
384
384
 
    let pmt = if ((size(i.payments) == 1))
385
385
 
        then i.payments[0]
386
386
 
        else throw("No payment attached, Please Attach LP Token as payment[1].")
387
387
 
    let checkpairisavailableornot = getString(this, ("Pair_UV_" + EnterAssetID))
388
388
 
    let VotingStatus = getStringValue(this, ("Voting_Status_" + EnterAssetID))
389
389
 
    let ReissueableassetId = fromBase58String(valueOrErrorMessage(getString(this, ("LP_" + EnterAssetID)), "LP Token is Missing or May be not Generated."))
390
390
 
    let CurrentVotingStatus = "F"
391
391
 
    let CheckUSDTBalance = getIntegerValue(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID)))
392
392
 
    let CheckAssetBalance = getIntegerValue(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID))
393
393
 
    let CheckLPTokenispresent = getIntegerValue(this, ("Total_LP_" + EnterAssetID))
394
394
 
    let SubtractedUSDT = fraction(CheckUSDTBalance, pmt.amount, getIntegerValue(this, ("Total_LP_" + EnterAssetID)))
395
395
 
    let CurrentpriceofToken = fraction(CheckUSDTBalance, 1, CheckAssetBalance)
396
396
 
    let SubtractedAsset = fraction(SubtractedUSDT, 1, CurrentpriceofToken)
397
397
 
    let USDTHoldingInPair =     match getInteger(this, ((("Balance_of_" + EnterAssetID) + "_") + toBase58String(USDTAssetID))) {
398
398
 
        case a: Int => 
399
399
 
            a
400
400
 
        case _ => 
401
401
 
            0
402
402
 
    }
403
403
 
    let NewUSDTHoldingInPair = (USDTHoldingInPair - SubtractedUSDT)
404
404
 
    let AssetHoldingInPair =     match getInteger(this, ((("Balance_of_" + toBase58String(USDTAssetID)) + "_") + EnterAssetID)) {
405
405
 
        case a: Int => 
406
406
 
            a
407
407
 
        case _ => 
408
408
 
            0
409
409
 
    }
410
410
 
    let NewAssetHoldingInPair = (AssetHoldingInPair - SubtractedAsset)
411
411
 
    let LPTokenIssued =     match getIntegerValue(this, ("Total_LP_" + EnterAssetID)) {
412
412
 
        case a: Int => 
413
413
 
            a
414
414
 
        case _ => 
415
415
 
            0
416
416
 
    }
417
417
 
    let NewLPTokenIssued = (LPTokenIssued - pmt.amount)
418
418
 
    if ((checkpairisavailableornot != EnterAssetID))
419
419
 
        then throw("Pair is not available in Whitelisted Asset.")
420
420
 
        else if ((VotingStatus == CurrentVotingStatus))
421
421
 
            then throw((EnterAssetID + " is not A Whitelisted Token Yet."))
422
422
 
            else if ((fromBase58String(EnterAssetID) == USDTAssetID))
423
423
 
                then throw("You can't choose USDT AssetID as Input String, Choose Whitelisted Asset as Input String and Attach LP Tokens as payment[1]")
424
424
 
                else if ((pmt.assetId != ReissueableassetId))
425
425
 
                    then throw("LP Token Not Found or Missing or Wrong Asset is attached.")
426
426
 
                    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, SubtractedUSDT, USDTAssetID), ScriptTransfer(i.caller, SubtractedAsset, fromBase58String(EnterAssetID))]
427
427
 
    }
428
428
 
429
429
 
430
430
 
431
431
 
@Callable(i)
432
432
 
func RemovePairEntry (EnterAssetID) = {
433
433
 
    let adminrights = getStringValue(this, "Polarity_Admin_Rights")
434
434
 
    let checkendheight = getIntegerValue(this, ("Voting_EH_" + EnterAssetID))
435
435
 
    let checkpairisavailableornot = getString(this, ("Pair_UV_" + EnterAssetID))
436
436
 
    let VotingStatus = getStringValue(this, ("Voting_Status_" + EnterAssetID))
437
437
 
    let NewVotingStatus = "P"
438
438
 
    let calleraddress = toBase58String(i.caller.bytes)
439
439
 
    let currentheight = height
440
440
 
    let pendingblocksforprojectexpire = (checkendheight - height)
441
441
 
    if ((checkpairisavailableornot != EnterAssetID))
442
442
 
        then throw("Pair is not available in Voting List.")
443
443
 
        else if ((adminrights != calleraddress))
444
444
 
            then throw((("I know You are not An Admin. Only " + adminrights) + " has rights to remove the pair."))
445
445
 
            else if ((checkendheight > height))
446
446
 
                then throw((("Voting Already Running. You can remove the pair after " + toString(pendingblocksforprojectexpire)) + " Blocks"))
447
447
 
                else if ((VotingStatus == NewVotingStatus))
448
448
 
                    then throw((EnterAssetID + " is now Whitelisted. So you can't remove it."))
449
449
 
                    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))]
450
450
 
    }
451
451
 
452
452
 
453
453
 
454
454
 
@Callable(i)
455
455
 
func RemoveEntry (Key,Key1,Key2,Key3) = [DeleteEntry(Key), DeleteEntry(Key1), DeleteEntry(Key2), DeleteEntry(Key3)]
456
456
 
457
457
 
458
458
 
@Verifier(tx)
459
459
 
func verify () = match tx {
460
460
 
    case _ => 
461
461
 
        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
462
462
 
}
463
463
 

github/deemru/w8io/026f985 
74.31 ms ◑