tx · AoR2fqfJtmJwG43qQ7D4iC8JXfDatwQvre3TSj8qg4F2

3MvR8ZD65rVQ7ho1LuZFMNmqnQs38SjFzvz:  -0.01800000 Waves

2024.07.04 10:25 [3178971] smart account 3MvR8ZD65rVQ7ho1LuZFMNmqnQs38SjFzvz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "AoR2fqfJtmJwG43qQ7D4iC8JXfDatwQvre3TSj8qg4F2",
    "fee": 1800000,
    "feeAssetId": null,
    "timestamp": 1720077981804,
    "version": 2,
    "chainId": 84,
    "sender": "3MvR8ZD65rVQ7ho1LuZFMNmqnQs38SjFzvz",
    "senderPublicKey": "EEqjCemrPmbE6rVdu2pgq2hcW4J8ecASNHy7TMnfYmuZ",
    "proofs": [
        "3i7ZoxJJ8nVPupv2mLvfXVSorbM94hdDJM97vSvL3tKk4LG66wzZfDYsqa7H7tRGjUSZfFkHVhmwrsQtYUt5kt2B"
    ],
    "script": "base64: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",
    "height": 3178971,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 7 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEPARATOR = "__"
5+
6+let KEY_MULTISIG = "MULTISIG"
7+
8+let KEY_STATUS = "STATUS"
9+
10+let KEY_INIT = "INIT"
11+
12+let KEY_PAUSED = "PAUSED"
13+
14+let KEY_PAUSER = "PAUSER"
15+
16+let KEY_CHAIN = "CHAIN"
17+
18+let KEY_GATEWAY_CONTRACT = "GATEWAY_CONTRACT"
19+
20+let KEY_SWAVES_CONTRACT = "SWAVES_CONTRACT"
21+
22+let KEY_SWAVES_ASSET = "ASSET"
23+
24+let KEY_RESERVES = "RESERVES"
25+
26+let KEY_STAKING_ASSETS = "STAKING_ASSETS"
27+
28+let KEY_STAKING_CONTRACT = "STAKING_CONTRACT"
29+
30+let FUNC_DEPOSIT = "deposit"
31+
32+let FUNC_REQUEST_WITHDRAWAL = "requestWithdrawal"
33+
34+let FUNC_EXECUTE_WITHDRAWAL = "executeWithdrawal"
35+
36+let FUNC_GET_RATE = "getRate"
37+
38+let FUNC_WITHDRAW = "withdraw"
39+
40+let FUNC_STAKE = "stake"
41+
42+let FUNC_UNSTAKE = "unstake"
43+
44+let FUNC_CLAIM_ALL = "claimAll"
45+
46+let FUNC_DEPOSIT_STAKING_REWARD = "depositStakingReward"
47+
48+let WAVES = "WAVES"
49+
50+let WAVES_DECIMALS = 8
51+
52+let DEX_DECIMALS = 8
53+
54+let MAX_INT = 9223372036854775807
55+
56+let ZERO_BIGINT = toBigInt(0)
57+
58+let ONE_BIGINT = toBigInt(1)
59+
60+let SWAVES_RATE_FACTOR = toBigInt(1000000000000)
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_) = if ((assetId_ == WAVES))
71+    then true
72+    else     match assetInfo(fromBase58String(assetId_)) {
73+        case a: Asset => 
74+            true
75+        case _ => 
76+            throw(err_)
77+    }
78+
79+
80+func _validateInt (val_,lowerBoundary_,upperBoundary_,err_) = if (if ((lowerBoundary_ > val_))
81+    then true
82+    else (val_ > upperBoundary_))
83+    then throw(err_)
84+    else true
85+
86+
87+func _validateBigInt (val_,lowerBoundary_,err_) = if ((lowerBoundary_ > val_))
88+    then throw(err_)
89+    else true
90+
91+
92+func _validateString (val_,err_) = if (if ((0 >= size(val_)))
93+    then true
94+    else contains(val_, SEPARATOR))
95+    then throw(err_)
96+    else true
97+
98+
99+func _validatePaymentsSize (payments_,target_,err_) = if ((size(payments_) != target_))
100+    then throw(err_)
101+    else true
102+
103+
104+func _assetToStr (asset_) = match asset_ {
105+    case a: ByteVector => 
106+        toBase58String(a)
107+    case _ => 
108+        WAVES
109+}
110+
111+
112+func _strToAsset (asset_) = if ((asset_ == WAVES))
113+    then unit
114+    else fromBase58String(asset_)
115+
116+
117+func _getDecimals (assetId_) = if ((assetId_ == WAVES))
118+    then WAVES_DECIMALS
119+    else     match assetInfo(fromBase58String(assetId_)) {
120+        case a: Asset => 
121+            a.decimals
122+        case _ => 
123+            throw(("_getDecimals: no asset=" + assetId_))
124+    }
125+
126+
127+func _normalizeDecimals (amount_,sourceDecimals_,targetDecimals_) = if ((sourceDecimals_ >= targetDecimals_))
128+    then (amount_ / pow(10, 0, (sourceDecimals_ - targetDecimals_), 0, 0, DOWN))
129+    else (amount_ * pow(10, 0, (targetDecimals_ - sourceDecimals_), 0, 0, DOWN))
130+
131+
132+func _loadInit () = match getBoolean(KEY_INIT) {
133+    case a: Boolean => 
134+        a
135+    case _ => 
136+        false
137+}
138+
139+
140+func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
141+
142+
143+func _loadPause () = match getBoolean(KEY_PAUSED) {
144+    case a: Boolean => 
145+        a
146+    case _ => 
147+        false
148+}
149+
150+
151+func _savePause (isPaused_) = [BooleanEntry(KEY_PAUSED, isPaused_)]
152+
153+
154+func _loadPauser () = match getString(KEY_PAUSER) {
155+    case a: String => 
156+        addressFromStringValue(a)
157+    case _ => 
158+        Address(base58'')
159+}
160+
161+
162+func _savePauser (pauser_) = [StringEntry(KEY_PAUSER, toString(pauser_))]
163+
164+
165+func _loadMultisig () = match getString(KEY_MULTISIG) {
166+    case a: String => 
167+        addressFromStringValue(a)
168+    case _ => 
169+        Address(base58'')
170+}
171+
172+
173+func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
174+
175+
176+func _loadChainId () = match getInteger(KEY_CHAIN) {
177+    case a: Int => 
178+        a
179+    case _ => 
180+        0
181+}
182+
183+
184+func _saveChainId (chainId_) = [IntegerEntry(KEY_CHAIN, chainId_)]
185+
186+
187+func _loadGatewayContract () = match getString(KEY_GATEWAY_CONTRACT) {
188+    case a: String => 
189+        addressFromStringValue(a)
190+    case _ => 
191+        Address(base58'')
192+}
193+
194+
195+func _saveGatewayContract (gatewayContract_) = [StringEntry(KEY_GATEWAY_CONTRACT, toString(gatewayContract_))]
196+
197+
198+func _loadSWavesContract () = match getString(KEY_SWAVES_CONTRACT) {
199+    case a: String => 
200+        addressFromStringValue(a)
201+    case _ => 
202+        Address(base58'')
203+}
204+
205+
206+func _saveSWavesContract (sWavesContract_) = [StringEntry(KEY_SWAVES_CONTRACT, toString(sWavesContract_))]
207+
208+
209+func _loadSWavesAsset (contract_) = match getString(contract_, KEY_SWAVES_ASSET) {
210+    case a: String => 
211+        fromBase58String(a)
212+    case _ => 
213+        throw("_loadSWavesAsset: revert")
214+}
215+
216+
217+func _loadReserves (asset_) = match getInteger(makeString([KEY_RESERVES, asset_], SEPARATOR)) {
218+    case a: Int => 
219+        a
220+    case _ => 
221+        0
222+}
223+
224+
225+func _saveReserves (asset_,reserves_) = [IntegerEntry(makeString([KEY_RESERVES, asset_], SEPARATOR), reserves_)]
226+
227+
228+func _loadStakingAssets () = match getString(KEY_STAKING_ASSETS) {
229+    case a: String => 
230+        if ((size(a) > 0))
231+            then split_51C(a, SEPARATOR)
232+            else nil
233+    case _ => 
234+        nil
235+}
236+
237+
238+func _saveStakingAssets (assets_) = [StringEntry(KEY_STAKING_ASSETS, makeString(assets_, SEPARATOR))]
239+
240+
241+func _loadStakingContract (asset_) = match getString(makeString([KEY_STAKING_CONTRACT, asset_], SEPARATOR)) {
242+    case a: String => 
243+        addressFromStringValue(a)
244+    case _ => 
245+        Address(base58'')
246+}
247+
248+
249+func _saveStakingContract (asset_,contract_) = [StringEntry(makeString([KEY_STAKING_CONTRACT, asset_], SEPARATOR), toString(contract_))]
250+
251+
252+func _onlyThisContract (caller_) = if ((caller_ != this))
253+    then throw("_onlyThisContract: revert")
254+    else true
255+
256+
257+func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
258+    then throw("_whenMultisigSet: revert")
259+    else true
260+
261+
262+func _whenNotInitialized () = if (_loadInit())
263+    then throw("_whenNotInitialized: revert")
264+    else true
265+
266+
267+func _whenInitialized () = if (!(_loadInit()))
268+    then throw("_whenInitialized: revert")
269+    else true
270+
271+
272+func _whenNotPaused () = if (_loadPause())
273+    then throw("_whenNotPaused: revert")
274+    else true
275+
276+
277+func _whenPaused () = if (!(_loadPause()))
278+    then throw("_whenPaused: revert")
279+    else true
280+
281+
282+func _onlyPauser (caller_) = if ((caller_ != _loadPauser()))
283+    then throw("_onlyPauser: revert")
284+    else true
285+
286+
287+func _validateGateway (caller,err_) = if ((_loadGatewayContract() != caller))
288+    then throw(err_)
289+    else true
290+
291+
292+func _deposit (from_,to_,asset_,amount_) = {
293+    let assetDecimals = _getDecimals(asset_)
294+    let amount = _normalizeDecimals(amount_, assetDecimals, DEX_DECIMALS)
295+    let err = _validateInt(amount, 1, MAX_INT, "_deposit: invalid payment amount")
296+    if ((err == err))
297+        then {
298+            let gatewayInvocation = invoke(_loadGatewayContract(), FUNC_DEPOSIT, [toString(this), from_, to_, toString(_loadChainId()), asset_, toString(amount)], nil)
299+            if ((gatewayInvocation == gatewayInvocation))
300+                then {
301+                    let stakingAssets = _loadStakingAssets()
302+                    let stakingInvocation = if ((asset_ == WAVES))
303+                        then invoke(_loadSWavesContract(), FUNC_DEPOSIT, nil, [AttachedPayment(unit, amount_)])
304+                        else if (containsElement(stakingAssets, asset_))
305+                            then invoke(_loadStakingContract(asset_), FUNC_STAKE, nil, [AttachedPayment(_strToAsset(asset_), amount_)])
306+                            else unit
307+                    if ((stakingInvocation == stakingInvocation))
308+                        then _saveReserves(asset_, (_loadReserves(asset_) + amount))
309+                        else throw("Strict value is not equal to itself.")
310+                    }
311+                else throw("Strict value is not equal to itself.")
312+            }
313+        else throw("Strict value is not equal to itself.")
314+    }
315+
316+
317+@Callable(i)
318+func init (chainId_,pauser_,gatewayContract_,sWavesContract_) = {
319+    let err = if (if (if (if (if (if (_onlyThisContract(i.caller))
320+        then _whenNotInitialized()
321+        else false)
322+        then _whenMultisigSet()
323+        else false)
324+        then _validateInt(chainId_, 0, MAX_INT, "init: invalid chainId")
325+        else false)
326+        then _validateAddress(pauser_, "init: invalid pauser")
327+        else false)
328+        then _validateAddress(gatewayContract_, "init: invalid gatewayContract")
329+        else false)
330+        then _validateAddress(sWavesContract_, "init: invalid sWavesContract")
331+        else false
332+    if ((err == err))
333+        then $Tuple2(((((_saveInit(true) ++ _saveChainId(chainId_)) ++ _savePauser(addressFromStringValue(pauser_))) ++ _saveGatewayContract(addressFromStringValue(gatewayContract_))) ++ _saveSWavesContract(addressFromStringValue(sWavesContract_))), unit)
334+        else throw("Strict value is not equal to itself.")
335+    }
336+
337+
338+
339+@Callable(i)
340+func deposit () = {
341+    let err = if (if (if (_whenInitialized())
342+        then _whenNotPaused()
343+        else false)
344+        then _validatePaymentsSize(i.payments, 1, "deposit: no payment")
345+        else false)
346+        then _validateInt(i.payments[0].amount, 0, MAX_INT, "deposit: negative payment")
347+        else false
348+    if ((err == err))
349+        then $Tuple2(_deposit(toString(i.caller), toString(i.caller), _assetToStr(i.payments[0].assetId), i.payments[0].amount), unit)
350+        else throw("Strict value is not equal to itself.")
351+    }
352+
353+
354+
355+@Callable(i)
356+func depositTo (to_) = {
357+    let err = if (if (if (if (_whenInitialized())
358+        then _whenNotPaused()
359+        else false)
360+        then _validatePaymentsSize(i.payments, 1, "depositTo: no payment")
361+        else false)
362+        then _validateInt(i.payments[0].amount, 0, MAX_INT, "depositTo: negative payment")
363+        else false)
364+        then _validateString(to_, "depositTo: invalid to")
365+        else false
366+    if ((err == err))
367+        then $Tuple2(_deposit(toString(i.caller), to_, _assetToStr(i.payments[0].assetId), i.payments[0].amount), unit)
368+        else throw("Strict value is not equal to itself.")
369+    }
370+
371+
372+
373+@Callable(i)
374+func requestWithdrawal (toChainId_,asset_,amount_) = {
375+    let amount = valueOrErrorMessage(parseBigInt(amount_), "requestWithdrawal: amount not int")
376+    let err = if (if (if (_whenInitialized())
377+        then _validateInt(toChainId_, 0, MAX_INT, "requestWithdrawal: invalid toChainId")
378+        else false)
379+        then _validateString(asset_, "requestWithdrawal: invalid asset")
380+        else false)
381+        then _validateBigInt(amount, ONE_BIGINT, "requestWithdrawal: negative amount")
382+        else false
383+    if ((err == err))
384+        then {
385+            let caller = toString(i.caller)
386+            let requestWithdrawalId =             match invoke(_loadGatewayContract(), FUNC_REQUEST_WITHDRAWAL, [toString(this), caller, caller, toString(_loadChainId()), toString(toChainId_), asset_, amount_], nil) {
387+                case a: Int => 
388+                    a
389+                case _ => 
390+                    throw("requestWithdrawal: call reverted from gw")
391+            }
392+            if ((requestWithdrawalId == requestWithdrawalId))
393+                then $Tuple2(nil, requestWithdrawalId)
394+                else throw("Strict value is not equal to itself.")
395+            }
396+        else throw("Strict value is not equal to itself.")
397+    }
398+
399+
400+
401+@Callable(i)
402+func executeWithdrawal (requestWithdrawalId_) = {
403+    let err = if (_whenInitialized())
404+        then _validateInt(requestWithdrawalId_, 0, MAX_INT, "executeWithdrawal: invalid requestId")
405+        else false
406+    if ((err == err))
407+        then {
408+            let gatewayInvocation = reentrantInvoke(_loadGatewayContract(), FUNC_EXECUTE_WITHDRAWAL, [toString(this), toString(_loadChainId()), toString(requestWithdrawalId_)], nil)
409+            if ((gatewayInvocation == gatewayInvocation))
410+                then $Tuple2(nil, unit)
411+                else throw("Strict value is not equal to itself.")
412+            }
413+        else throw("Strict value is not equal to itself.")
414+    }
415+
416+
417+
418+@Callable(i)
419+func withdraw (to_,asset_,amount_) = {
420+    let amount = valueOrErrorMessage(parseInt(amount_), "withdraw: amount not int")
421+    let err = if (if (if (if (_whenInitialized())
422+        then _validateGateway(i.caller, "withdraw: invalid gateway")
423+        else false)
424+        then _validateAddress(to_, "withdraw: invalid address")
425+        else false)
426+        then _validateAsset(asset_, "withdraw: invalid asset")
427+        else false)
428+        then _validateInt(amount, 0, MAX_INT, "withdraw: negative amount")
429+        else false
430+    if ((err == err))
431+        then {
432+            let assetDecimals = _getDecimals(asset_)
433+            let amountNormalized = _normalizeDecimals(amount, DEX_DECIMALS, assetDecimals)
434+            let newReserves = (_loadReserves(asset_) - amount)
435+            let err1 = if (_validateInt(amountNormalized, 1, MAX_INT, "withdraw: invalid amount"))
436+                then _validateInt(newReserves, 0, MAX_INT, "withdraw: negative newReserves")
437+                else false
438+            if ((err1 == err1))
439+                then {
440+                    let stakingAssets = _loadStakingAssets()
441+                    let unstakingInvocation = if ((asset_ == WAVES))
442+                        then {
443+                            let sWavesContract = _loadSWavesContract()
444+                            let sWavesAsset = _loadSWavesAsset(sWavesContract)
445+                            let invocation = invoke(sWavesContract, FUNC_GET_RATE, nil, nil)
446+                            let rate =                             match invocation {
447+                                case a: String => 
448+                                    parseBigIntValue(a)
449+                                case _ => 
450+                                    throw("withdraw: sWaves getRate() revert")
451+                            }
452+                            let sWavesToWithdraw = toInt(fraction(toBigInt(amountNormalized), SWAVES_RATE_FACTOR, rate, CEILING))
453+                            invoke(sWavesContract, FUNC_WITHDRAW, nil, [AttachedPayment(sWavesAsset, sWavesToWithdraw)])
454+                            }
455+                        else if (containsElement(stakingAssets, asset_))
456+                            then invoke(_loadStakingContract(asset_), FUNC_UNSTAKE, [amountNormalized], nil)
457+                            else unit
458+                    if ((unstakingInvocation == unstakingInvocation))
459+                        then $Tuple2(([ScriptTransfer(addressFromStringValue(to_), amountNormalized, _strToAsset(asset_))] ++ _saveReserves(asset_, newReserves)), unit)
460+                        else throw("Strict value is not equal to itself.")
461+                    }
462+                else throw("Strict value is not equal to itself.")
463+            }
464+        else throw("Strict value is not equal to itself.")
465+    }
466+
467+
468+
469+@Callable(i)
470+func depositStakingReward (asset_) = {
471+    let err = if (_whenInitialized())
472+        then _validateAsset(asset_, "depositStakingReward: invalid asset")
473+        else false
474+    if ((err == err))
475+        then {
476+            let stakingAssets = _loadStakingAssets()
477+            let updatedReserves = if ((asset_ == WAVES))
478+                then {
479+                    let sWavesContract = _loadSWavesContract()
480+                    let sWavesAsset = _loadSWavesAsset(sWavesContract)
481+                    let invocation = invoke(sWavesContract, FUNC_GET_RATE, nil, nil)
482+                    let rate =                     match invocation {
483+                        case a: String => 
484+                            parseBigIntValue(a)
485+                        case _ => 
486+                            throw("depositStakingReward: sWaves getRate() revert")
487+                    }
488+                    let swavesAmount = assetBalance(this, sWavesAsset)
489+                    toInt(fraction(toBigInt(swavesAmount), rate, SWAVES_RATE_FACTOR, DOWN))
490+                    }
491+                else if (containsElement(stakingAssets, asset_))
492+                    then {
493+                        let invocation = invoke(_loadStakingContract(asset_), FUNC_CLAIM_ALL, [toString(this)], nil)
494+                        if ((invocation == invocation))
495+                            then assetBalance(this, fromBase58String(asset_))
496+                            else throw("Strict value is not equal to itself.")
497+                        }
498+                    else throw("depositStakingReward: no staking for asset")
499+            let assetDecimals = _getDecimals(asset_)
500+            let updatedReservesNormalized = _normalizeDecimals(updatedReserves, assetDecimals, DEX_DECIMALS)
501+            let stakingProfit = (updatedReservesNormalized - _loadReserves(asset_))
502+            let err1 = _validateInt(stakingProfit, 1, MAX_INT, "depositStakingReward: no reward")
503+            if ((err1 == err1))
504+                then {
505+                    let gatewayInvocation = invoke(_loadGatewayContract(), FUNC_DEPOSIT_STAKING_REWARD, [toString(this), toString(_loadChainId()), asset_, toString(stakingProfit)], nil)
506+                    if ((gatewayInvocation == gatewayInvocation))
507+                        then $Tuple2(_saveReserves(asset_, updatedReservesNormalized), unit)
508+                        else throw("Strict value is not equal to itself.")
509+                    }
510+                else throw("Strict value is not equal to itself.")
511+            }
512+        else throw("Strict value is not equal to itself.")
513+    }
514+
515+
516+
517+@Callable(i)
518+func addStakingAsset (asset_,contract_) = {
519+    let err = if (if (_onlyThisContract(i.caller))
520+        then _validateAsset(asset_, "addStakingAsset: invalid asset")
521+        else false)
522+        then _validateAddress(contract_, "addStakingAsset: invalid contract")
523+        else false
524+    if ((err == err))
525+        then {
526+            let assets = _loadStakingAssets()
527+            let err1 = if (containsElement(assets, asset_))
528+                then throw("addStakingAsset: duplicate asset")
529+                else unit
530+            if ((err1 == err1))
531+                then $Tuple2((_saveStakingAssets((assets :+ asset_)) ++ _saveStakingContract(asset_, addressFromStringValue(contract_))), unit)
532+                else throw("Strict value is not equal to itself.")
533+            }
534+        else throw("Strict value is not equal to itself.")
535+    }
536+
537+
538+
539+@Callable(i)
540+func rmStakingAsset (asset_) = {
541+    let err = if (_onlyThisContract(i.caller))
542+        then _validateAsset(asset_, "rmStakingAsset: invalid asset")
543+        else false
544+    if ((err == err))
545+        then {
546+            let assets = _loadStakingAssets()
547+            let err1 = if (!(containsElement(assets, asset_)))
548+                then throw("rmStakingAsset: no asset")
549+                else unit
550+            if ((err1 == err1))
551+                then {
552+                    let index = value(indexOf(assets, asset_))
553+                    $Tuple2(_saveStakingAssets(removeByIndex(assets, index)), unit)
554+                    }
555+                else throw("Strict value is not equal to itself.")
556+            }
557+        else throw("Strict value is not equal to itself.")
558+    }
559+
560+
561+
562+@Callable(i)
563+func pause () = {
564+    let err = if (if (_onlyPauser(i.caller))
565+        then _whenInitialized()
566+        else false)
567+        then _whenNotPaused()
568+        else false
569+    if ((err == err))
570+        then $Tuple2(_savePause(true), unit)
571+        else throw("Strict value is not equal to itself.")
572+    }
573+
574+
575+
576+@Callable(i)
577+func unpause () = {
578+    let err = if (if (_onlyPauser(i.caller))
579+        then _whenInitialized()
580+        else false)
581+        then _whenPaused()
582+        else false
583+    if ((err == err))
584+        then $Tuple2(_savePause(false), unit)
585+        else throw("Strict value is not equal to itself.")
586+    }
587+
588+
589+
590+@Callable(i)
591+func updatePauser (pauser_) = {
592+    let err = if (if (_onlyThisContract(i.caller))
593+        then _whenInitialized()
594+        else false)
595+        then _validateAddress(pauser_, "updatePauser: invalid pauser")
596+        else false
597+    if ((err == err))
598+        then $Tuple2(_savePauser(addressFromStringValue(pauser_)), unit)
599+        else throw("Strict value is not equal to itself.")
600+    }
601+
602+
603+
604+@Callable(i)
605+func setMultisig (multisig_) = {
606+    let err = if (_onlyThisContract(i.caller))
607+        then _validateAddress(multisig_, "setMultisig: invalid multisig")
608+        else false
609+    if ((err == err))
610+        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
611+        else throw("Strict value is not equal to itself.")
612+    }
613+
614+
615+@Verifier(tx)
616+func verify () = match getString(KEY_MULTISIG) {
617+    case multisig: String => 
618+        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
619+    case _ => 
620+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
621+}
622+
github/deemru/w8io/169f3d6 
31.45 ms ◑