tx · 8Cc7s47hmEqPnxKgmbAAdKHLX9P46WXccqyYmJ5qKme9

3MrtFvvc7QBGaNXke4B8T7brYidircMU8pM:  -0.01400000 Waves

2023.02.20 22:28 [2458391] smart account 3MrtFvvc7QBGaNXke4B8T7brYidircMU8pM > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8Cc7s47hmEqPnxKgmbAAdKHLX9P46WXccqyYmJ5qKme9",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1676921324343,
    "version": 2,
    "chainId": 84,
    "sender": "3MrtFvvc7QBGaNXke4B8T7brYidircMU8pM",
    "senderPublicKey": "A3DknTXNtQRgyx5yLE3L1YUXipPTqbF3qQrCvp8ZbFPq",
    "proofs": [
        "2FRRTFdABn6zW82fRaxCrnnf1ccFDxYgmo3g66j3vM67qTiFdBpsWmidhwC6Vuc6PgBpGHLnhRhwRvmZBTp7DreV"
    ],
    "script": "base64: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",
    "height": 2458391,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 98g6ysyspvsqMzmxGfteVXitHh5kAscTYcTWWL6mhG6q

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEPARATOR = "__"
5+
6+let KEY_INIT = "INIT"
7+
8+let KEY_MULTISIG = "MULTISIG"
9+
10+let KEY_STATUS = "STATUS"
11+
12+let KEY_PAUSED = "PAUSED"
13+
14+let KEY_PAUSER = "PAUSER"
15+
16+let KEY_EXECUTOR = "EXECUTOR"
17+
18+let KEY_ROOT_ADAPTER = "ROOT_ADAPTER"
19+
20+let KEY_CALLER_CONTRACT = "CALLER_CONTRACT"
21+
22+let KEY_CHAIN = "CHAIN"
23+
24+let KEY_BINDING = "BINDING"
25+
26+let KEY_FEE = "FEE"
27+
28+let KEY_FEE_CHAIN_ID = "FEE_CHAIN_ID"
29+
30+let KEY_FEE_RECIPIENT = "FEE_RECIPIENT"
31+
32+let FUNC_TAKE_TOKENS = "takeTokens"
33+
34+let WAVES = "WAVES"
35+
36+let WAVES_DECIMALS = 8
37+
38+let DECIMALS = 6
39+
40+let PERCENT_FACTOR = 1000000
41+
42+let MAX_INT = 9223372036854775807
43+
44+func _validateAddress (address_,err_) = match addressFromString(address_) {
45+    case a: Address => 
46+        true
47+    case _ => 
48+        throw(err_)
49+}
50+
51+
52+func _validateAsset (assetId_,err_) = match assetInfo(fromBase58String(assetId_)) {
53+    case a: Asset => 
54+        true
55+    case _ => 
56+        throw(err_)
57+}
58+
59+
60+func _validateInt (val_,lowerBoundary_,upperBoundary_,err_) = if (if ((lowerBoundary_ > val_))
61+    then true
62+    else (val_ > upperBoundary_))
63+    then throw(err_)
64+    else true
65+
66+
67+func _validateBool (val_,target_,err_) = if ((val_ != target_))
68+    then throw(err_)
69+    else true
70+
71+
72+func _validatePaymentsSize (payments_,target_,err_) = if ((size(payments_) != target_))
73+    then throw(err_)
74+    else true
75+
76+
77+func _validatePaymentAsset (payment_,asset_,err_) = if ((payment_.assetId != asset_))
78+    then throw(err_)
79+    else true
80+
81+
82+func _normalizeDecimals (amount_,sourceDecimals_,targetDecimals_) = if ((sourceDecimals_ >= targetDecimals_))
83+    then (amount_ / pow(10, 0, (sourceDecimals_ - targetDecimals_), 0, 0, DOWN))
84+    else (amount_ * pow(10, 0, (targetDecimals_ - sourceDecimals_), 0, 0, DOWN))
85+
86+
87+func _loadInit () = match getBoolean(KEY_INIT) {
88+    case a: Boolean => 
89+        a
90+    case _ => 
91+        false
92+}
93+
94+
95+func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
96+
97+
98+func _loadPause () = match getBoolean(KEY_PAUSED) {
99+    case a: Boolean => 
100+        a
101+    case _ => 
102+        false
103+}
104+
105+
106+func _savePause (isPaused_) = [BooleanEntry(KEY_PAUSED, isPaused_)]
107+
108+
109+func _loadPauser () = match getString(KEY_PAUSER) {
110+    case a: String => 
111+        addressFromStringValue(a)
112+    case _ => 
113+        Address(base58'')
114+}
115+
116+
117+func _savePauser (pauser_) = [StringEntry(KEY_PAUSER, toString(pauser_))]
118+
119+
120+func _loadMultisig () = match getString(KEY_MULTISIG) {
121+    case a: String => 
122+        addressFromStringValue(a)
123+    case _ => 
124+        Address(base58'')
125+}
126+
127+
128+func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
129+
130+
131+func _loadExecutor () = match getString(KEY_EXECUTOR) {
132+    case a: String => 
133+        addressFromStringValue(a)
134+    case _ => 
135+        Address(base58'')
136+}
137+
138+
139+func _saveExecutor (executor_) = [StringEntry(KEY_EXECUTOR, toString(executor_))]
140+
141+
142+func _loadCallerContract () = match getString(KEY_CALLER_CONTRACT) {
143+    case a: String => 
144+        a
145+    case _ => 
146+        ""
147+}
148+
149+
150+func _saveCallerContract (caller_) = [StringEntry(KEY_CALLER_CONTRACT, caller_)]
151+
152+
153+func _loadChain (chainId_) = match getBoolean(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR)) {
154+    case a: Boolean => 
155+        a
156+    case _ => 
157+        false
158+}
159+
160+
161+func _saveChain (chainId_,val_) = [BooleanEntry(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR), val_)]
162+
163+
164+func _loadBinding (executionChainId_,assetId_) = match getString(makeString([KEY_BINDING, toString(executionChainId_), toBase58String(assetId_)], SEPARATOR)) {
165+    case a: String => 
166+        let struct = split(a, SEPARATOR)
167+        $Tuple6(parseIntValue(struct[0]), parseIntValue(struct[1]), parseIntValue(struct[2]), parseIntValue(struct[3]), parseIntValue(struct[4]), if ((struct[5] == "1"))
168+            then true
169+            else false)
170+    case _ => 
171+        $Tuple6(0, 0, 0, 0, 0, false)
172+}
173+
174+
175+func _saveBinding (executionChainId_,assetId_,binding_) = [StringEntry(makeString([KEY_BINDING, toString(executionChainId_), toBase58String(assetId_)], SEPARATOR), makeString([toString(binding_._1), toString(binding_._2), toString(binding_._3), toString(binding_._4), toString(binding_._5), if (binding_._6)
176+    then "1"
177+    else "0"], SEPARATOR))]
178+
179+
180+func _loadFee (assetId_) = match getInteger(makeString([KEY_FEE, toBase58String(assetId_)], SEPARATOR)) {
181+    case a: Int => 
182+        a
183+    case _ => 
184+        0
185+}
186+
187+
188+func _saveFee (assetId_,val_) = [IntegerEntry(makeString([KEY_FEE, toBase58String(assetId_)], SEPARATOR), val_)]
189+
190+
191+func _loadRootAdapter () = match getString(KEY_ROOT_ADAPTER) {
192+    case a: String => 
193+        addressFromStringValue(a)
194+    case _ => 
195+        Address(base58'')
196+}
197+
198+
199+func _saveRootAdapter (adapter_) = [StringEntry(KEY_ROOT_ADAPTER, toString(adapter_))]
200+
201+
202+func _loadFeeChainId () = match getInteger(KEY_FEE_CHAIN_ID) {
203+    case a: Int => 
204+        a
205+    case _ => 
206+        0
207+}
208+
209+
210+func _saveFeeChainId (val_) = [IntegerEntry(KEY_FEE_CHAIN_ID, val_)]
211+
212+
213+func _loadFeeRecipient () = match getString(KEY_FEE_RECIPIENT) {
214+    case a: String => 
215+        a
216+    case _ => 
217+        ""
218+}
219+
220+
221+func _saveFeeRecipient (val_) = [StringEntry(KEY_FEE_RECIPIENT, val_)]
222+
223+
224+func _onlyThisContract (caller_) = if ((caller_ != this))
225+    then throw("_onlyThisContract: revert")
226+    else true
227+
228+
229+func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
230+    then throw("_whenMultisigSet: revert")
231+    else true
232+
233+
234+func _whenNotInitialized () = if (_loadInit())
235+    then throw("_whenNotInitialized: revert")
236+    else true
237+
238+
239+func _whenInitialized () = if (!(_loadInit()))
240+    then throw("_whenInitialized: revert")
241+    else true
242+
243+
244+func _whenNotPaused () = if (_loadPause())
245+    then throw("_whenNotPaused: revert")
246+    else true
247+
248+
249+func _whenPaused () = if (!(_loadPause()))
250+    then throw("_whenPaused: revert")
251+    else true
252+
253+
254+func _onlyPauser (caller_) = if ((caller_ != _loadPauser()))
255+    then throw("_onlyPauser: revert")
256+    else true
257+
258+
259+func _asInt (val_) = match val_ {
260+    case a: Int => 
261+        a
262+    case _ => 
263+        throw("_asInt: revert")
264+}
265+
266+
267+func _asBytes (val_) = match val_ {
268+    case a: ByteVector => 
269+        a
270+    case _ => 
271+        throw("_asBytes: revert")
272+}
273+
274+
275+func _validateExecutor (val_,err_) = if ((val_ != _loadExecutor()))
276+    then throw(err_)
277+    else true
278+
279+
280+func _validateCaller (val_,err_) = if ((val_ != _loadCallerContract()))
281+    then throw(err_)
282+    else true
283+
284+
285+func _validateChain (executionChainId_,err_) = if (!(_loadChain(executionChainId_)))
286+    then throw(err_)
287+    else true
288+
289+
290+@Callable(i)
291+func init (executor_,adapter_) = {
292+    let err = if (if (if (if (_onlyThisContract(i.caller))
293+        then _whenNotInitialized()
294+        else false)
295+        then _whenMultisigSet()
296+        else false)
297+        then _validateAddress(executor_, "init: invalid executor")
298+        else false)
299+        then _validateAddress(adapter_, "init: invalid adapter")
300+        else false
301+    if ((err == err))
302+        then $Tuple2(((_saveInit(true) ++ _saveExecutor(addressFromStringValue(executor_))) ++ _saveRootAdapter(addressFromStringValue(adapter_))), unit)
303+        else throw("Strict value is not equal to itself.")
304+    }
305+
306+
307+
308+@Callable(i)
309+func mintTokens (assetContract_,amount_,recipient_,gaslessReward_,referrer_,referrerFee_,callerContract_) = {
310+    let err = if (if (if (if (if (if (if (_whenInitialized())
311+        then _whenNotPaused()
312+        else false)
313+        then _validateAddress(assetContract_, "mint: invalid asset contract")
314+        else false)
315+        then _validateExecutor(i.caller, "mint: invalid executor")
316+        else false)
317+        then _validateCaller(callerContract_, "mint: invalid caller")
318+        else false)
319+        then _validateAddress(recipient_, "mint: invalid recipient address")
320+        else false)
321+        then _validateInt(amount_, 0, MAX_INT, "mint: invalid amount")
322+        else false)
323+        then _validateInt(gaslessReward_, 0, MAX_INT, "mint: invalid gaslessReward")
324+        else false
325+    if ((err == err))
326+        then {
327+            let assetId = _asBytes(invoke(addressFromStringValue(assetContract_), "getAssetId", nil, nil))
328+            if ((assetId == assetId))
329+                then {
330+                    let assetDecimals = _asInt(invoke(addressFromStringValue(assetContract_), "getDecimals", nil, nil))
331+                    if ((assetDecimals == assetDecimals))
332+                        then {
333+                            let normalizedAmount = _normalizeDecimals(amount_, DECIMALS, assetDecimals)
334+                            let normalizedGasless = _normalizeDecimals(gaslessReward_, DECIMALS, assetDecimals)
335+                            let referrer = if ((size(referrer_) > 0))
336+                                then {
337+                                    let err1 = if (_validateAddress(referrer_, "mint: invalid referrer address"))
338+                                        then _validateInt(referrerFee_, 0, MAX_INT, "mint: invalid referrer fee")
339+                                        else false
340+                                    if ((err1 == err1))
341+                                        then {
342+                                            let normalizedReferrerFee = _normalizeDecimals(referrerFee_, DECIMALS, assetDecimals)
343+                                            $Tuple2(normalizedReferrerFee, [ScriptTransfer(addressFromStringValue(referrer_), normalizedReferrerFee, assetId)])
344+                                            }
345+                                        else throw("Strict value is not equal to itself.")
346+                                    }
347+                                else $Tuple2(0, nil)
348+                            let referrerFee = referrer._1
349+                            let referrerActions = referrer._2
350+                            let invocation = invoke(addressFromStringValue(assetContract_), "mint", [(normalizedAmount + referrerFee), toString(this)], nil)
351+                            if ((invocation == invocation))
352+                                then {
353+                                    let actions = if (if ((normalizedGasless > 0))
354+                                        then (addressFromStringValue(recipient_) != i.originCaller)
355+                                        else false)
356+                                        then [ScriptTransfer(addressFromStringValue(recipient_), (normalizedAmount - normalizedGasless), assetId), ScriptTransfer(i.originCaller, normalizedGasless, assetId)]
357+                                        else [ScriptTransfer(addressFromStringValue(recipient_), normalizedAmount, assetId)]
358+                                    $Tuple2((actions ++ referrerActions), unit)
359+                                    }
360+                                else throw("Strict value is not equal to itself.")
361+                            }
362+                        else throw("Strict value is not equal to itself.")
363+                    }
364+                else throw("Strict value is not equal to itself.")
365+            }
366+        else throw("Strict value is not equal to itself.")
367+    }
368+
369+
370+
371+@Callable(i)
372+func burnTokens (assetContract_,amount_,executionChainId_,recipient_,gaslessReward_,referrer_) = {
373+    let err = if (if (if (if (if (_whenInitialized())
374+        then _whenNotPaused()
375+        else false)
376+        then _validateAddress(assetContract_, "burn: invalid asset contract")
377+        else false)
378+        then _validateChain(executionChainId_, "burn: invalid execution chain")
379+        else false)
380+        then _validatePaymentsSize(i.payments, 1, "burn: no payment")
381+        else false)
382+        then _validateInt(i.payments[0].amount, amount_, MAX_INT, "burn: invalid payment amount")
383+        else false
384+    if ((err == err))
385+        then {
386+            let assetId = _asBytes(invoke(addressFromStringValue(assetContract_), "getAssetId", nil, nil))
387+            if ((assetId == assetId))
388+                then {
389+                    let assetDecimals = _asInt(invoke(addressFromStringValue(assetContract_), "getDecimals", nil, nil))
390+                    if ((assetDecimals == assetDecimals))
391+                        then {
392+                            let binding = _loadBinding(executionChainId_, assetId)
393+                            let minAmount = binding._1
394+                            let minFee = binding._2
395+                            let thresholdFee = binding._3
396+                            let beforePercentFee = binding._4
397+                            let afterPercentFee = binding._5
398+                            let enabled = binding._6
399+                            let err1 = if (if (_validatePaymentAsset(i.payments[0], assetId, "burn: invalid payment asset"))
400+                                then _validateInt(amount_, minAmount, MAX_INT, "burn: less than min")
401+                                else false)
402+                                then _validateBool(enabled, true, "burn: token is disabled")
403+                                else false
404+                            if ((err1 == err1))
405+                                then {
406+                                    let percent = if ((amount_ > thresholdFee))
407+                                        then afterPercentFee
408+                                        else beforePercentFee
409+                                    let fee = (minFee + ((amount_ * percent) / PERCENT_FACTOR))
410+                                    let err2 = _validateInt(amount_, (fee + 1), MAX_INT, "burn: fee more than amount")
411+                                    if ((err2 == err2))
412+                                        then {
413+                                            let amountToSend = (amount_ - fee)
414+                                            let err3 = _validateInt(amountToSend, (gaslessReward_ + 1), MAX_INT, "burn: reward more than amount")
415+                                            if ((err3 == err3))
416+                                                then {
417+                                                    let updateFee = (_loadFee(assetId) + fee)
418+                                                    let normalizedAmount = _normalizeDecimals(amountToSend, assetDecimals, DECIMALS)
419+                                                    let normalizedGasless = _normalizeDecimals(gaslessReward_, assetDecimals, DECIMALS)
420+                                                    let invocation = invoke(_loadRootAdapter(), FUNC_TAKE_TOKENS, [executionChainId_, assetContract_, normalizedAmount, recipient_, normalizedGasless, referrer_], nil)
421+                                                    if ((invocation == invocation))
422+                                                        then $Tuple2((_saveFee(assetId, updateFee) ++ [Burn(assetId, amount_)]), unit)
423+                                                        else throw("Strict value is not equal to itself.")
424+                                                    }
425+                                                else throw("Strict value is not equal to itself.")
426+                                            }
427+                                        else throw("Strict value is not equal to itself.")
428+                                    }
429+                                else throw("Strict value is not equal to itself.")
430+                            }
431+                        else throw("Strict value is not equal to itself.")
432+                    }
433+                else throw("Strict value is not equal to itself.")
434+            }
435+        else throw("Strict value is not equal to itself.")
436+    }
437+
438+
439+
440+@Callable(i)
441+func updateCallerContract (callerContract_) = {
442+    let err = if (_onlyThisContract(i.caller))
443+        then _whenInitialized()
444+        else false
445+    if ((err == err))
446+        then $Tuple2(_saveCallerContract(callerContract_), unit)
447+        else throw("Strict value is not equal to itself.")
448+    }
449+
450+
451+
452+@Callable(i)
453+func updateExecutionChain (executionChainId_,enabled_) = {
454+    let err = if (if (_onlyThisContract(i.caller))
455+        then _whenInitialized()
456+        else false)
457+        then _validateInt(executionChainId_, 0, MAX_INT, "updateExecutionChain: invalid executionChainId")
458+        else false
459+    if ((err == err))
460+        then $Tuple2(_saveChain(executionChainId_, enabled_), unit)
461+        else throw("Strict value is not equal to itself.")
462+    }
463+
464+
465+
466+@Callable(i)
467+func updateFeeChain (feeChainId_) = {
468+    let err = if (if (_onlyThisContract(i.caller))
469+        then _whenInitialized()
470+        else false)
471+        then _validateInt(feeChainId_, 0, MAX_INT, "updateFeeChain: invalid feeChainId")
472+        else false
473+    if ((err == err))
474+        then $Tuple2(_saveFeeChainId(feeChainId_), unit)
475+        else throw("Strict value is not equal to itself.")
476+    }
477+
478+
479+
480+@Callable(i)
481+func updateFeeRecipient (feeRecipient_) = {
482+    let err = if (_onlyThisContract(i.caller))
483+        then _whenInitialized()
484+        else false
485+    if ((err == err))
486+        then $Tuple2(_saveFeeRecipient(feeRecipient_), unit)
487+        else throw("Strict value is not equal to itself.")
488+    }
489+
490+
491+
492+@Callable(i)
493+func updateBindingInfo (assetContract_,executionChainId_,minAmount_,minFee_,thresholdFee_,beforePercentFee_,afterPercentFee_,enabled_) = {
494+    let err = if (if (if (if (if (if (if (if (_onlyThisContract(i.caller))
495+        then _whenInitialized()
496+        else false)
497+        then _validateAddress(assetContract_, "updateBindingInfo: invalid asset contract")
498+        else false)
499+        then _validateInt(executionChainId_, 0, MAX_INT, "updateBindingInfo: invalid executionChainId")
500+        else false)
501+        then _validateInt(minAmount_, 0, MAX_INT, "updateBindingInfo: invalid minAmount")
502+        else false)
503+        then _validateInt(minFee_, 0, MAX_INT, "updateBindingInfo: invalid minFee")
504+        else false)
505+        then _validateInt(thresholdFee_, 0, MAX_INT, "updateBindingInfo: invalid thresholdFee")
506+        else false)
507+        then _validateInt(beforePercentFee_, 0, MAX_INT, "updateBindingInfo: invalid beforePercentFee")
508+        else false)
509+        then _validateInt(afterPercentFee_, 0, MAX_INT, "updateBindingInfo: invalid afterPercentFee")
510+        else false
511+    if ((err == err))
512+        then {
513+            let assetId = _asBytes(invoke(addressFromStringValue(assetContract_), "getAssetId", nil, nil))
514+            if ((assetId == assetId))
515+                then {
516+                    let binding = $Tuple6(minAmount_, minFee_, thresholdFee_, beforePercentFee_, afterPercentFee_, enabled_)
517+                    $Tuple2(_saveBinding(executionChainId_, assetId, binding), unit)
518+                    }
519+                else throw("Strict value is not equal to itself.")
520+            }
521+        else throw("Strict value is not equal to itself.")
522+    }
523+
524+
525+
526+@Callable(i)
527+func setMultisig (multisig_) = {
528+    let err = if (_onlyThisContract(i.caller))
529+        then _validateAddress(multisig_, "setMultisig: invalid multisig")
530+        else false
531+    if ((err == err))
532+        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
533+        else throw("Strict value is not equal to itself.")
534+    }
535+
536+
537+@Verifier(tx)
538+func verify () = match getString(KEY_MULTISIG) {
539+    case multisig: String => 
540+        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
541+    case _ => 
542+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
543+}
544+
github/deemru/w8io/873ac7e 
27.78 ms ◑