tx · HMAq7WPmcrGKxzdCZmhjKXEo8UGhMfyHA4cAWciiGjti

3N6riweA9GFQVMVx8Y2qob5FkRDw9iJ2ixC:  -0.01100000 Waves

2022.09.11 20:32 [2224739] smart account 3N6riweA9GFQVMVx8Y2qob5FkRDw9iJ2ixC > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HMAq7WPmcrGKxzdCZmhjKXEo8UGhMfyHA4cAWciiGjti",
    "fee": 1100000,
    "feeAssetId": null,
    "timestamp": 1662917600158,
    "version": 2,
    "chainId": 84,
    "sender": "3N6riweA9GFQVMVx8Y2qob5FkRDw9iJ2ixC",
    "senderPublicKey": "6SRJBFaBG88AUNGzMxjLMwpALr3ewnhyLJ2WYLM9TgRi",
    "proofs": [
        "23E9xYinc9gQrJ7VeLECYJd4JhBZvRUfPBtyJpWCX8Vcwp67uMwZbD5Mzf4LYiKqrBzRodvgc7vsYtVkFop7d6eB"
    ],
    "script": "base64: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",
    "height": 2224739,
    "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 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+
345+@Callable(i)
346+func start_dapp () = {
347+    let stop_wallet_add = Address(stop_wallet)
348+    if ((i.caller != stop_wallet_add))
349+        then throw("you can't Invoke this funactios")
350+        else [StringEntry("stop_most_funactions", "")]
351+    }
352+
353+
354+@Verifier(tx)
355+func verify () = {
356+    let result =     match tx {
357+        case TT: TransferTransaction => 
358+            sec_transfer_transaction(TT)
359+        case IST: InvokeScriptTransaction => 
360+            sec_invoke_script_transaction(IST)
361+        case _ => 
362+            false
363+    }
364+    if ((result == true))
365+        then sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
366+        else false
367+    }
368+
github/deemru/w8io/c3f4982 
40.12 ms ◑