tx · CfbquQfsk1CHL2iuB28eMo8ausqbgdUjrrcSNayVXJaU

3PEPvEdXoQ39HUzzDvBGwmkwqEGZnuC3BQA:  -0.01500000 Waves

2023.04.26 23:09 [3617566] smart account 3PEPvEdXoQ39HUzzDvBGwmkwqEGZnuC3BQA > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CfbquQfsk1CHL2iuB28eMo8ausqbgdUjrrcSNayVXJaU",
    "fee": 1500000,
    "feeAssetId": null,
    "timestamp": 1682539853739,
    "version": 2,
    "chainId": 87,
    "sender": "3PEPvEdXoQ39HUzzDvBGwmkwqEGZnuC3BQA",
    "senderPublicKey": "5LGqg5LeJYXxZSxTWyYjTkDrBH3ceL57pES1BfT4owtg",
    "proofs": [
        "huNWGLr71AHLxLFbQuEGZpGbsB9wndw5TB4RephS1xhgJNr8YYSCF2fSSUkiPMsPd6QmAuwQAGTM4cUzLC4uUUi"
    ],
    "script": "base64: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",
    "height": 3617566,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: B96uzfUgYURDDTxztVRhUzDGGQttBoNp1qYgMRoQ9RKM

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