tx · J8ntLvVk3mnSvYzPbUyJXCdxgF1fnTVTAHDy3G65tyCr

3MxfoDjTo6U1pteXtApM7bTeko1YJaQnHAr:  -0.02000000 Waves

2023.04.20 03:58 [2542182] smart account 3MxfoDjTo6U1pteXtApM7bTeko1YJaQnHAr > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "J8ntLvVk3mnSvYzPbUyJXCdxgF1fnTVTAHDy3G65tyCr",
    "fee": 2000000,
    "feeAssetId": null,
    "timestamp": 1681952403816,
    "version": 2,
    "chainId": 84,
    "sender": "3MxfoDjTo6U1pteXtApM7bTeko1YJaQnHAr",
    "senderPublicKey": "A8zQom7idYcGh2p1BptebtJmyh1m85hk2Bjr6BuzzPhV",
    "proofs": [
        "44XUrXHFWRxLRbMv1EaS3DES6fCAxiq2KzrnufnhmjR5g6NZQ4i43bMCiDutNV97CnCqJUj7WYQ5XCvqpenryk6p"
    ],
    "script": "base64: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",
    "height": 2542182,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
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 waves = base58'DWscu6nt8HMVq3kR8ySucpjKPpPpAJs2H3mqgpLa6bQW'
9+
10+let admin_wallet = "3N3DCngjidivkJbTJwFTEvbYRTffCWVBLCL"
11+
12+let admin_wallet_address = base58'3N3DCngjidivkJbTJwFTEvbYRTffCWVBLCL'
13+
14+let stop_wallet = base58'3MpDfDT359qSSmNFZnMeoPQpyJA2U1K51u5'
15+
16+let alfark_testnet = 2500
17+
18+let vires_dapp = base58'3MpFYUjf9xgvz61eBjwjsj1F9mmhQjNpfJu'
19+
20+func tryGetInteger (key) = match getInteger(this, key) {
21+    case b: Int => 
22+        b
23+    case _ => 
24+        0
25+}
26+
27+
28+func tryGetString (key) = match getStringValue(this, key) {
29+    case b: String => 
30+        b
31+    case _ => 
32+        ""
33+}
34+
35+
36+func check_send_if_allow (token) = {
37+    let token_name =     match token {
38+        case str: String => 
39+            str
40+        case _ => 
41+            throw("Error, check_send_if_allow , token unknown type ")
42+    }
43+    let result = tryGetString((token_name + "_profit_is_allow_to_send"))
44+    if ((result == "yes"))
45+        then true
46+        else false
47+    }
48+
49+
50+func check_asset (assetId) = {
51+    let asset_id =     match assetId {
52+        case str: String => 
53+            toBytes(str)
54+        case byte: ByteVector => 
55+            byte
56+        case address: Address => 
57+            toBytes(toString(address))
58+        case nit: Unit => 
59+            throw("ERROR , in check_asset , Unkonwon Asset type!")
60+        case _ => 
61+            throw("ERROR , in check_asset , Unkonwon Asset type!")
62+    }
63+    if ((asset_id == usdn))
64+        then {
65+            let token = "usdn"
66+            token
67+            }
68+        else if ((asset_id == usdc))
69+            then {
70+                let token = "usdc"
71+                token
72+                }
73+            else if ((asset_id == waves))
74+                then {
75+                    let token = "waves"
76+                    token
77+                    }
78+                else throw("Error , in check asset func , unknown asset to check")
79+    }
80+
81+
82+func sec_transfer_transaction (sx) = {
83+    let tx =     match sx {
84+        case t: TransferTransaction => 
85+            t
86+        case _ => 
87+            throw("Error , in sec_transfer_transaction , wrong transaction type")
88+    }
89+    let token = check_asset(tx.assetId)
90+    if ((tx.recipient == Address(admin_wallet_address)))
91+        then {
92+            let allow_amount = tryGetInteger((token + "_profit_old_amount"))
93+            let allow_to_send = check_send_if_allow(token)
94+            if ((tx.amount != allow_amount))
95+                then throw("sec_transfer_transaction, DAPP can't send this Transaction for security Reasons")
96+                else if ((allow_to_send != true))
97+                    then throw("sec_transfer_transaction, DAPP can't send this Transaction for security Reasons")
98+                    else true
99+            }
100+        else {
101+            let user_address = addressFromRecipient(tx.recipient)
102+            let user_allow_amount = tryGetInteger(((token + toString(user_address)) + "_credit"))
103+            if ((tx.amount > user_allow_amount))
104+                then throw("sec_transfer_transaction, DAPP can't send this Transaction for security Reasons [you want withdraw amount more than you depostied ]")
105+                else true
106+            }
107+    }
108+
109+
110+func sec_invoke_script_transaction (sx) = {
111+    let tx =     match sx {
112+        case t: InvokeScriptTransaction => 
113+            t
114+        case _ => 
115+            throw("Error , in sec_invoke_script_transaction , wrong transaction type")
116+    }
117+    let recipient = addressFromRecipient(tx.dApp)
118+    if ((recipient != Address(vires_dapp)))
119+        then throw("Error , in sec_invoke_script_transaction ,DAPP can't send this Transaction for security Reasons [Wrong Unknown Dapp Address] ")
120+        else true
121+    }
122+
123+
124+@Callable(i)
125+func buy_usdn_ticket (referral) = {
126+    let stop_most_func = tryGetString("stop_most_funactions")
127+    if ((stop_most_func != ""))
128+        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
129+        else if ((i.payments[0].assetId != usdn))
130+            then throw("Please deposit USD-N token only")
131+            else {
132+                let user_credit = tryGetInteger((("usdn_" + toString(i.originCaller)) + "_credit"))
133+                let deposit_amount = i.payments[0].amount
134+                let new_user_credit = (user_credit + deposit_amount)
135+                let all_credit = tryGetInteger("usdn_all_credit")
136+                let new_all_credit = (all_credit + deposit_amount)
137+                let transaction_block =                 match lastBlock.height {
138+                    case a: Int => 
139+                        a
140+                    case _ => 
141+                        throw("Error! with blochchain height")
142+                }
143+                let res = invoke(Address(vires_dapp), "usdN_stake", nil, [AttachedPayment(usdn, deposit_amount)])
144+                if ((res == res))
145+                    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)]
146+                    else throw("Strict value is not equal to itself.")
147+                }
148+    }
149+
150+
151+
152+@Callable(i)
153+func buy_usdc_ticket (referral) = {
154+    let stop_most_func = tryGetString("stop_most_funactions")
155+    if ((stop_most_func != ""))
156+        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
157+        else if ((i.payments[0].assetId != usdc))
158+            then throw("Please deposit USD-C token only")
159+            else {
160+                let user_credit = tryGetInteger((("usdc_" + toString(i.originCaller)) + "_credit"))
161+                let deposit_amount = i.payments[0].amount
162+                let new_user_credit = (user_credit + deposit_amount)
163+                let all_credit = tryGetInteger("usdc_all_credit")
164+                let new_all_credit = (all_credit + deposit_amount)
165+                let transaction_block =                 match lastBlock.height {
166+                    case a: Int => 
167+                        a
168+                    case _ => 
169+                        throw("Error block number")
170+                }
171+                let res = invoke(Address(vires_dapp), "usdC_stake", nil, [AttachedPayment(usdc, deposit_amount)])
172+                if ((res == res))
173+                    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)]
174+                    else throw("Strict value is not equal to itself.")
175+                }
176+    }
177+
178+
179+
180+@Callable(i)
181+func sell_usdn_ticket (amount) = {
182+    let user_credit = tryGetInteger((("usdn_" + toString(i.originCaller)) + "_credit"))
183+    if ((amount > user_credit))
184+        then throw(("sorry you can't withdraw this amount, because you have only " + toString(user_credit)))
185+        else {
186+            let new_user_credit = (user_credit - amount)
187+            let all_credit = tryGetInteger("usdn_all_credit")
188+            let new_all_credit = (all_credit - amount)
189+            let transaction_block =             match lastBlock.height {
190+                case a: Int => 
191+                    a
192+                case _ => 
193+                    throw("Error block number")
194+            }
195+            let res = invoke(Address(vires_dapp), "usdN_cancelStake", [amount], nil)
196+            if ((res == res))
197+                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)]
198+                else throw("Strict value is not equal to itself.")
199+            }
200+    }
201+
202+
203+
204+@Callable(i)
205+func sell_usdc_ticket (amount) = {
206+    let user_credit = tryGetInteger((("usdc_" + toString(i.originCaller)) + "_credit"))
207+    if ((amount > user_credit))
208+        then throw(("sorry you can't withdraw this amount, because u=you have only " + toString(user_credit)))
209+        else {
210+            let new_user_credit = (user_credit - amount)
211+            let all_credit = tryGetInteger("usdc_all_credit")
212+            let new_all_credit = (all_credit - amount)
213+            let transaction_block =             match lastBlock.height {
214+                case a: Int => 
215+                    a
216+                case _ => 
217+                    throw("Error block number")
218+            }
219+            let res = invoke(Address(vires_dapp), "usdC_cancelStake", [amount], nil)
220+            if ((res == res))
221+                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)]
222+                else throw("Strict value is not equal to itself.")
223+            }
224+    }
225+
226+
227+
228+@Callable(i)
229+func buy_waves_ticket (referral) = {
230+    let stop_most_func = tryGetString("stop_most_funactions")
231+    if ((stop_most_func != ""))
232+        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
233+        else if ((i.payments[0].assetId != waves))
234+            then throw("Please deposit Waves token only")
235+            else {
236+                let user_credit = tryGetInteger((("waves_" + toString(i.originCaller)) + "_credit"))
237+                let deposit_amount = i.payments[0].amount
238+                let new_user_credit = (user_credit + deposit_amount)
239+                let all_credit = tryGetInteger("waves_all_credit")
240+                let new_all_credit = (all_credit + deposit_amount)
241+                let transaction_block =                 match lastBlock.height {
242+                    case a: Int => 
243+                        a
244+                    case _ => 
245+                        throw("Error block number")
246+                }
247+                let res = invoke(Address(vires_dapp), "waves_stake", nil, [AttachedPayment(waves, deposit_amount)])
248+                if ((res == res))
249+                    then [StringEntry((("waves_" + toString(i.originCaller)) + "_referral"), referral), IntegerEntry((("waves_" + toString(i.originCaller)) + "_credit"), new_user_credit), IntegerEntry((("waves_" + toString(i.originCaller)) + "_block"), transaction_block), IntegerEntry("waves_all_credit", new_all_credit), IntegerEntry("waves_all_block", transaction_block)]
250+                    else throw("Strict value is not equal to itself.")
251+                }
252+    }
253+
254+
255+
256+@Callable(i)
257+func sell_waves_ticket (amount) = {
258+    let user_credit = tryGetInteger((("waves_" + toString(i.originCaller)) + "_credit"))
259+    if ((amount > user_credit))
260+        then throw(("sorry you can't withdraw this amount, because you have only " + toString(user_credit)))
261+        else {
262+            let new_user_credit = (user_credit - amount)
263+            let all_credit = tryGetInteger("waves_all_credit")
264+            let new_all_credit = (all_credit - amount)
265+            let transaction_block =             match lastBlock.height {
266+                case a: Int => 
267+                    a
268+                case _ => 
269+                    throw("Error block number")
270+            }
271+            let res = invoke(Address(vires_dapp), "waves_cancelStake", [amount], nil)
272+            if ((res == res))
273+                then [IntegerEntry((("waves_" + toString(i.originCaller)) + "_credit"), new_user_credit), IntegerEntry((("waves_" + toString(i.originCaller)) + "_block"), transaction_block), IntegerEntry("waves_all_credit", new_all_credit), IntegerEntry("waves_all_block", transaction_block)]
274+                else throw("Strict value is not equal to itself.")
275+            }
276+    }
277+
278+
279+
280+@Callable(i)
281+func usdn_calc_profit_amount () = {
282+    let stop_most_func = tryGetString("stop_most_funactions")
283+    if ((stop_most_func != ""))
284+        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
285+        else if ((toString(i.originCaller) != admin_wallet))
286+            then throw("Sorry! you are not allowed to use this funaction")
287+            else {
288+                let usdn_calc_profit_last_block = tryGetInteger("usdn_calc_profit_last_block")
289+                let usdn_profit_last_amount = tryGetInteger("usdn_profit_last_amount")
290+                let transaction_block =                 match lastBlock.height {
291+                    case a: Int => 
292+                        a
293+                    case _ => 
294+                        throw("Error block number")
295+                }
296+                let alfark = (transaction_block - usdn_calc_profit_last_block)
297+                if ((alfark_testnet > alfark))
298+                    then throw((("Please try again after " + toString((alfark_testnet - alfark))) + " block"))
299+                    else {
300+                        let usdn_balance = assetBalance(this, usdn)
301+[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")]
302+                        }
303+                }
304+    }
305+
306+
307+
308+@Callable(i)
309+func usdn_send_profit_amount () = {
310+    let stop_most_func = tryGetString("stop_most_funactions")
311+    if ((stop_most_func != ""))
312+        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
313+        else {
314+            let allow = check_send_if_allow("usdn")
315+            if ((allow != true))
316+                then throw("send is not allow for this token")
317+                else {
318+                    let usdn_profit_last_amount = tryGetInteger("usdn_profit_last_amount")
319+                    if ((0 >= usdn_profit_last_amount))
320+                        then throw(("you dont have profit amount " + toString(usdn_profit_last_amount)))
321+                        else {
322+                            let transfer = ScriptTransfer(addressFromStringValue(admin_wallet), usdn_profit_last_amount, usdn)
323+                            let transaction_block =                             match lastBlock.height {
324+                                case a: Int => 
325+                                    a
326+                                case _ => 
327+                                    throw("Error block number")
328+                            }
329+[transfer, IntegerEntry("usdn_profit_last_amount", 0), IntegerEntry("usdn_profit_last_block", transaction_block)]
330+                            }
331+                    }
332+            }
333+    }
334+
335+
336+
337+@Callable(i)
338+func usdc_calc_profit_amount () = {
339+    let stop_most_func = tryGetString("stop_most_funactions")
340+    if ((stop_most_func != ""))
341+        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
342+        else if ((toString(i.originCaller) != admin_wallet))
343+            then throw("Sorry! you are not allowed to use this funaction")
344+            else {
345+                let usdc_calc_profit_last_block = tryGetInteger("usdc_calc_profit_last_block")
346+                let usdc_profit_last_amount = tryGetInteger("usdc_profit_last_amount")
347+                let transaction_block =                 match lastBlock.height {
348+                    case a: Int => 
349+                        a
350+                    case _ => 
351+                        throw("Error block number")
352+                }
353+                let alfark = (transaction_block - usdc_calc_profit_last_block)
354+                if ((alfark_testnet > alfark))
355+                    then throw((("Please try again after " + toString((alfark_testnet - alfark))) + " block"))
356+                    else {
357+                        let usdc_balance = assetBalance(this, usdc)
358+[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")]
359+                        }
360+                }
361+    }
362+
363+
364+
365+@Callable(i)
366+func usdc_send_profit_amount () = {
367+    let stop_most_func = tryGetString("stop_most_funactions")
368+    if ((stop_most_func != ""))
369+        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
370+        else {
371+            let allow = check_send_if_allow("usdc")
372+            if ((allow != true))
373+                then throw("send is not allow for this token")
374+                else {
375+                    let usdc_profit_last_amount = tryGetInteger("usdc_profit_last_amount")
376+                    if ((0 >= usdc_profit_last_amount))
377+                        then throw(("you dont have profit amount " + toString(usdc_profit_last_amount)))
378+                        else {
379+                            let transfer = ScriptTransfer(addressFromStringValue(admin_wallet), usdc_profit_last_amount, usdc)
380+                            let transaction_block =                             match lastBlock.height {
381+                                case a: Int => 
382+                                    a
383+                                case _ => 
384+                                    throw("Error block number")
385+                            }
386+[transfer, IntegerEntry("usdc_profit_last_amount", 0), IntegerEntry("usdc_profit_last_block", transaction_block)]
387+                            }
388+                    }
389+            }
390+    }
391+
392+
393+
394+@Callable(i)
395+func waves_calc_profit_amount () = {
396+    let stop_most_func = tryGetString("stop_most_funactions")
397+    if ((stop_most_func != ""))
398+        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
399+        else if ((toString(i.originCaller) != admin_wallet))
400+            then throw("Sorry! you are not allowed to use this funaction")
401+            else {
402+                let waves_calc_profit_last_block = tryGetInteger("waves_calc_profit_last_block")
403+                let waves_profit_last_amount = tryGetInteger("waves_profit_last_amount")
404+                let transaction_block =                 match lastBlock.height {
405+                    case a: Int => 
406+                        a
407+                    case _ => 
408+                        throw("Error block number")
409+                }
410+                let alfark = (transaction_block - waves_calc_profit_last_block)
411+                if ((alfark_testnet > alfark))
412+                    then throw((("Please try again after " + toString((alfark_testnet - alfark))) + " block"))
413+                    else {
414+                        let waves_balance = assetBalance(this, waves)
415+[IntegerEntry("waves_calc_profit_last_block", transaction_block), IntegerEntry("waves_profit_last_amount", waves_balance), IntegerEntry("waves_profit_old_amount", waves_balance), StringEntry("waves_profit_is_allow_to_send", "yes")]
416+                        }
417+                }
418+    }
419+
420+
421+
422+@Callable(i)
423+func waves_send_profit_amount () = {
424+    let stop_most_func = tryGetString("stop_most_funactions")
425+    if ((stop_most_func != ""))
426+        then throw(("This DAPP has stopped , please use the new contract : " + stop_most_func))
427+        else {
428+            let allow = check_send_if_allow("waves")
429+            if ((allow != true))
430+                then throw("send is not allow for this token")
431+                else {
432+                    let waves_profit_last_amount = tryGetInteger("waves_profit_last_amount")
433+                    if ((0 >= waves_profit_last_amount))
434+                        then throw(("you dont have profit amount " + toString(waves_profit_last_amount)))
435+                        else {
436+                            let transfer = ScriptTransfer(addressFromStringValue(admin_wallet), waves_profit_last_amount, waves)
437+                            let transaction_block =                             match lastBlock.height {
438+                                case a: Int => 
439+                                    a
440+                                case _ => 
441+                                    throw("Error block number")
442+                            }
443+[transfer, IntegerEntry("waves_profit_last_amount", 0), IntegerEntry("waves_profit_last_block", transaction_block)]
444+                            }
445+                    }
446+            }
447+    }
448+
449+
450+
451+@Callable(i)
452+func stop_dapp (new_dapp) = {
453+    let stop_wallet_add = Address(stop_wallet)
454+    if ((i.caller != stop_wallet_add))
455+        then throw("you can't Invoke this funactios")
456+        else [StringEntry("stop_most_funactions", new_dapp)]
457+    }
458+
459+
460+
461+@Callable(i)
462+func start_dapp () = {
463+    let stop_wallet_add = Address(stop_wallet)
464+    if ((i.caller != stop_wallet_add))
465+        then throw("you can't Invoke this funactios")
466+        else [StringEntry("stop_most_funactions", "")]
467+    }
468+
469+
470+@Verifier(tx)
471+func verify () = {
472+    let result =     match tx {
473+        case TT: TransferTransaction => 
474+            sec_transfer_transaction(TT)
475+        case IST: InvokeScriptTransaction => 
476+            sec_invoke_script_transaction(IST)
477+        case _ => 
478+            false
479+    }
480+    if ((result == true))
481+        then sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
482+        else false
483+    }
484+
github/deemru/w8io/873ac7e 
30.85 ms ◑