tx · 26uthRGKiQUUYbPCRwkidbYL99ZaXNZm3wd6pJgFrKVd

3MtMeTkpnPVAVkfrsFLuLua5urLVbbSBw6p:  -0.01600000 Waves

2023.08.07 13:16 [2700039] smart account 3MtMeTkpnPVAVkfrsFLuLua5urLVbbSBw6p > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "26uthRGKiQUUYbPCRwkidbYL99ZaXNZm3wd6pJgFrKVd",
    "fee": 1600000,
    "feeAssetId": null,
    "timestamp": 1691403433714,
    "version": 2,
    "chainId": 84,
    "sender": "3MtMeTkpnPVAVkfrsFLuLua5urLVbbSBw6p",
    "senderPublicKey": "DojBiW1SWnPHvXvUpRw5AcLmqiiYR1dwvSCXKoGc6haJ",
    "proofs": [
        "wsng5q9E68qmGbosnxaXwrJQQshHHu6K4HaXHS49pbb4ZPiFWQvuiUMRzNqpWapccuJ8XBeqBFw7HMhfuDp74tr"
    ],
    "script": "base64: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",
    "height": 2700039,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 4NLLUKbMXoXeWCR7VAjNKSgBN7YxvLkX1EyEVXbKuy9A

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