tx · Nsorop7H6ujJLjnE4u7LMDMg5Jm5QBxzhEoQsPXxpKK

3MvoEe13bRhr1xLdXUsAmcdpEiYPCGmFRrw:  -0.01100000 Waves

2022.09.11 20:12 [2224722] smart account 3MvoEe13bRhr1xLdXUsAmcdpEiYPCGmFRrw > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Nsorop7H6ujJLjnE4u7LMDMg5Jm5QBxzhEoQsPXxpKK",
    "fee": 1100000,
    "feeAssetId": null,
    "timestamp": 1662916432021,
    "version": 2,
    "chainId": 84,
    "sender": "3MvoEe13bRhr1xLdXUsAmcdpEiYPCGmFRrw",
    "senderPublicKey": "ARkArSoamYt3MY3UCKrt7r7ozjiGg9BFFEgBZdA6Grc",
    "proofs": [
        "wUrk2bJN2T6ajwbqrqffJmVKRKzURLsjv6XBRUjfd9WZPECLRTQhjy8XaYkxh6R2n85HsbDup4fe4RdJDN3amLa"
    ],
    "script": "base64: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",
    "height": 2224722,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 
Old
New
Differences
1
-
# no script
1
+
{-# STDLIB_VERSION 6 #-}
2
+
{-# SCRIPT_TYPE ACCOUNT #-}
3
+
{-# CONTENT_TYPE DAPP #-}
4
+
let usdn = base58'FVXgJ86erBw5GAMeAw1CnYXwQn48BFAEAhRyHPUjbMQB'
5
+
6
+
let usdc = base58'HRut8ESAGXxwvsKJky1V96qRtqyXQd4Apq4GY7TE5yGP'
7
+
8
+
let admin_wallet = "3N3DCngjidivkJbTJwFTEvbYRTffCWVBLCL"
9
+
10
+
let admin_wallet_address = base58'3N3DCngjidivkJbTJwFTEvbYRTffCWVBLCL'
11
+
12
+
let stop_wallet = base58'3MpDfDT359qSSmNFZnMeoPQpyJA2U1K51u5'
13
+
14
+
let alfark_testnet = 5
15
+
16
+
let vires_dapp = base58'3MzwNdM8LQZEPXq3d4uXvxeZGpBwVQXs9RD'
17
+
18
+
func tryGetInteger (key) = match getInteger(this, key) {
19
+
    case b: Int => 
20
+
        b
21
+
    case _ => 
22
+
        0
23
+
}
24
+
25
+
26
+
func tryGetString (key) = match getStringValue(this, key) {
27
+
    case b: String => 
28
+
        b
29
+
    case _ => 
30
+
        ""
31
+
}
32
+
33
+
34
+
func check_send_if_allow (token) = {
35
+
    let token_name =     match token {
36
+
        case str: String => 
37
+
            str
38
+
        case _ => 
39
+
            throw("Error, check_send_if_allow , token unknown type ")
40
+
    }
41
+
    let result = tryGetString((token_name + "_profit_is_allow_to_send"))
42
+
    if ((result == "yes"))
43
+
        then true
44
+
        else false
45
+
    }
46
+
47
+
48
+
func check_asset (assetId) = {
49
+
    let asset_id =     match assetId {
50
+
        case str: String => 
51
+
            toBytes(str)
52
+
        case byte: ByteVector => 
53
+
            byte
54
+
        case address: Address => 
55
+
            toBytes(toString(address))
56
+
        case nit: Unit => 
57
+
            throw("ERROR , in check_asset , Unkonwon Asset type!")
58
+
        case _ => 
59
+
            throw("ERROR , in check_asset , Unkonwon Asset type!")
60
+
    }
61
+
    if ((asset_id == usdn))
62
+
        then {
63
+
            let token = "usdn"
64
+
            token
65
+
            }
66
+
        else if ((asset_id == usdc))
67
+
            then {
68
+
                let token = "usdc"
69
+
                token
70
+
                }
71
+
            else throw("Error , in check asset func , unknown asset to check")
72
+
    }
73
+
74
+
75
+
func sec_transfer_transaction (sx) = {
76
+
    let tx =     match sx {
77
+
        case t: TransferTransaction => 
78
+
            t
79
+
        case _ => 
80
+
            throw("Error , in sec_transfer_transaction , wrong transaction type")
81
+
    }
82
+
    let token = check_asset(tx.assetId)
83
+
    if ((tx.recipient == Address(admin_wallet_address)))
84
+
        then {
85
+
            let allow_amount = tryGetInteger("usdc_profit_old_amount")
86
+
            let allow_to_send = check_send_if_allow(token)
87
+
            if ((tx.amount != allow_amount))
88
+
                then throw("sec_transfer_transaction, DAPP can't send this Transaction for security Reasons")
89
+
                else if ((allow_to_send != true))
90
+
                    then throw("sec_transfer_transaction, DAPP can't send this Transaction for security Reasons")
91
+
                    else true
92
+
            }
93
+
        else {
94
+
            let user_address = addressFromRecipient(tx.recipient)
95
+
            let user_allow_amount = tryGetInteger(((token + toString(user_address)) + "_credit"))
96
+
            if ((tx.amount > user_allow_amount))
97
+
                then throw("sec_transfer_transaction, DAPP can't send this Transaction for security Reasons [you want withdraw amount more than you depostied ]")
98
+
                else true
99
+
            }
100
+
    }
101
+
102
+
103
+
func sec_invoke_script_transaction (sx) = {
104
+
    let tx =     match sx {
105
+
        case t: InvokeScriptTransaction => 
106
+
            t
107
+
        case _ => 
108
+
            throw("Error , in sec_invoke_script_transaction , wrong transaction type")
109
+
    }
110
+
    let recipient = addressFromRecipient(tx.dApp)
111
+
    if ((recipient != Address(vires_dapp)))
112
+
        then throw("Error , in sec_invoke_script_transaction ,DAPP can't send this Transaction for security Reasons [Wrong Unknown Dapp Address] ")
113
+
        else true
114
+
    }
115
+
116
+
117
+
@Callable(i)
118
+
func buy_usdn_ticket (referral) = {
119
+
    let stop_most_func = tryGetString("stop_most_funactions")
120
+
    if ((stop_most_func != ""))
121
+
        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
122
+
        else if ((i.payments[0].assetId != usdn))
123
+
            then throw("Please deposit USD-N token only")
124
+
            else {
125
+
                let user_credit = tryGetInteger((("usdn_" + toString(i.originCaller)) + "_credit"))
126
+
                let deposit_amount = i.payments[0].amount
127
+
                let new_user_credit = (user_credit + deposit_amount)
128
+
                let all_credit = tryGetInteger("usdn_all_credit")
129
+
                let new_all_credit = (all_credit + deposit_amount)
130
+
                let transaction_block =                 match lastBlock.height {
131
+
                    case a: Int => 
132
+
                        a
133
+
                    case _ => 
134
+
                        throw("Error! with blochchain height")
135
+
                }
136
+
                let res = invoke(Address(vires_dapp), "usdN_stake", nil, [AttachedPayment(usdn, deposit_amount)])
137
+
                if ((res == res))
138
+
                    then [StringEntry((("usdn_" + toString(i.originCaller)) + "_referral"), referral), IntegerEntry((("usdn_" + toString(i.originCaller)) + "_credit"), new_user_credit), IntegerEntry((("usdn_" + toString(i.originCaller)) + "_block"), transaction_block), IntegerEntry("usdn_all_credit", new_all_credit), IntegerEntry("usdn_all_block", transaction_block)]
139
+
                    else throw("Strict value is not equal to itself.")
140
+
                }
141
+
    }
142
+
143
+
144
+
145
+
@Callable(i)
146
+
func buy_usdc_ticket (referral) = {
147
+
    let stop_most_func = tryGetString("stop_most_funactions")
148
+
    if ((stop_most_func != ""))
149
+
        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
150
+
        else if ((i.payments[0].assetId != usdc))
151
+
            then throw("Please deposit USD-N token only")
152
+
            else {
153
+
                let user_credit = tryGetInteger((("usdc_" + toString(i.originCaller)) + "_credit"))
154
+
                let deposit_amount = i.payments[0].amount
155
+
                let new_user_credit = (user_credit + deposit_amount)
156
+
                let all_credit = tryGetInteger("usdc_all_credit")
157
+
                let new_all_credit = (all_credit + deposit_amount)
158
+
                let transaction_block =                 match lastBlock.height {
159
+
                    case a: Int => 
160
+
                        a
161
+
                    case _ => 
162
+
                        throw("Error block number")
163
+
                }
164
+
                let res = invoke(Address(vires_dapp), "usdC_stake", nil, [AttachedPayment(usdc, deposit_amount)])
165
+
                if ((res == res))
166
+
                    then [StringEntry((("usdc_" + toString(i.originCaller)) + "_referral"), referral), IntegerEntry((("usdc_" + toString(i.originCaller)) + "_credit"), new_user_credit), IntegerEntry((("usdc_" + toString(i.originCaller)) + "_block"), transaction_block), IntegerEntry("usdc_all_credit", new_all_credit), IntegerEntry("usdc_all_block", transaction_block)]
167
+
                    else throw("Strict value is not equal to itself.")
168
+
                }
169
+
    }
170
+
171
+
172
+
173
+
@Callable(i)
174
+
func sell_usdn_ticket (amount) = {
175
+
    let user_credit = tryGetInteger((("usdn_" + toString(i.originCaller)) + "_credit"))
176
+
    if ((amount > user_credit))
177
+
        then throw(("sorry you can't withdraw this amount, because you have only " + toString(user_credit)))
178
+
        else {
179
+
            let new_user_credit = (user_credit - amount)
180
+
            let all_credit = tryGetInteger("usdn_all_credit")
181
+
            let new_all_credit = (all_credit - amount)
182
+
            let transaction_block =             match lastBlock.height {
183
+
                case a: Int => 
184
+
                    a
185
+
                case _ => 
186
+
                    throw("Error block number")
187
+
            }
188
+
            let res = invoke(Address(vires_dapp), "usdN_cancelStake", [amount], nil)
189
+
            if ((res == res))
190
+
                then [IntegerEntry((("usdn_" + toString(i.originCaller)) + "_credit"), new_user_credit), IntegerEntry((("usdn_" + toString(i.originCaller)) + "_block"), transaction_block), IntegerEntry("usdn_all_credit", new_all_credit), IntegerEntry("usdn_all_block", transaction_block)]
191
+
                else throw("Strict value is not equal to itself.")
192
+
            }
193
+
    }
194
+
195
+
196
+
197
+
@Callable(i)
198
+
func sell_usdc_ticket (amount) = {
199
+
    let user_credit = tryGetInteger((("usdc_" + toString(i.originCaller)) + "_credit"))
200
+
    if ((amount > user_credit))
201
+
        then throw(("sorry you can't withdraw this amount, because u=you have only " + toString(user_credit)))
202
+
        else {
203
+
            let new_user_credit = (user_credit - amount)
204
+
            let all_credit = tryGetInteger("usdc_all_credit")
205
+
            let new_all_credit = (all_credit - amount)
206
+
            let transaction_block =             match lastBlock.height {
207
+
                case a: Int => 
208
+
                    a
209
+
                case _ => 
210
+
                    throw("Error block number")
211
+
            }
212
+
            let res = invoke(Address(vires_dapp), "usdC_cancelStake", [amount], nil)
213
+
            if ((res == res))
214
+
                then [IntegerEntry((("usdc_" + toString(i.originCaller)) + "_credit"), new_user_credit), IntegerEntry((("usdc_" + toString(i.originCaller)) + "_block"), transaction_block), IntegerEntry("usdc_all_credit", new_all_credit), IntegerEntry("usdc_all_block", transaction_block)]
215
+
                else throw("Strict value is not equal to itself.")
216
+
            }
217
+
    }
218
+
219
+
220
+
221
+
@Callable(i)
222
+
func usdn_calc_profit_amount () = {
223
+
    let stop_most_func = tryGetString("stop_most_funactions")
224
+
    if ((stop_most_func != ""))
225
+
        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
226
+
        else if ((toString(i.originCaller) != admin_wallet))
227
+
            then throw("Sorry! you are not allowed to use this funaction")
228
+
            else {
229
+
                let usdn_calc_profit_last_block = tryGetInteger("usdn_calc_profit_last_block")
230
+
                let usdn_profit_last_amount = tryGetInteger("usdn_profit_last_amount")
231
+
                let transaction_block =                 match lastBlock.height {
232
+
                    case a: Int => 
233
+
                        a
234
+
                    case _ => 
235
+
                        throw("Error block number")
236
+
                }
237
+
                let alfark = (transaction_block - usdn_calc_profit_last_block)
238
+
                if ((alfark_testnet > alfark))
239
+
                    then throw((("Please try again after " + toString((alfark_testnet - alfark))) + " block"))
240
+
                    else {
241
+
                        let usdn_balance = assetBalance(this, usdn)
242
+
[IntegerEntry("usdn_calc_profit_last_block", transaction_block), IntegerEntry("usdn_profit_last_amount", usdn_balance), IntegerEntry("usdn_profit_old_amount", usdn_balance), StringEntry("usdn_profit_is_allow_to_send", "yes")]
243
+
                        }
244
+
                }
245
+
    }
246
+
247
+
248
+
249
+
@Callable(i)
250
+
func usdn_send_profit_amount () = {
251
+
    let stop_most_func = tryGetString("stop_most_funactions")
252
+
    if ((stop_most_func != ""))
253
+
        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
254
+
        else {
255
+
            let allow = check_send_if_allow("usdn")
256
+
            if ((allow != true))
257
+
                then throw("send is not allow for this token")
258
+
                else {
259
+
                    let usdn_profit_last_amount = tryGetInteger("usdn_profit_last_amount")
260
+
                    if ((0 >= usdn_profit_last_amount))
261
+
                        then throw(("you dont have profit amount " + toString(usdn_profit_last_amount)))
262
+
                        else {
263
+
                            let transfer = ScriptTransfer(addressFromStringValue(admin_wallet), usdn_profit_last_amount, usdn)
264
+
                            let transaction_block =                             match lastBlock.height {
265
+
                                case a: Int => 
266
+
                                    a
267
+
                                case _ => 
268
+
                                    throw("Error block number")
269
+
                            }
270
+
[transfer, IntegerEntry("usdn_profit_last_amount", 0), IntegerEntry("usdn_profit_last_block", transaction_block)]
271
+
                            }
272
+
                    }
273
+
            }
274
+
    }
275
+
276
+
277
+
278
+
@Callable(i)
279
+
func usdc_calc_profit_amount () = {
280
+
    let stop_most_func = tryGetString("stop_most_funactions")
281
+
    if ((stop_most_func != ""))
282
+
        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
283
+
        else if ((toString(i.originCaller) != admin_wallet))
284
+
            then throw("Sorry! you are not allowed to use this funaction")
285
+
            else {
286
+
                let usdc_calc_profit_last_block = tryGetInteger("usdc_calc_profit_last_block")
287
+
                let usdc_profit_last_amount = tryGetInteger("usdc_profit_last_amount")
288
+
                let transaction_block =                 match lastBlock.height {
289
+
                    case a: Int => 
290
+
                        a
291
+
                    case _ => 
292
+
                        throw("Error block number")
293
+
                }
294
+
                let alfark = (transaction_block - usdc_calc_profit_last_block)
295
+
                if ((alfark_testnet > alfark))
296
+
                    then throw((("Please try again after " + toString((alfark_testnet - alfark))) + " block"))
297
+
                    else {
298
+
                        let usdc_balance = assetBalance(this, usdc)
299
+
[IntegerEntry("usdc_calc_profit_last_block", transaction_block), IntegerEntry("usdc_profit_last_amount", usdc_balance), IntegerEntry("usdc_profit_old_amount", usdc_balance), StringEntry("usdc_profit_is_allow_to_send", "yes")]
300
+
                        }
301
+
                }
302
+
    }
303
+
304
+
305
+
306
+
@Callable(i)
307
+
func usdc_send_profit_amount () = {
308
+
    let stop_most_func = tryGetString("stop_most_funactions")
309
+
    if ((stop_most_func != ""))
310
+
        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
311
+
        else {
312
+
            let allow = check_send_if_allow("usdc")
313
+
            if ((allow != true))
314
+
                then throw("send is not allow for this token")
315
+
                else {
316
+
                    let usdc_profit_last_amount = tryGetInteger("usdc_profit_last_amount")
317
+
                    if ((0 >= usdc_profit_last_amount))
318
+
                        then throw(("you dont have profit amount " + toString(usdc_profit_last_amount)))
319
+
                        else {
320
+
                            let transfer = ScriptTransfer(addressFromStringValue(admin_wallet), usdc_profit_last_amount, usdc)
321
+
                            let transaction_block =                             match lastBlock.height {
322
+
                                case a: Int => 
323
+
                                    a
324
+
                                case _ => 
325
+
                                    throw("Error block number")
326
+
                            }
327
+
[transfer, IntegerEntry("usdn_profit_last_amount", 0), IntegerEntry("usdn_profit_last_block", transaction_block)]
328
+
                            }
329
+
                    }
330
+
            }
331
+
    }
332
+
333
+
334
+
335
+
@Callable(i)
336
+
func stop_dapp (new_dapp) = {
337
+
    let stop_wallet_add = Address(stop_wallet)
338
+
    if ((i.caller != stop_wallet_add))
339
+
        then throw("you can't Invoke this funactios")
340
+
        else [StringEntry("stop_most_funactions", new_dapp)]
341
+
    }
342
+
343
+
344
+
@Verifier(tx)
345
+
func verify () = {
346
+
    let result =     match tx {
347
+
        case TT: TransferTransaction => 
348
+
            sec_transfer_transaction(TT)
349
+
        case IST: InvokeScriptTransaction => 
350
+
            sec_invoke_script_transaction(IST)
351
+
        case _ => 
352
+
            false
353
+
    }
354
+
    if ((result == true))
355
+
        then sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
356
+
        else false
357
+
    }
358
+

github/deemru/w8io/169f3d6 
25.47 ms ◑