tx · CXDAMCPF2TTNAkH7v8a8v9yt16Tka5KSM9viG45Ysj29

3N1vLkqi1Wz7MDLtpwRFBg5V33fHpnxaFuV:  -0.02100000 Waves

2024.04.01 18:22 [3043887] smart account 3N1vLkqi1Wz7MDLtpwRFBg5V33fHpnxaFuV > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CXDAMCPF2TTNAkH7v8a8v9yt16Tka5KSM9viG45Ysj29",
    "fee": 2100000,
    "feeAssetId": null,
    "timestamp": 1711985047663,
    "version": 2,
    "chainId": 84,
    "sender": "3N1vLkqi1Wz7MDLtpwRFBg5V33fHpnxaFuV",
    "senderPublicKey": "8eBztzvcDYHno9SMCjk6rkQHJHDMXFt5YcknLLsAARn8",
    "proofs": [
        "57B3GhB7nffS5Gqa3ddiNAbGcgpwzzqwhpEDjAwLgaunY8Q42wYiANNUbztTFHGtJ4Lw3dv2YxrTS7DfBRFSSb3L"
    ],
    "script": "base64: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",
    "height": 3043887,
    "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_EXECUTOR = "EXECUTOR"
17+
18+let KEY_CALLER_CONTRACT = "CALLER_CONTRACT"
19+
20+let KEY_WAVES_VAULT = "WAVES_VAULT"
21+
22+let KEY_ACCOUNT_STORAGE = "ACCOUNT_STORAGE"
23+
24+let KEY_CHAIN = "CHAIN"
25+
26+let KEY_ASSET_CURRENCY = "ASSET_CURRENCY"
27+
28+let KEY_ASSET_RESERVES = "ASSET_RESERVES"
29+
30+let KEY_ASSET_RESERVES_LOCKED = "ASSET_RESERVES_LOCKED"
31+
32+let KEY_CURRENCY_RESERVES = "CURRENCY_RESERVES"
33+
34+let KEY_REQUEST_WITHDRAWAL_SIZE = "REQUEST_WITHDRAWAL_SIZE"
35+
36+let KEY_REQUEST_WITHDRAWAL = "REQUEST_WITHDRAWAL"
37+
38+let KEY_REQUEST_WITHDRAWAL_BLOCK_DELAY = "REQUEST_WITHDRAWAL_BLOCK_DELAY"
39+
40+let FUNC_DEPOSIT = "deposit"
41+
42+let FUNC_GET_USER_BALANCE = "getUserBalance"
43+
44+let FUNC_INTERNAL_TRANSFER = "internalTransfer"
45+
46+let FUNC_WITHDRAW = "withdraw"
47+
48+let REQUEST_STATUS_CREATED = 0
49+
50+let REQUEST_STATUS_DONE = 1
51+
52+let REQUEST_STATUS_REJECTED = 2
53+
54+let WAVES = "WAVES"
55+
56+let SPOT_WALLET = "SPOT"
57+
58+let WITHDRAWALS_WALLET = "WITHDRAWALS"
59+
60+let MAX_INT = 9223372036854775807
61+
62+let ZERO_BIGINT = toBigInt(0)
63+
64+let ONE_BIGINT = toBigInt(1)
65+
66+func _validateAddress (address_,err_) = match addressFromString(address_) {
67+    case a: Address => 
68+        true
69+    case _ => 
70+        throw(err_)
71+}
72+
73+
74+func _validateInt (val_,lowerBoundary_,upperBoundary_,err_) = if (if ((lowerBoundary_ > val_))
75+    then true
76+    else (val_ > upperBoundary_))
77+    then throw(err_)
78+    else true
79+
80+
81+func _validateBigInt (val_,lowerBoundary_,err_) = if ((lowerBoundary_ > val_))
82+    then throw(err_)
83+    else true
84+
85+
86+func _validateString (val_,err_) = if (if ((0 >= size(val_)))
87+    then true
88+    else contains(val_, SEPARATOR))
89+    then throw(err_)
90+    else true
91+
92+
93+func _loadInit () = match getBoolean(KEY_INIT) {
94+    case a: Boolean => 
95+        a
96+    case _ => 
97+        false
98+}
99+
100+
101+func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
102+
103+
104+func _loadPause () = match getBoolean(KEY_PAUSED) {
105+    case a: Boolean => 
106+        a
107+    case _ => 
108+        false
109+}
110+
111+
112+func _savePause (isPaused_) = [BooleanEntry(KEY_PAUSED, isPaused_)]
113+
114+
115+func _loadPauser () = match getString(KEY_PAUSER) {
116+    case a: String => 
117+        addressFromStringValue(a)
118+    case _ => 
119+        Address(base58'')
120+}
121+
122+
123+func _savePauser (pauser_) = [StringEntry(KEY_PAUSER, toString(pauser_))]
124+
125+
126+func _loadMultisig () = match getString(KEY_MULTISIG) {
127+    case a: String => 
128+        addressFromStringValue(a)
129+    case _ => 
130+        Address(base58'')
131+}
132+
133+
134+func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
135+
136+
137+func _loadCallerContract (chainId_) = match getString(makeString([KEY_CALLER_CONTRACT, toString(chainId_)], SEPARATOR)) {
138+    case a: String => 
139+        a
140+    case _ => 
141+        ""
142+}
143+
144+
145+func _saveCallerContract (chainId_,callerContract_) = [StringEntry(makeString([KEY_CALLER_CONTRACT, toString(chainId_)], SEPARATOR), callerContract_)]
146+
147+
148+func _loadExecutor () = match getString(KEY_EXECUTOR) {
149+    case a: String => 
150+        addressFromStringValue(a)
151+    case _ => 
152+        Address(base58'')
153+}
154+
155+
156+func _saveExecutor (executor_) = [StringEntry(KEY_EXECUTOR, toString(executor_))]
157+
158+
159+func _loadAccountStorage () = match getString(KEY_ACCOUNT_STORAGE) {
160+    case a: String => 
161+        addressFromStringValue(a)
162+    case _ => 
163+        Address(base58'')
164+}
165+
166+
167+func _saveAccountStorage (accountStorage_) = [StringEntry(KEY_ACCOUNT_STORAGE, toString(accountStorage_))]
168+
169+
170+func _loadWavesVault () = match getString(KEY_WAVES_VAULT) {
171+    case a: String => 
172+        addressFromStringValue(a)
173+    case _ => 
174+        Address(base58'')
175+}
176+
177+
178+func _saveWavesVault (wavesVault_) = [StringEntry(KEY_WAVES_VAULT, toString(wavesVault_))]
179+
180+
181+func _loadChain (chainId_) = match getString(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR)) {
182+    case a: String => 
183+        a
184+    case _ => 
185+        ""
186+}
187+
188+
189+func _saveChain (chainId_,name_) = [StringEntry(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR), name_)]
190+
191+
192+func _loadAssetCurrency (chainId_,asset_) = match getString(makeString([KEY_ASSET_CURRENCY, toString(chainId_), asset_], SEPARATOR)) {
193+    case a: String => 
194+        a
195+    case _ => 
196+        ""
197+}
198+
199+
200+func _saveAssetCurrency (chainId_,asset_,currency_) = [StringEntry(makeString([KEY_ASSET_CURRENCY, toString(chainId_), asset_], SEPARATOR), currency_)]
201+
202+
203+func _loadAssetReserves (chainId_,asset_) = match getString(makeString([KEY_ASSET_RESERVES, toString(chainId_), asset_], SEPARATOR)) {
204+    case a: String => 
205+        parseBigIntValue(a)
206+    case _ => 
207+        ZERO_BIGINT
208+}
209+
210+
211+func _saveAssetReserves (chainId_,asset_,reserves_) = [StringEntry(makeString([KEY_ASSET_RESERVES, toString(chainId_), asset_], SEPARATOR), toString(reserves_))]
212+
213+
214+func _loadAssetReservesLocked (chainId_,asset_) = match getString(makeString([KEY_ASSET_RESERVES_LOCKED, toString(chainId_), asset_], SEPARATOR)) {
215+    case a: String => 
216+        parseBigIntValue(a)
217+    case _ => 
218+        ZERO_BIGINT
219+}
220+
221+
222+func _saveAssetReservesLocked (chainId_,asset_,reserves_) = [StringEntry(makeString([KEY_ASSET_RESERVES_LOCKED, toString(chainId_), asset_], SEPARATOR), toString(reserves_))]
223+
224+
225+func _loadCurrencyReserves (currency_) = match getString(makeString([KEY_CURRENCY_RESERVES, currency_], SEPARATOR)) {
226+    case a: String => 
227+        parseBigIntValue(a)
228+    case _ => 
229+        ZERO_BIGINT
230+}
231+
232+
233+func _saveCurrencyReserves (currency_,reserves_) = [StringEntry(makeString([KEY_CURRENCY_RESERVES, currency_], SEPARATOR), toString(reserves_))]
234+
235+
236+func _loadRequestWithdrawalSize () = match getInteger(KEY_REQUEST_WITHDRAWAL_SIZE) {
237+    case a: Int => 
238+        a
239+    case _ => 
240+        0
241+}
242+
243+
244+func _saveRequestWithdrawalSize (val_) = [IntegerEntry(KEY_REQUEST_WITHDRAWAL_SIZE, val_)]
245+
246+
247+func _loadRequestWithdrawal (index_) = match getString(makeString([KEY_REQUEST_WITHDRAWAL, toString(index_)], SEPARATOR)) {
248+    case a: String => 
249+        let struct = split(a, SEPARATOR)
250+        $Tuple8(struct[0], struct[1], parseIntValue(struct[2]), struct[3], parseBigIntValue(struct[4]), parseIntValue(struct[5]), struct[6], parseIntValue(struct[7]))
251+    case _ => 
252+        $Tuple8("", "", 0, "", ZERO_BIGINT, 0, "", REQUEST_STATUS_CREATED)
253+}
254+
255+
256+func _saveRequestWithdrawal (index_,request_) = [StringEntry(makeString([KEY_REQUEST_WITHDRAWAL, toString(index_)], SEPARATOR), makeString([request_._1, request_._2, toString(request_._3), request_._4, toString(request_._5), toString(request_._6), request_._7, toString(request_._8)], SEPARATOR))]
257+
258+
259+func _loadRequestWithdrawalBlockDelay () = match getInteger(KEY_REQUEST_WITHDRAWAL_BLOCK_DELAY) {
260+    case a: Int => 
261+        a
262+    case _ => 
263+        0
264+}
265+
266+
267+func _saveRequestWithdrawalBlockDelay (delay_) = [IntegerEntry(KEY_REQUEST_WITHDRAWAL_BLOCK_DELAY, delay_)]
268+
269+
270+func _onlyThisContract (caller_) = if ((caller_ != this))
271+    then throw("_onlyThisContract: revert")
272+    else true
273+
274+
275+func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
276+    then throw("_whenMultisigSet: revert")
277+    else true
278+
279+
280+func _whenNotInitialized () = if (_loadInit())
281+    then throw("_whenNotInitialized: revert")
282+    else true
283+
284+
285+func _whenInitialized () = if (!(_loadInit()))
286+    then throw("_whenInitialized: revert")
287+    else true
288+
289+
290+func _whenNotPaused () = if (_loadPause())
291+    then throw("_whenNotPaused: revert")
292+    else true
293+
294+
295+func _whenPaused () = if (!(_loadPause()))
296+    then throw("_whenPaused: revert")
297+    else true
298+
299+
300+func _onlyPauser (caller_) = if ((caller_ != _loadPauser()))
301+    then throw("_onlyPauser: revert")
302+    else true
303+
304+
305+func _validateExecutor (val_,err_) = if ((val_ != _loadExecutor()))
306+    then throw(err_)
307+    else true
308+
309+
310+func _validateCallerContract (chainId_,callerContract_,err_) = if ((_loadCallerContract(chainId_) != callerContract_))
311+    then throw(err_)
312+    else true
313+
314+
315+func _chainExists (chainId_,err_) = if ((0 >= size(_loadChain(chainId_))))
316+    then throw(err_)
317+    else true
318+
319+
320+func _chainNotExist (chainId_,err_) = if ((size(_loadChain(chainId_)) > 0))
321+    then throw(err_)
322+    else true
323+
324+
325+func _assetCurrencyExists (chainId_,asset_,err_) = if ((0 >= size(_loadAssetCurrency(chainId_, asset_))))
326+    then throw(err_)
327+    else true
328+
329+
330+func _assetCurrencyNotExist (chainId_,asset_,err_) = if ((size(_loadAssetCurrency(chainId_, asset_)) > 0))
331+    then throw(err_)
332+    else true
333+
334+
335+func _validateWavesVault (caller,err_) = if ((_loadWavesVault() != caller))
336+    then throw(err_)
337+    else true
338+
339+
340+func _requestIsCreated (status_,err_) = if ((status_ != REQUEST_STATUS_CREATED))
341+    then throw(err_)
342+    else true
343+
344+
345+@Callable(i)
346+func init (executor_,pauser_,accountStorage_,wavesVault_) = {
347+    let err = if (if (if (if (if (if (_onlyThisContract(i.caller))
348+        then _whenNotInitialized()
349+        else false)
350+        then _whenMultisigSet()
351+        else false)
352+        then _validateAddress(executor_, "init: invalid executor")
353+        else false)
354+        then _validateAddress(pauser_, "init: invalid pauser")
355+        else false)
356+        then _validateAddress(accountStorage_, "init: invalid accountStorage")
357+        else false)
358+        then _validateAddress(wavesVault_, "init: invalid wavesVault")
359+        else false
360+    if ((err == err))
361+        then $Tuple2(((((_saveInit(true) ++ _saveExecutor(addressFromStringValue(executor_))) ++ _savePauser(addressFromStringValue(pauser_))) ++ _saveAccountStorage(addressFromStringValue(accountStorage_))) ++ _saveWavesVault(addressFromStringValue(wavesVault_))), unit)
362+        else throw("Strict value is not equal to itself.")
363+    }
364+
365+
366+
367+@Callable(i)
368+func deposit (callerContract_,from_,to_,chainId_,asset_,amount_) = {
369+    let chainId = valueOrErrorMessage(parseInt(chainId_), "deposit: chainId not int")
370+    let amount = valueOrErrorMessage(parseBigInt(amount_), "deposit: amount not int")
371+    let err = if (if (if (if (if (if (_whenInitialized())
372+        then _whenNotPaused()
373+        else false)
374+        then _chainExists(chainId, "deposit: invalid chainId")
375+        else false)
376+        then _validateString(from_, "deposit: invalid from")
377+        else false)
378+        then _validateString(to_, "deposit: invalid to")
379+        else false)
380+        then _assetCurrencyExists(chainId, asset_, "deposit: invalid asset")
381+        else false)
382+        then _validateBigInt(amount, ZERO_BIGINT, "deposit: invalid amount")
383+        else false
384+    if ((err == err))
385+        then {
386+            let err1 = if ((_loadChain(chainId) == WAVES))
387+                then _validateWavesVault(i.caller, "deposit: invalid waves vault")
388+                else if (_validateExecutor(i.caller, "deposit: invalid executor"))
389+                    then _validateCallerContract(chainId, callerContract_, "deposit: invalid caller contract")
390+                    else false
391+            if ((err1 == err1))
392+                then {
393+                    let newAssetReserves = (_loadAssetReserves(chainId, asset_) + amount)
394+                    let currency = _loadAssetCurrency(chainId, asset_)
395+                    let newCurrencyReserves = (_loadCurrencyReserves(currency) + amount)
396+                    let invocation = invoke(_loadAccountStorage(), FUNC_DEPOSIT, [to_, currency, amount_], nil)
397+                    if ((invocation == invocation))
398+                        then $Tuple2((_saveAssetReserves(chainId, asset_, newAssetReserves) ++ _saveCurrencyReserves(currency, newCurrencyReserves)), unit)
399+                        else throw("Strict value is not equal to itself.")
400+                    }
401+                else throw("Strict value is not equal to itself.")
402+            }
403+        else throw("Strict value is not equal to itself.")
404+    }
405+
406+
407+
408+@Callable(i)
409+func requestWithdrawal (callerContract_,from_,to_,fromChainId_,toChainId_,asset_,amount_) = {
410+    let fromChainId = valueOrErrorMessage(parseInt(fromChainId_), "requestWithdrawal: fromChainId not int")
411+    let toChainId = valueOrErrorMessage(parseInt(toChainId_), "requestWithdrawal: toChainId not int")
412+    let amount = valueOrErrorMessage(parseBigInt(amount_), "requestWithdrawal: amount not int")
413+    let err = if (if (if (if (if (if (_whenInitialized())
414+        then _chainExists(fromChainId, "requestWithdrawal: invalid fromChainId")
415+        else false)
416+        then _chainExists(toChainId, "requestWithdrawal: invalid toChainId")
417+        else false)
418+        then _validateString(from_, "requestWithdrawal: invalid from")
419+        else false)
420+        then _validateString(to_, "requestWithdrawal: invalid to")
421+        else false)
422+        then _assetCurrencyExists(toChainId, asset_, "requestWithdrawal: invalid asset")
423+        else false)
424+        then _validateBigInt(amount, ZERO_BIGINT, "requestWithdrawal: invalid amount")
425+        else false
426+    if ((err == err))
427+        then {
428+            let err1 = if ((_loadChain(fromChainId) == WAVES))
429+                then _validateWavesVault(i.caller, "requestWithdrawal: invalid waves vault")
430+                else if (_validateExecutor(i.caller, "requestWithdrawal: invalid executor"))
431+                    then _validateCallerContract(fromChainId, callerContract_, "requestWithdrawal: invalid caller contract")
432+                    else false
433+            if ((err1 == err1))
434+                then {
435+                    let currency = _loadAssetCurrency(toChainId, asset_)
436+                    let availableBalance =                     match invoke(_loadAccountStorage(), FUNC_GET_USER_BALANCE, [from_, SPOT_WALLET, currency], nil) {
437+                        case a: String => 
438+                            parseBigIntValue(a)
439+                        case _ => 
440+                            throw("requestWithdrawal: can't take available balance from storage")
441+                    }
442+                    if ((availableBalance == availableBalance))
443+                        then {
444+                            let lockedReserves = _loadAssetReservesLocked(toChainId, asset_)
445+                            let $t01414214651 = if (if ((availableBalance >= amount))
446+                                then ((_loadAssetReserves(toChainId, asset_) - lockedReserves) >= amount)
447+                                else false)
448+                                then $Tuple3(REQUEST_STATUS_CREATED, invoke(_loadAccountStorage(), FUNC_INTERNAL_TRANSFER, [from_, SPOT_WALLET, WITHDRAWALS_WALLET, currency, amount_], nil), _saveAssetReservesLocked(toChainId, asset_, (lockedReserves + amount)))
449+                                else $Tuple3(REQUEST_STATUS_REJECTED, unit, nil)
450+                            if (($t01414214651 == $t01414214651))
451+                                then {
452+                                    let reservesActions = $t01414214651._3
453+                                    let storageInvocation = $t01414214651._2
454+                                    let requestStatus = $t01414214651._1
455+                                    let requestWithdrawalSize = _loadRequestWithdrawalSize()
456+                                    let requestWithdrawal = $Tuple8(from_, to_, toChainId, asset_, amount, height, toBase58String(i.transactionId), requestStatus)
457+                                    $Tuple2(((_saveRequestWithdrawal(requestWithdrawalSize, requestWithdrawal) ++ _saveRequestWithdrawalSize((requestWithdrawalSize + 1))) ++ reservesActions), requestWithdrawalSize)
458+                                    }
459+                                else throw("Strict value is not equal to itself.")
460+                            }
461+                        else throw("Strict value is not equal to itself.")
462+                    }
463+                else throw("Strict value is not equal to itself.")
464+            }
465+        else throw("Strict value is not equal to itself.")
466+    }
467+
468+
469+
470+@Callable(i)
471+func executeWithdrawal (callerContract_,chainId_,requestWithdrawalId_) = {
472+    let chainId = valueOrErrorMessage(parseInt(chainId_), "executeWithdrawal: chainId not int")
473+    let requestWithdrawalId = valueOrErrorMessage(parseInt(requestWithdrawalId_), "executeWithdrawal: requestWithdrawalId not int")
474+    let err = if (if (_whenInitialized())
475+        then _chainExists(chainId, "executeWithdrawal: invalid chainId")
476+        else false)
477+        then _validateInt(requestWithdrawalId, 0, MAX_INT, "executeWithdrawal: invalid requestWithdrawalId")
478+        else false
479+    if ((err == err))
480+        then {
481+            let err1 = if ((_loadChain(chainId) == WAVES))
482+                then _validateWavesVault(i.caller, "executeWithdrawal: invalid waves vault")
483+                else if (_validateExecutor(i.caller, "executeWithdrawal: invalid executor"))
484+                    then _validateCallerContract(chainId, callerContract_, "executeWithdrawal: invalid caller contract")
485+                    else false
486+            if ((err1 == err1))
487+                then {
488+                    let request = _loadRequestWithdrawal(requestWithdrawalId)
489+                    let requestFrom = request._1
490+                    let requestTo = request._2
491+                    let requestToChainId = request._3
492+                    let requestAsset = request._4
493+                    let requestAmount = request._5
494+                    let requestHeight = request._6
495+                    let requestStatus = request._8
496+                    let newAssetReserves = (_loadAssetReserves(requestToChainId, requestAsset) - requestAmount)
497+                    let newAssetReservesLocked = (_loadAssetReservesLocked(requestToChainId, requestAsset) - requestAmount)
498+                    let currency = _loadAssetCurrency(requestToChainId, requestAsset)
499+                    let newCurrencyReserves = (_loadCurrencyReserves(currency) - requestAmount)
500+                    let err2 = if (if (if (if (_validateBigInt(newAssetReserves, ZERO_BIGINT, "executeWithdrawal: negative newAssetReserves"))
501+                        then _validateBigInt(newAssetReservesLocked, ZERO_BIGINT, "executeWithdrawal: negative newAssetReservesLocked")
502+                        else false)
503+                        then _validateBigInt(newCurrencyReserves, ZERO_BIGINT, "executeWithdrawal: negative newCurrencyReserves")
504+                        else false)
505+                        then _validateInt((height - requestHeight), _loadRequestWithdrawalBlockDelay(), MAX_INT, "executeWithdrawal: too early to execute")
506+                        else false)
507+                        then _requestIsCreated(requestStatus, "executeWithdrawal: request is resolved")
508+                        else false
509+                    if ((err2 == err2))
510+                        then {
511+                            let storageInvocation = invoke(_loadAccountStorage(), FUNC_WITHDRAW, [requestFrom, currency, toString(requestAmount)], nil)
512+                            if ((storageInvocation == storageInvocation))
513+                                then {
514+                                    let vaultInvocation = if ((_loadChain(requestToChainId) == WAVES))
515+                                        then invoke(_loadWavesVault(), FUNC_WITHDRAW, [requestTo, requestAsset, toString(requestAmount)], nil)
516+                                        else unit
517+                                    if ((vaultInvocation == vaultInvocation))
518+                                        then {
519+                                            let requestUpdated = $Tuple8(request._1, request._2, request._3, request._4, request._5, request._6, request._7, REQUEST_STATUS_DONE)
520+                                            $Tuple2((((_saveAssetReserves(requestToChainId, requestAsset, newAssetReserves) ++ _saveAssetReservesLocked(requestToChainId, requestAsset, newAssetReservesLocked)) ++ _saveCurrencyReserves(currency, newCurrencyReserves)) ++ _saveRequestWithdrawal(requestWithdrawalId, requestUpdated)), unit)
521+                                            }
522+                                        else throw("Strict value is not equal to itself.")
523+                                    }
524+                                else throw("Strict value is not equal to itself.")
525+                            }
526+                        else throw("Strict value is not equal to itself.")
527+                    }
528+                else throw("Strict value is not equal to itself.")
529+            }
530+        else throw("Strict value is not equal to itself.")
531+    }
532+
533+
534+
535+@Callable(i)
536+func withdraw (from_,to_,chainId_,asset_,amount_,timestamp_,signature_) = $Tuple2(nil, unit)
537+
538+
539+
540+@Callable(i)
541+func addChain (chainId_,name_,callerContract_) = {
542+    let err = if (if (if (if (if (_onlyThisContract(i.caller))
543+        then _whenInitialized()
544+        else false)
545+        then _validateInt(chainId_, 0, MAX_INT, "addChain: invalid chainId")
546+        else false)
547+        then _validateString(name_, "addChain: invalid name")
548+        else false)
549+        then _validateString(callerContract_, "addChain: invalid callerContract")
550+        else false)
551+        then _chainNotExist(chainId_, "addChain: already exists")
552+        else false
553+    if ((err == err))
554+        then $Tuple2((_saveChain(chainId_, name_) ++ _saveCallerContract(chainId_, callerContract_)), unit)
555+        else throw("Strict value is not equal to itself.")
556+    }
557+
558+
559+
560+@Callable(i)
561+func addAsset (chainId_,asset_,currency_) = {
562+    let err = if (if (if (if (if (_onlyThisContract(i.caller))
563+        then _whenInitialized()
564+        else false)
565+        then _chainExists(chainId_, "addAsset: invalid chainId")
566+        else false)
567+        then _validateString(asset_, "addAsset: invalid asset")
568+        else false)
569+        then _validateString(currency_, "addAsset: invalid currency")
570+        else false)
571+        then _assetCurrencyNotExist(chainId_, asset_, "addAsset: already exists")
572+        else false
573+    if ((err == err))
574+        then $Tuple2(_saveAssetCurrency(chainId_, asset_, currency_), unit)
575+        else throw("Strict value is not equal to itself.")
576+    }
577+
578+
579+
580+@Callable(i)
581+func setRequestWithdrawalBlockDelay (delay_) = {
582+    let err = if (if (_onlyThisContract(i.caller))
583+        then _whenInitialized()
584+        else false)
585+        then _validateInt(delay_, 0, MAX_INT, "setRequestWithdrawalBlockDelay: invalid delay")
586+        else false
587+    if ((err == err))
588+        then $Tuple2(_saveRequestWithdrawalBlockDelay(delay_), unit)
589+        else throw("Strict value is not equal to itself.")
590+    }
591+
592+
593+
594+@Callable(i)
595+func pause () = {
596+    let err = if (if (_onlyPauser(i.caller))
597+        then _whenInitialized()
598+        else false)
599+        then _whenNotPaused()
600+        else false
601+    if ((err == err))
602+        then $Tuple2(_savePause(true), unit)
603+        else throw("Strict value is not equal to itself.")
604+    }
605+
606+
607+
608+@Callable(i)
609+func unpause () = {
610+    let err = if (if (_onlyPauser(i.caller))
611+        then _whenInitialized()
612+        else false)
613+        then _whenPaused()
614+        else false
615+    if ((err == err))
616+        then $Tuple2(_savePause(false), unit)
617+        else throw("Strict value is not equal to itself.")
618+    }
619+
620+
621+
622+@Callable(i)
623+func updatePauser (pauser_) = {
624+    let err = if (if (_onlyThisContract(i.caller))
625+        then _whenInitialized()
626+        else false)
627+        then _validateAddress(pauser_, "updatePauser: invalid pauser")
628+        else false
629+    if ((err == err))
630+        then $Tuple2(_savePauser(addressFromStringValue(pauser_)), unit)
631+        else throw("Strict value is not equal to itself.")
632+    }
633+
634+
635+
636+@Callable(i)
637+func setMultisig (multisig_) = {
638+    let err = if (_onlyThisContract(i.caller))
639+        then _validateAddress(multisig_, "setMultisig: invalid multisig")
640+        else false
641+    if ((err == err))
642+        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
643+        else throw("Strict value is not equal to itself.")
644+    }
645+
646+
647+@Verifier(tx)
648+func verify () = match getString(KEY_MULTISIG) {
649+    case multisig: String => 
650+        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
651+    case _ => 
652+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
653+}
654+
github/deemru/w8io/3ef1775 
38.24 ms ◑