tx · EpS4jW9vMhhdE8HA1gCHTfYcXA8SczjmdXDNMRY3zthk

3PFPuctNkdbwGKKUNymWw816jGPexHzGXW5:  -0.01800000 Waves

2023.08.01 14:23 [3757082] smart account 3PFPuctNkdbwGKKUNymWw816jGPexHzGXW5 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EpS4jW9vMhhdE8HA1gCHTfYcXA8SczjmdXDNMRY3zthk",
    "fee": 1800000,
    "feeAssetId": null,
    "timestamp": 1690889037167,
    "version": 2,
    "chainId": 87,
    "sender": "3PFPuctNkdbwGKKUNymWw816jGPexHzGXW5",
    "senderPublicKey": "DXuakuc1KLTEyYDAtYiNBVDKWa2mxRmnfBFxocD8WeW3",
    "proofs": [
        "pXYmZP6xTNYgmGn6HRaki1uDeCxhHrhN7Wdoib2N7S5mp7s58T82cpQhCCYNnuTFc4pL5UgbSw1F4oztmmp4wM2"
    ],
    "script": "base64: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",
    "height": 3757082,
    "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 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_BALANCE = "BALANCE"
29+
30+let KEY_FEE_RECIPIENT = "FEE_RECIPIENT"
31+
32+let KEY_REFERRER_FEE_PERCENT = "REFERRER_FEE_PERCENT"
33+
34+let KEY_SWAVES_CONTRACT = "SWAVES_CONTRACT"
35+
36+let KEY_SWAVES_ASSET = "ASSET"
37+
38+let FUNC_MINT_TOKENS = "mintTokens"
39+
40+let FUNC_DEPOSIT = "deposit"
41+
42+let FUNC_GET_RATE = "getRate"
43+
44+let FUNC_WITHDRAW = "withdraw"
45+
46+let WAVES = "WAVES"
47+
48+let WAVES_BYTES = base58'WAVES'
49+
50+let WAVES_DECIMALS = 8
51+
52+let DECIMALS = 6
53+
54+let PERCENT_FACTOR = 1000000
55+
56+let SWAVES_RATE_FACTOR = toBigInt(1000000000000)
57+
58+let MAX_REFERRER_FEE = 200000
59+
60+let MAX_INT = 9223372036854775807
61+
62+func _validateAddress (address_,err_) = match addressFromString(address_) {
63+    case a: Address => 
64+        true
65+    case _ => 
66+        throw(err_)
67+}
68+
69+
70+func _validateAsset (assetId_,err_) = match assetInfo(fromBase58String(assetId_)) {
71+    case a: Asset => 
72+        true
73+    case _ => 
74+        throw(err_)
75+}
76+
77+
78+func _validateInt (val_,lowerBoundary_,upperBoundary_,err_) = if (if ((lowerBoundary_ > val_))
79+    then true
80+    else (val_ > upperBoundary_))
81+    then throw(err_)
82+    else true
83+
84+
85+func _validateBool (val_,target_,err_) = if ((val_ != target_))
86+    then throw(err_)
87+    else true
88+
89+
90+func _validateString (val_,err_) = if (if ((0 >= size(val_)))
91+    then true
92+    else contains(val_, SEPARATOR))
93+    then throw(err_)
94+    else true
95+
96+
97+func _validatePaymentsSize (payments_,target_,err_) = if ((size(payments_) != target_))
98+    then throw(err_)
99+    else true
100+
101+
102+func _validateWavesAsset (assetId_,err_) = match assetId_ {
103+    case _: ByteVector => 
104+        throw(err_)
105+    case _: Unit => 
106+        true
107+    case _ => 
108+        throw("Match error")
109+}
110+
111+
112+func _validateReferrer (referrer_,err_) = if ((referrer_ != ""))
113+    then _validateAddress(referrer_, err_)
114+    else true
115+
116+
117+func _normalizeDecimals (amount_,sourceDecimals_,targetDecimals_) = if ((sourceDecimals_ >= targetDecimals_))
118+    then (amount_ / pow(10, 0, (sourceDecimals_ - targetDecimals_), 0, 0, DOWN))
119+    else (amount_ * pow(10, 0, (targetDecimals_ - sourceDecimals_), 0, 0, DOWN))
120+
121+
122+func _loadInit () = match getBoolean(KEY_INIT) {
123+    case a: Boolean => 
124+        a
125+    case _ => 
126+        false
127+}
128+
129+
130+func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
131+
132+
133+func _loadPause () = match getBoolean(KEY_PAUSED) {
134+    case a: Boolean => 
135+        a
136+    case _ => 
137+        false
138+}
139+
140+
141+func _savePause (isPaused_) = [BooleanEntry(KEY_PAUSED, isPaused_)]
142+
143+
144+func _loadPauser () = match getString(KEY_PAUSER) {
145+    case a: String => 
146+        addressFromStringValue(a)
147+    case _ => 
148+        Address(base58'')
149+}
150+
151+
152+func _savePauser (pauser_) = [StringEntry(KEY_PAUSER, toString(pauser_))]
153+
154+
155+func _loadMultisig () = match getString(KEY_MULTISIG) {
156+    case a: String => 
157+        addressFromStringValue(a)
158+    case _ => 
159+        Address(base58'')
160+}
161+
162+
163+func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
164+
165+
166+func _loadExecutor () = match getString(KEY_EXECUTOR) {
167+    case a: String => 
168+        addressFromStringValue(a)
169+    case _ => 
170+        Address(base58'')
171+}
172+
173+
174+func _saveExecutor (executor_) = [StringEntry(KEY_EXECUTOR, toString(executor_))]
175+
176+
177+func _loadCallerContract () = match getString(KEY_CALLER_CONTRACT) {
178+    case a: String => 
179+        a
180+    case _ => 
181+        ""
182+}
183+
184+
185+func _saveCallerContract (caller_) = [StringEntry(KEY_CALLER_CONTRACT, caller_)]
186+
187+
188+func _loadChain (chainId_) = match getBoolean(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR)) {
189+    case a: Boolean => 
190+        a
191+    case _ => 
192+        false
193+}
194+
195+
196+func _saveChain (chainId_,val_) = [BooleanEntry(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR), val_)]
197+
198+
199+func _loadBinding (executionChainId_) = match getString(makeString([KEY_BINDING, toString(executionChainId_)], SEPARATOR)) {
200+    case a: String => 
201+        let struct = split(a, SEPARATOR)
202+        $Tuple7(struct[0], parseIntValue(struct[1]), parseIntValue(struct[2]), parseIntValue(struct[3]), parseIntValue(struct[4]), parseIntValue(struct[5]), if ((struct[6] == "1"))
203+            then true
204+            else false)
205+    case _ => 
206+        $Tuple7("", 0, 0, 0, 0, 0, false)
207+}
208+
209+
210+func _saveBinding (executionChainId_,binding_) = [StringEntry(makeString([KEY_BINDING, toString(executionChainId_)], SEPARATOR), makeString([binding_._1, toString(binding_._2), toString(binding_._3), toString(binding_._4), toString(binding_._5), toString(binding_._6), if (binding_._7)
211+    then "1"
212+    else "0"], SEPARATOR))]
213+
214+
215+func _loadFee () = match getInteger(KEY_FEE) {
216+    case a: Int => 
217+        a
218+    case _ => 
219+        0
220+}
221+
222+
223+func _saveFee (val_) = [IntegerEntry(KEY_FEE, val_)]
224+
225+
226+func _loadBalance () = match getInteger(KEY_BALANCE) {
227+    case a: Int => 
228+        a
229+    case _ => 
230+        0
231+}
232+
233+
234+func _saveBalance (val_) = [IntegerEntry(KEY_BALANCE, val_)]
235+
236+
237+func _loadRootAdapter () = match getString(KEY_ROOT_ADAPTER) {
238+    case a: String => 
239+        addressFromStringValue(a)
240+    case _ => 
241+        Address(base58'')
242+}
243+
244+
245+func _saveRootAdapter (adapter_) = [StringEntry(KEY_ROOT_ADAPTER, toString(adapter_))]
246+
247+
248+func _loadFeeRecipient () = match getString(KEY_FEE_RECIPIENT) {
249+    case a: String => 
250+        addressFromStringValue(a)
251+    case _ => 
252+        Address(base58'')
253+}
254+
255+
256+func _saveFeeRecipient (val_) = [StringEntry(KEY_FEE_RECIPIENT, toString(val_))]
257+
258+
259+func _loadReferrerFeePercent (executionChainId_,referrer_) = match getInteger(makeString([KEY_REFERRER_FEE_PERCENT, toString(executionChainId_), toString(referrer_)], SEPARATOR)) {
260+    case a: Int => 
261+        a
262+    case _ => 
263+        0
264+}
265+
266+
267+func _saveReferrerFeePercent (executionChainId_,referrer_,val_) = [IntegerEntry(makeString([KEY_REFERRER_FEE_PERCENT, toString(executionChainId_), toString(referrer_)], SEPARATOR), val_)]
268+
269+
270+func _loadSWavesContract () = match getString(KEY_SWAVES_CONTRACT) {
271+    case a: String => 
272+        addressFromStringValue(a)
273+    case _ => 
274+        Address(base58'')
275+}
276+
277+
278+func _saveSWavesContract (contract_) = [StringEntry(KEY_SWAVES_CONTRACT, toString(contract_))]
279+
280+
281+func _loadSWavesAsset (contract_) = match getString(contract_, KEY_SWAVES_ASSET) {
282+    case a: String => 
283+        fromBase58String(a)
284+    case _ => 
285+        throw("_loadSWavesAsset: revert")
286+}
287+
288+
289+func _onlyThisContract (caller_) = if ((caller_ != this))
290+    then throw("_onlyThisContract: revert")
291+    else true
292+
293+
294+func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
295+    then throw("_whenMultisigSet: revert")
296+    else true
297+
298+
299+func _whenNotInitialized () = if (_loadInit())
300+    then throw("_whenNotInitialized: revert")
301+    else true
302+
303+
304+func _whenInitialized () = if (!(_loadInit()))
305+    then throw("_whenInitialized: revert")
306+    else true
307+
308+
309+func _whenNotPaused () = if (_loadPause())
310+    then throw("_whenNotPaused: revert")
311+    else true
312+
313+
314+func _whenPaused () = if (!(_loadPause()))
315+    then throw("_whenPaused: revert")
316+    else true
317+
318+
319+func _onlyPauser (caller_) = if ((caller_ != _loadPauser()))
320+    then throw("_onlyPauser: revert")
321+    else true
322+
323+
324+func _asInt (val_) = match val_ {
325+    case a: Int => 
326+        a
327+    case _ => 
328+        throw("_asInt: revert")
329+}
330+
331+
332+func _asBytes (val_) = match val_ {
333+    case a: ByteVector => 
334+        a
335+    case _ => 
336+        throw("_asBytes: revert")
337+}
338+
339+
340+func _validateExecutor (val_,err_) = if ((val_ != _loadExecutor()))
341+    then throw(err_)
342+    else true
343+
344+
345+func _validateCaller (val_,err_) = if ((val_ != _loadCallerContract()))
346+    then throw(err_)
347+    else true
348+
349+
350+func _validateChain (executionChainId_,err_) = if (!(_loadChain(executionChainId_)))
351+    then throw(err_)
352+    else true
353+
354+
355+@Callable(i)
356+func init (executor_,adapter_,pauser_,feeRecipient_,sWavesContract_) = {
357+    let err = if (if (if (if (if (if (if (_onlyThisContract(i.caller))
358+        then _whenNotInitialized()
359+        else false)
360+        then _whenMultisigSet()
361+        else false)
362+        then _validateAddress(executor_, "init: invalid executor")
363+        else false)
364+        then _validateAddress(adapter_, "init: invalid adapter")
365+        else false)
366+        then _validateAddress(pauser_, "init: invalid pauser")
367+        else false)
368+        then _validateAddress(feeRecipient_, "init: invalid feeRecipient")
369+        else false)
370+        then _validateAddress(sWavesContract_, "init: invalid swavesContract")
371+        else false
372+    if ((err == err))
373+        then $Tuple2((((((_saveInit(true) ++ _saveExecutor(addressFromStringValue(executor_))) ++ _saveRootAdapter(addressFromStringValue(adapter_))) ++ _savePauser(addressFromStringValue(pauser_))) ++ _saveFeeRecipient(addressFromStringValue(feeRecipient_))) ++ _saveSWavesContract(addressFromStringValue(sWavesContract_))), unit)
374+        else throw("Strict value is not equal to itself.")
375+    }
376+
377+
378+
379+@Callable(i)
380+func lockTokens (executionChainId_,recipient_,referrer_,gaslessReward_) = {
381+    let err = if (if (if (if (if (if (if (_whenInitialized())
382+        then _whenNotPaused()
383+        else false)
384+        then _validateChain(executionChainId_, "lockTokens: invalid execution chain")
385+        else false)
386+        then _validatePaymentsSize(i.payments, 1, "lockTokens: no payment")
387+        else false)
388+        then _validateInt(gaslessReward_, 0, MAX_INT, "lockTokens: invalid gaslessReward")
389+        else false)
390+        then _validateInt(i.payments[0].amount, 0, MAX_INT, "lockTokens: invalid payment amount")
391+        else false)
392+        then _validateWavesAsset(i.payments[0].assetId, "lockTokens: invalid asset")
393+        else false)
394+        then _validateReferrer(referrer_, "lockTokens: invalid referrer")
395+        else false
396+    if ((err == err))
397+        then {
398+            let amount = i.payments[0].amount
399+            let binding = _loadBinding(executionChainId_)
400+            let executionAsset = binding._1
401+            let minAmount = binding._2
402+            let minFee = binding._3
403+            let thresholdFee = binding._4
404+            let beforePercentFee = binding._5
405+            let afterPercentFee = binding._6
406+            let enabled = binding._7
407+            let err1 = if (if (_validateString(executionAsset, "lockTokens: no such binding"))
408+                then _validateInt(amount, minAmount, MAX_INT, "lockTokens: less than min")
409+                else false)
410+                then _validateBool(enabled, true, "lockTokens: token is disabled")
411+                else false
412+            if ((err1 == err1))
413+                then {
414+                    let percent = if ((amount > thresholdFee))
415+                        then afterPercentFee
416+                        else beforePercentFee
417+                    let fee = (minFee + fraction(amount, percent, PERCENT_FACTOR))
418+                    let err2 = _validateInt(amount, (fee + 1), MAX_INT, "lockTokens: fee more than amount")
419+                    if ((err2 == err2))
420+                        then {
421+                            let $t01208212484 = if ((referrer_ != ""))
422+                                then {
423+                                    let referrer = addressFromStringValue(referrer_)
424+                                    let referrerFeeAmount = fraction(_loadReferrerFeePercent(executionChainId_, referrer), fee, PERCENT_FACTOR)
425+                                    $Tuple2(referrerFeeAmount, [ScriptTransfer(referrer, referrerFeeAmount, unit)])
426+                                    }
427+                                else $Tuple2(0, nil)
428+                            let referrerFee = $t01208212484._1
429+                            let referrerActions = $t01208212484._2
430+                            let amountToSend = (amount - fee)
431+                            let err3 = _validateInt(amountToSend, (gaslessReward_ + 1), MAX_INT, "lockTokens: reward more than amount")
432+                            if ((err3 == err3))
433+                                then {
434+                                    let amountToFee = (fee - referrerFee)
435+                                    let normalizedAmount = _normalizeDecimals(amountToSend, WAVES_DECIMALS, DECIMALS)
436+                                    let normalizedGasless = _normalizeDecimals(gaslessReward_, WAVES_DECIMALS, DECIMALS)
437+                                    let invocation = invoke(_loadRootAdapter(), FUNC_MINT_TOKENS, [executionChainId_, executionAsset, normalizedAmount, recipient_, normalizedGasless], nil)
438+                                    if ((invocation == invocation))
439+                                        then {
440+                                            let invocation1 = invoke(_loadSWavesContract(), FUNC_DEPOSIT, nil, [AttachedPayment(unit, (amountToSend + amountToFee))])
441+                                            if ((invocation1 == invocation1))
442+                                                then $Tuple2(((_saveFee((_loadFee() + amountToFee)) ++ _saveBalance((_loadBalance() + amountToSend))) ++ referrerActions), unit)
443+                                                else throw("Strict value is not equal to itself.")
444+                                            }
445+                                        else throw("Strict value is not equal to itself.")
446+                                    }
447+                                else throw("Strict value is not equal to itself.")
448+                            }
449+                        else throw("Strict value is not equal to itself.")
450+                    }
451+                else throw("Strict value is not equal to itself.")
452+            }
453+        else throw("Strict value is not equal to itself.")
454+    }
455+
456+
457+
458+@Callable(i)
459+func releaseTokens (callerContract_,amount_,recipient_,gaslessReward_,referrer_,referrerFee_) = {
460+    let amount = valueOrErrorMessage(parseInt(amount_), "releaseTokens: amount is not Int")
461+    let gaslessReward = valueOrErrorMessage(parseInt(gaslessReward_), "releaseTokens: gaslessReward is not Int")
462+    let referrerFee = valueOrErrorMessage(parseInt(referrerFee_), "releaseTokens: referrerFee is not Int")
463+    let err = if (if (if (if (if (if (if (_whenInitialized())
464+        then _whenNotPaused()
465+        else false)
466+        then _validateExecutor(i.caller, "releaseTokens: invalid executor")
467+        else false)
468+        then _validateCaller(callerContract_, "releaseTokens: invalid caller")
469+        else false)
470+        then _validateAddress(recipient_, "releaseTokens: invalid recipient address")
471+        else false)
472+        then _validateInt(amount, 0, MAX_INT, "releaseTokens: invalid amount")
473+        else false)
474+        then _validateInt(gaslessReward, 0, MAX_INT, "releaseTokens: invalid gaslessReward")
475+        else false)
476+        then _validateInt(referrerFee, 0, MAX_INT, "releaseTokens: invalid referrer fee")
477+        else false
478+    if ((err == err))
479+        then {
480+            let normalizedAmount = _normalizeDecimals(amount, DECIMALS, WAVES_DECIMALS)
481+            let normalizedGasless = _normalizeDecimals(gaslessReward, DECIMALS, WAVES_DECIMALS)
482+            let $t01459215032 =             match addressFromString(referrer_) {
483+                case refererAddress: Address => 
484+                    let normalizedReferrerFee = _normalizeDecimals(referrerFee, DECIMALS, WAVES_DECIMALS)
485+                    $Tuple2(normalizedReferrerFee, [ScriptTransfer(refererAddress, normalizedReferrerFee, unit)])
486+                case _ => 
487+                    $Tuple2(0, nil)
488+            }
489+            let normalizedReferrerFee = $t01459215032._1
490+            let referrerActions = $t01459215032._2
491+            let sWavesContract = _loadSWavesContract()
492+            let sWavesAsset = _loadSWavesAsset(sWavesContract)
493+            let invocation = invoke(sWavesContract, FUNC_GET_RATE, nil, nil)
494+            let rate =             match invocation {
495+                case a: String => 
496+                    parseBigIntValue(a)
497+                case _ => 
498+                    throw("releaseTokens: sWaves getRate() revert")
499+            }
500+            let sWavesToWithdraw = toInt(fraction(toBigInt((normalizedAmount + normalizedReferrerFee)), SWAVES_RATE_FACTOR, rate, CEILING))
501+            let invocation1 = invoke(sWavesContract, FUNC_WITHDRAW, nil, [AttachedPayment(sWavesAsset, sWavesToWithdraw)])
502+            if ((invocation1 == invocation1))
503+                then {
504+                    let actions = if (if ((normalizedGasless > 0))
505+                        then (addressFromStringValue(recipient_) != i.originCaller)
506+                        else false)
507+                        then [ScriptTransfer(addressFromStringValue(recipient_), (normalizedAmount - normalizedGasless), unit), ScriptTransfer(i.originCaller, normalizedGasless, unit)]
508+                        else [ScriptTransfer(addressFromStringValue(recipient_), normalizedAmount, unit)]
509+                    $Tuple2(((_saveBalance(((_loadBalance() - normalizedAmount) - normalizedReferrerFee)) ++ actions) ++ referrerActions), unit)
510+                    }
511+                else throw("Strict value is not equal to itself.")
512+            }
513+        else throw("Strict value is not equal to itself.")
514+    }
515+
516+
517+
518+@Callable(i)
519+func transferFee (executionChainId_) = {
520+    let err = if (_whenInitialized())
521+        then _whenNotPaused()
522+        else false
523+    if ((err == err))
524+        then {
525+            let binding = _loadBinding(executionChainId_)
526+            let executionAsset = binding._1
527+            let enabled = binding._7
528+            let err1 = if (_validateString(executionAsset, "transferFee: no such binding"))
529+                then _validateBool(enabled, true, "transferFee: token is disabled")
530+                else false
531+            if ((err1 == err1))
532+                then {
533+                    let feeAmount = _loadFee()
534+                    let sWavesContract = _loadSWavesContract()
535+                    let sWavesAsset = _loadSWavesAsset(sWavesContract)
536+                    let invocation = invoke(sWavesContract, FUNC_GET_RATE, nil, nil)
537+                    let rate =                     match invocation {
538+                        case a: String => 
539+                            parseBigIntValue(a)
540+                        case _ => 
541+                            throw("transferFee: sWaves getRate() revert")
542+                    }
543+                    let balanceOfSWaves = assetBalance(this, sWavesAsset)
544+                    let wavesCollateral = _loadBalance()
545+                    let sWavesCollateral = toInt(fraction(toBigInt(wavesCollateral), SWAVES_RATE_FACTOR, rate, CEILING))
546+                    let $t01721017563 = if ((balanceOfSWaves > sWavesCollateral))
547+                        then {
548+                            let sWavesToWithdraw = (balanceOfSWaves - sWavesCollateral)
549+                            let wavesFee = toInt(fraction(toBigInt((balanceOfSWaves - sWavesCollateral)), rate, SWAVES_RATE_FACTOR, FLOOR))
550+                            $Tuple2(sWavesToWithdraw, wavesFee)
551+                            }
552+                        else $Tuple2(0, 0)
553+                    let sWavesToWithdraw = $t01721017563._1
554+                    let wavesFee = $t01721017563._2
555+                    let feeAmountUpdated = if ((feeAmount > wavesFee))
556+                        then (feeAmount - wavesFee)
557+                        else 0
558+                    let invocation1 = invoke(sWavesContract, FUNC_WITHDRAW, nil, [AttachedPayment(sWavesAsset, sWavesToWithdraw)])
559+                    if ((invocation1 == invocation1))
560+                        then $Tuple2((_saveFee(feeAmountUpdated) ++ [ScriptTransfer(_loadFeeRecipient(), wavesFee, unit)]), unit)
561+                        else throw("Strict value is not equal to itself.")
562+                    }
563+                else throw("Strict value is not equal to itself.")
564+            }
565+        else throw("Strict value is not equal to itself.")
566+    }
567+
568+
569+
570+@Callable(i)
571+func updateCallerContract (callerContract_) = {
572+    let err = if (_onlyThisContract(i.caller))
573+        then _whenInitialized()
574+        else false
575+    if ((err == err))
576+        then $Tuple2(_saveCallerContract(callerContract_), unit)
577+        else throw("Strict value is not equal to itself.")
578+    }
579+
580+
581+
582+@Callable(i)
583+func updateExecutionChain (executionChainId_,enabled_) = {
584+    let err = if (if (_onlyThisContract(i.caller))
585+        then _whenInitialized()
586+        else false)
587+        then _validateInt(executionChainId_, 0, MAX_INT, "updateExecutionChain: invalid executionChainId")
588+        else false
589+    if ((err == err))
590+        then $Tuple2(_saveChain(executionChainId_, enabled_), unit)
591+        else throw("Strict value is not equal to itself.")
592+    }
593+
594+
595+
596+@Callable(i)
597+func updateFeeRecipient (feeRecipient_) = {
598+    let err = if (if (_onlyThisContract(i.caller))
599+        then _whenInitialized()
600+        else false)
601+        then _validateAddress(feeRecipient_, "updateFeeRecipient: invalid feeRecipient")
602+        else false
603+    if ((err == err))
604+        then $Tuple2(_saveFeeRecipient(addressFromStringValue(feeRecipient_)), unit)
605+        else throw("Strict value is not equal to itself.")
606+    }
607+
608+
609+
610+@Callable(i)
611+func updateReferrer (executionChainId_,referrer_,fee_) = {
612+    let err = if (if (if (if (_onlyThisContract(i.caller))
613+        then _whenInitialized()
614+        else false)
615+        then _validateChain(executionChainId_, "updateReferrer: invalid execution chain")
616+        else false)
617+        then _validateAddress(referrer_, "updateReferrer: invalid referrer")
618+        else false)
619+        then _validateInt(fee_, 0, MAX_REFERRER_FEE, "updateReferrer: invalid fee")
620+        else false
621+    if ((err == err))
622+        then $Tuple2(_saveReferrerFeePercent(executionChainId_, addressFromStringValue(referrer_), fee_), unit)
623+        else throw("Strict value is not equal to itself.")
624+    }
625+
626+
627+
628+@Callable(i)
629+func updateBindingInfo (executionChainId_,executionAsset_,minAmount_,minFee_,thresholdFee_,beforePercentFee_,afterPercentFee_,enabled_) = {
630+    let err = if (if (if (if (if (if (if (_onlyThisContract(i.caller))
631+        then _whenInitialized()
632+        else false)
633+        then _validateInt(executionChainId_, 0, MAX_INT, "updateBindingInfo: invalid executionChainId")
634+        else false)
635+        then _validateInt(minAmount_, 0, MAX_INT, "updateBindingInfo: invalid minAmount")
636+        else false)
637+        then _validateInt(minFee_, 0, MAX_INT, "updateBindingInfo: invalid minFee")
638+        else false)
639+        then _validateInt(thresholdFee_, 0, MAX_INT, "updateBindingInfo: invalid thresholdFee")
640+        else false)
641+        then _validateInt(beforePercentFee_, 0, MAX_INT, "updateBindingInfo: invalid beforePercentFee")
642+        else false)
643+        then _validateInt(afterPercentFee_, 0, MAX_INT, "updateBindingInfo: invalid afterPercentFee")
644+        else false
645+    if ((err == err))
646+        then {
647+            let binding = $Tuple7(executionAsset_, minAmount_, minFee_, thresholdFee_, beforePercentFee_, afterPercentFee_, enabled_)
648+            $Tuple2(_saveBinding(executionChainId_, binding), unit)
649+            }
650+        else throw("Strict value is not equal to itself.")
651+    }
652+
653+
654+
655+@Callable(i)
656+func pause () = {
657+    let err = if (if (_onlyPauser(i.caller))
658+        then _whenInitialized()
659+        else false)
660+        then _whenNotPaused()
661+        else false
662+    if ((err == err))
663+        then $Tuple2(_savePause(true), unit)
664+        else throw("Strict value is not equal to itself.")
665+    }
666+
667+
668+
669+@Callable(i)
670+func unpause () = {
671+    let err = if (if (_onlyPauser(i.caller))
672+        then _whenInitialized()
673+        else false)
674+        then _whenPaused()
675+        else false
676+    if ((err == err))
677+        then $Tuple2(_savePause(false), unit)
678+        else throw("Strict value is not equal to itself.")
679+    }
680+
681+
682+
683+@Callable(i)
684+func updatePauser (pauser_) = {
685+    let err = if (if (_onlyThisContract(i.caller))
686+        then _whenInitialized()
687+        else false)
688+        then _validateAddress(pauser_, "updatePauser: invalid pauser")
689+        else false
690+    if ((err == err))
691+        then $Tuple2(_savePauser(addressFromStringValue(pauser_)), unit)
692+        else throw("Strict value is not equal to itself.")
693+    }
694+
695+
696+
697+@Callable(i)
698+func setMultisig (multisig_) = {
699+    let err = if (_onlyThisContract(i.caller))
700+        then _validateAddress(multisig_, "setMultisig: invalid multisig")
701+        else false
702+    if ((err == err))
703+        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
704+        else throw("Strict value is not equal to itself.")
705+    }
706+
707+
708+@Verifier(tx)
709+func verify () = match getString(KEY_MULTISIG) {
710+    case multisig: String => 
711+        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
712+    case _ => 
713+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
714+}
715+
github/deemru/w8io/3ef1775 
45.03 ms ◑