tx · 74rf9Vdqi9f8SHdP9ipAKhpd68m8VwbfeMKCcNExBi45

3NAg2HDvKz7gwrNc2wnUxdK74NydBFUXTYP:  -0.03300000 Waves

2024.12.10 20:31 [3408805] smart account 3NAg2HDvKz7gwrNc2wnUxdK74NydBFUXTYP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "74rf9Vdqi9f8SHdP9ipAKhpd68m8VwbfeMKCcNExBi45",
    "fee": 3300000,
    "feeAssetId": null,
    "timestamp": 1733851942662,
    "version": 2,
    "chainId": 84,
    "sender": "3NAg2HDvKz7gwrNc2wnUxdK74NydBFUXTYP",
    "senderPublicKey": "BEbZF8zo7WjaQFZFFuPs7hqSLEgGwjwQFGg4tSidf9C3",
    "proofs": [
        "5UVYpaYXrSyaDbXDwpMnHxoT884NVqud31k9L9EkFt4PkVfVs9WxxEag4LYTnJek7chFyBf9Rk3ngMLhdkueQdHv"
    ],
    "script": "base64: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",
    "height": 3408805,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: F4ZRZKEp5Tdpuwvtz9A7MmyUEwa7FJwExVLEHZD3TyBT
Next: none

Diff: 

OldNewDifferences
477477 func _validateWithdrawalSignature (withdrawalHash_,signature_,web3Id_,alg_,err_) = {
478478     let result = if ((alg_ == ALG_TYPE_WAVES))
479479         then {
480-            let hashWithPrefix = keccak256_16Kb((WAVES_PREFIX + toBytes(toBase58String(withdrawalHash_))))
481-            sigVerify(hashWithPrefix, signature_, web3Id_)
480+            let msg = (WAVES_PREFIX + toBytes(toBase58String(withdrawalHash_)))
481+            sigVerify(msg, signature_, web3Id_)
482482             }
483483         else if ((alg_ == ALG_TYPE_EVM))
484484             then {
609609                         then {
610610                             let lockedReserves = _loadAssetReservesLocked(toChainId, asset_)
611611                             let userLockedCurrency = _loadUserLockedCurrency(currency, from_)
612-                            let $t01943719892 = if (if (((availableBalance - userLockedCurrency) >= amount))
612+                            let $t01939919854 = if (if (((availableBalance - userLockedCurrency) >= amount))
613613                                 then ((_loadAssetReserves(toChainId, asset_) - lockedReserves) >= amount)
614614                                 else false)
615615                                 then $Tuple2(REQUEST_STATUS_CREATED, (_saveAssetReservesLocked(toChainId, asset_, (lockedReserves + amount)) ++ _saveUserLockedCurrency(currency, from_, (amount + userLockedCurrency))))
616616                                 else $Tuple2(REQUEST_STATUS_REJECTED, nil)
617-                            let requestStatus = $t01943719892._1
618-                            let reservesActions = $t01943719892._2
617+                            let requestStatus = $t01939919854._1
618+                            let reservesActions = $t01939919854._2
619619                             let requestWithdrawalSize = _loadRequestWithdrawalSize()
620620                             let requestWithdrawal = $Tuple8(from_, to_, toChainId, asset_, amount, height, toBase58String(i.transactionId), requestStatus)
621621                             $Tuple2(((_saveRequestWithdrawal(requestWithdrawalSize, requestWithdrawal) ++ _saveRequestWithdrawalSize((requestWithdrawalSize + 1))) ++ reservesActions), requestWithdrawalSize)

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 7 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEPARATOR = "__"
55 
66 let KEY_MULTISIG = "MULTISIG"
77 
88 let KEY_STATUS = "STATUS"
99 
1010 let KEY_INIT = "INIT"
1111 
1212 let KEY_PAUSED = "PAUSED"
1313 
1414 let KEY_PAUSER = "PAUSER"
1515 
1616 let KEY_EXECUTOR = "EXECUTOR"
1717 
1818 let KEY_CALLER_CONTRACT = "CALLER_CONTRACT"
1919 
2020 let KEY_WAVES_VAULT = "WAVES_VAULT"
2121 
2222 let KEY_ACCOUNT_STORAGE = "ACCOUNT_STORAGE"
2323 
2424 let KEY_CHAIN = "CHAIN"
2525 
2626 let KEY_ASSET_CURRENCY = "ASSET_CURRENCY"
2727 
2828 let KEY_ASSET_RESERVES = "ASSET_RESERVES"
2929 
3030 let KEY_ASSET_RESERVES_LOCKED = "ASSET_RESERVES_LOCKED"
3131 
3232 let KEY_USER_LOCKED_CURRENCY = "USER_LOCKED_CURRENCY"
3333 
3434 let KEY_CURRENCY_RESERVES = "CURRENCY_RESERVES"
3535 
3636 let KEY_REQUEST_WITHDRAWAL_SIZE = "REQUEST_WITHDRAWAL_SIZE"
3737 
3838 let KEY_REQUEST_WITHDRAWAL = "REQUEST_WITHDRAWAL"
3939 
4040 let KEY_REQUEST_WITHDRAWAL_BLOCK_DELAY = "REQUEST_WITHDRAWAL_BLOCK_DELAY"
4141 
4242 let KEY_SEQUENCER = "SEQUENCER"
4343 
4444 let KEY_WITHDRAWAL_HASH = "WITHDRAWAL_HASH"
4545 
4646 let KEY_VAULT_ADAPTER = "VAULT_ADAPTER"
4747 
4848 let KEY_REWARD_DISTRIBUTOR = "REWARD_DISTRIBUTOR"
4949 
5050 let KEY_RELAYER_FEE_RECIPIENT = "RELAYER_FEE_RECIPIENT"
5151 
5252 let FUNC_DEPOSIT = "deposit"
5353 
5454 let FUNC_GET_USER_BALANCE = "getUserBalance"
5555 
5656 let FUNC_INTERNAL_TRANSFER = "internalTransfer"
5757 
5858 let FUNC_WITHDRAW = "withdraw"
5959 
6060 let FUNC_DEPOSIT_STAKING_REWARD = "depositStakingReward"
6161 
6262 let REQUEST_STATUS_CREATED = 0
6363 
6464 let REQUEST_STATUS_DONE = 1
6565 
6666 let REQUEST_STATUS_REJECTED = 2
6767 
6868 let WAVES = "WAVES"
6969 
7070 let SPOT_WALLET = "SPOT"
7171 
7272 let MAX_INT = 9223372036854775807
7373 
7474 let ZERO_BIGINT = toBigInt(0)
7575 
7676 let ONE_BIGINT = toBigInt(1)
7777 
7878 let ONE_DAY = 86400000
7979 
8080 let ALG_TYPE_WAVES = 1
8181 
8282 let ALG_TYPE_EVM = 2
8383 
8484 let WAVES_PREFIX = base58'7YXq4t'
8585 
8686 let EVM_SIGNATURE_PREFIX = base58'G5Nu92G2p7moXW9qjjN3na7gtq4dWCeVdaSjry'
8787 
8888 func _validateAddress (address_,err_) = match addressFromString(address_) {
8989     case a: Address => 
9090         true
9191     case _ => 
9292         throw(err_)
9393 }
9494 
9595 
9696 func _validateInt (val_,lowerBoundary_,upperBoundary_,err_) = if (if ((lowerBoundary_ > val_))
9797     then true
9898     else (val_ > upperBoundary_))
9999     then throw(err_)
100100     else true
101101 
102102 
103103 func _validateBigInt (val_,lowerBoundary_,err_) = if ((lowerBoundary_ > val_))
104104     then throw(err_)
105105     else true
106106 
107107 
108108 func _validateBigInt_2 (val_,lowerBoundary_,upperBoundary_,err_) = if (if ((lowerBoundary_ > val_))
109109     then true
110110     else (val_ > upperBoundary_))
111111     then throw(err_)
112112     else true
113113 
114114 
115115 func _validateString (val_,err_) = if (if ((0 >= size(val_)))
116116     then true
117117     else contains(val_, SEPARATOR))
118118     then throw(err_)
119119     else true
120120 
121121 
122122 func _validateStringEqual (val1_,val2_,err_) = if ((val1_ != val2_))
123123     then throw(err_)
124124     else true
125125 
126126 
127127 func _loadInit () = match getBoolean(KEY_INIT) {
128128     case a: Boolean => 
129129         a
130130     case _ => 
131131         false
132132 }
133133 
134134 
135135 func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
136136 
137137 
138138 func _loadPause () = match getBoolean(KEY_PAUSED) {
139139     case a: Boolean => 
140140         a
141141     case _ => 
142142         false
143143 }
144144 
145145 
146146 func _savePause (isPaused_) = [BooleanEntry(KEY_PAUSED, isPaused_)]
147147 
148148 
149149 func _loadPauser () = match getString(KEY_PAUSER) {
150150     case a: String => 
151151         addressFromStringValue(a)
152152     case _ => 
153153         Address(base58'')
154154 }
155155 
156156 
157157 func _savePauser (pauser_) = [StringEntry(KEY_PAUSER, toString(pauser_))]
158158 
159159 
160160 func _loadMultisig () = match getString(KEY_MULTISIG) {
161161     case a: String => 
162162         addressFromStringValue(a)
163163     case _ => 
164164         Address(base58'')
165165 }
166166 
167167 
168168 func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
169169 
170170 
171171 func _loadCallerContract (chainId_) = match getString(makeString([KEY_CALLER_CONTRACT, toString(chainId_)], SEPARATOR)) {
172172     case a: String => 
173173         a
174174     case _ => 
175175         ""
176176 }
177177 
178178 
179179 func _saveCallerContract (chainId_,callerContract_) = [StringEntry(makeString([KEY_CALLER_CONTRACT, toString(chainId_)], SEPARATOR), callerContract_)]
180180 
181181 
182182 func _loadExecutor () = match getString(KEY_EXECUTOR) {
183183     case a: String => 
184184         addressFromStringValue(a)
185185     case _ => 
186186         Address(base58'')
187187 }
188188 
189189 
190190 func _saveExecutor (executor_) = [StringEntry(KEY_EXECUTOR, toString(executor_))]
191191 
192192 
193193 func _loadAccountStorage () = match getString(KEY_ACCOUNT_STORAGE) {
194194     case a: String => 
195195         addressFromStringValue(a)
196196     case _ => 
197197         Address(base58'')
198198 }
199199 
200200 
201201 func _saveAccountStorage (accountStorage_) = [StringEntry(KEY_ACCOUNT_STORAGE, toString(accountStorage_))]
202202 
203203 
204204 func _loadWavesVault () = match getString(KEY_WAVES_VAULT) {
205205     case a: String => 
206206         addressFromStringValue(a)
207207     case _ => 
208208         Address(base58'')
209209 }
210210 
211211 
212212 func _saveWavesVault (wavesVault_) = [StringEntry(KEY_WAVES_VAULT, toString(wavesVault_))]
213213 
214214 
215215 func _loadChain (chainId_) = match getString(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR)) {
216216     case a: String => 
217217         a
218218     case _ => 
219219         ""
220220 }
221221 
222222 
223223 func _saveChain (chainId_,name_) = [StringEntry(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR), name_)]
224224 
225225 
226226 func _loadAssetCurrency (chainId_,asset_) = match getString(makeString([KEY_ASSET_CURRENCY, toString(chainId_), asset_], SEPARATOR)) {
227227     case a: String => 
228228         a
229229     case _ => 
230230         ""
231231 }
232232 
233233 
234234 func _saveAssetCurrency (chainId_,asset_,currency_) = [StringEntry(makeString([KEY_ASSET_CURRENCY, toString(chainId_), asset_], SEPARATOR), currency_)]
235235 
236236 
237237 func _loadAssetReserves (chainId_,asset_) = match getString(makeString([KEY_ASSET_RESERVES, toString(chainId_), asset_], SEPARATOR)) {
238238     case a: String => 
239239         parseBigIntValue(a)
240240     case _ => 
241241         ZERO_BIGINT
242242 }
243243 
244244 
245245 func _saveAssetReserves (chainId_,asset_,reserves_) = [StringEntry(makeString([KEY_ASSET_RESERVES, toString(chainId_), asset_], SEPARATOR), toString(reserves_))]
246246 
247247 
248248 func _loadAssetReservesLocked (chainId_,asset_) = match getString(makeString([KEY_ASSET_RESERVES_LOCKED, toString(chainId_), asset_], SEPARATOR)) {
249249     case a: String => 
250250         parseBigIntValue(a)
251251     case _ => 
252252         ZERO_BIGINT
253253 }
254254 
255255 
256256 func _saveAssetReservesLocked (chainId_,asset_,reserves_) = [StringEntry(makeString([KEY_ASSET_RESERVES_LOCKED, toString(chainId_), asset_], SEPARATOR), toString(reserves_))]
257257 
258258 
259259 func _loadUserLockedCurrency (currency_,user_) = match getString(makeString([KEY_USER_LOCKED_CURRENCY, currency_, user_], SEPARATOR)) {
260260     case a: String => 
261261         parseBigIntValue(a)
262262     case _ => 
263263         ZERO_BIGINT
264264 }
265265 
266266 
267267 func _saveUserLockedCurrency (currency_,user_,amount_) = [StringEntry(makeString([KEY_USER_LOCKED_CURRENCY, currency_, user_], SEPARATOR), toString(amount_))]
268268 
269269 
270270 func _loadCurrencyReserves (currency_) = match getString(makeString([KEY_CURRENCY_RESERVES, currency_], SEPARATOR)) {
271271     case a: String => 
272272         parseBigIntValue(a)
273273     case _ => 
274274         ZERO_BIGINT
275275 }
276276 
277277 
278278 func _saveCurrencyReserves (currency_,reserves_) = [StringEntry(makeString([KEY_CURRENCY_RESERVES, currency_], SEPARATOR), toString(reserves_))]
279279 
280280 
281281 func _loadRequestWithdrawalSize () = match getInteger(KEY_REQUEST_WITHDRAWAL_SIZE) {
282282     case a: Int => 
283283         a
284284     case _ => 
285285         0
286286 }
287287 
288288 
289289 func _saveRequestWithdrawalSize (val_) = [IntegerEntry(KEY_REQUEST_WITHDRAWAL_SIZE, val_)]
290290 
291291 
292292 func _loadRequestWithdrawal (index_) = match getString(makeString([KEY_REQUEST_WITHDRAWAL, toString(index_)], SEPARATOR)) {
293293     case a: String => 
294294         let struct = split(a, SEPARATOR)
295295         $Tuple8(struct[0], struct[1], parseIntValue(struct[2]), struct[3], parseBigIntValue(struct[4]), parseIntValue(struct[5]), struct[6], parseIntValue(struct[7]))
296296     case _ => 
297297         $Tuple8("", "", 0, "", ZERO_BIGINT, 0, "", REQUEST_STATUS_CREATED)
298298 }
299299 
300300 
301301 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))]
302302 
303303 
304304 func _loadRequestWithdrawalBlockDelay () = match getInteger(KEY_REQUEST_WITHDRAWAL_BLOCK_DELAY) {
305305     case a: Int => 
306306         a
307307     case _ => 
308308         0
309309 }
310310 
311311 
312312 func _saveRequestWithdrawalBlockDelay (delay_) = [IntegerEntry(KEY_REQUEST_WITHDRAWAL_BLOCK_DELAY, delay_)]
313313 
314314 
315315 func _loadSequencer () = match getString(KEY_SEQUENCER) {
316316     case a: String => 
317317         addressFromStringValue(a)
318318     case _ => 
319319         Address(base58'')
320320 }
321321 
322322 
323323 func _saveSequencer (sequencer_) = [StringEntry(KEY_SEQUENCER, toString(sequencer_))]
324324 
325325 
326326 func _loadWithdrawalHash (withdrawalHash_) = match getString(makeString([KEY_WITHDRAWAL_HASH, toBase58String(withdrawalHash_)], SEPARATOR)) {
327327     case a: String => 
328328         a
329329     case _ => 
330330         ""
331331 }
332332 
333333 
334334 func _saveWithdrawalHash (withdrawalHash_,txId_) = [StringEntry(makeString([KEY_WITHDRAWAL_HASH, toBase58String(withdrawalHash_)], SEPARATOR), txId_)]
335335 
336336 
337337 func _loadVaultAdapter () = match getString(KEY_VAULT_ADAPTER) {
338338     case a: String => 
339339         addressFromStringValue(a)
340340     case _ => 
341341         Address(base58'')
342342 }
343343 
344344 
345345 func _saveVaultAdapter (vaultAdapter_) = [StringEntry(KEY_VAULT_ADAPTER, toString(vaultAdapter_))]
346346 
347347 
348348 func _loadRewardDistributor () = match getString(KEY_REWARD_DISTRIBUTOR) {
349349     case a: String => 
350350         a
351351     case _ => 
352352         ""
353353 }
354354 
355355 
356356 func _saveRewardDistributor (distributor_) = [StringEntry(KEY_REWARD_DISTRIBUTOR, distributor_)]
357357 
358358 
359359 func _loadRelayerFeeRecipient () = match getString(KEY_RELAYER_FEE_RECIPIENT) {
360360     case a: String => 
361361         a
362362     case _ => 
363363         ""
364364 }
365365 
366366 
367367 func _saveRelayerFeeRecipient (relayerFeeRecipient_) = [StringEntry(KEY_RELAYER_FEE_RECIPIENT, relayerFeeRecipient_)]
368368 
369369 
370370 func _onlyThisContract (caller_) = if ((caller_ != this))
371371     then throw("_onlyThisContract: revert")
372372     else true
373373 
374374 
375375 func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
376376     then throw("_whenMultisigSet: revert")
377377     else true
378378 
379379 
380380 func _whenNotInitialized () = if (_loadInit())
381381     then throw("_whenNotInitialized: revert")
382382     else true
383383 
384384 
385385 func _whenInitialized () = if (!(_loadInit()))
386386     then throw("_whenInitialized: revert")
387387     else true
388388 
389389 
390390 func _whenNotPaused () = if (_loadPause())
391391     then throw("_whenNotPaused: revert")
392392     else true
393393 
394394 
395395 func _whenPaused () = if (!(_loadPause()))
396396     then throw("_whenPaused: revert")
397397     else true
398398 
399399 
400400 func _onlyPauser (caller_) = if ((caller_ != _loadPauser()))
401401     then throw("_onlyPauser: revert")
402402     else true
403403 
404404 
405405 func _validateExecutor (val_,err_) = if ((val_ != _loadExecutor()))
406406     then throw(err_)
407407     else true
408408 
409409 
410410 func _validateCallerContract (chainId_,callerContract_,err_) = if ((_loadCallerContract(chainId_) != callerContract_))
411411     then throw(err_)
412412     else true
413413 
414414 
415415 func _chainExists (chainId_,err_) = if ((0 >= size(_loadChain(chainId_))))
416416     then throw(err_)
417417     else true
418418 
419419 
420420 func _chainNotExist (chainId_,err_) = if ((size(_loadChain(chainId_)) > 0))
421421     then throw(err_)
422422     else true
423423 
424424 
425425 func _assetCurrencyExists (chainId_,asset_,err_) = if ((0 >= size(_loadAssetCurrency(chainId_, asset_))))
426426     then throw(err_)
427427     else true
428428 
429429 
430430 func _assetCurrencyNotExist (chainId_,asset_,err_) = if ((size(_loadAssetCurrency(chainId_, asset_)) > 0))
431431     then throw(err_)
432432     else true
433433 
434434 
435435 func _validateWavesVault (caller,err_) = if ((_loadWavesVault() != caller))
436436     then throw(err_)
437437     else true
438438 
439439 
440440 func _requestIsCreated (status_,err_) = if ((status_ != REQUEST_STATUS_CREATED))
441441     then throw(err_)
442442     else true
443443 
444444 
445445 func _validateSequencer (caller,err_) = if ((_loadSequencer() != caller))
446446     then throw(err_)
447447     else true
448448 
449449 
450450 func _checkWithdrawalHashNotExist (withdrawalHash_,err_) = if ((size(_loadWithdrawalHash(withdrawalHash_)) > 0))
451451     then throw(err_)
452452     else true
453453 
454454 
455455 func _validateSignatureFormat (signature_,alg_,err_) = if ((alg_ == ALG_TYPE_WAVES))
456456     then if ((size(signature_) != 64))
457457         then throw(err_)
458458         else true
459459     else if ((alg_ == ALG_TYPE_EVM))
460460         then if ((size(signature_) != 65))
461461             then throw(err_)
462462             else true
463463         else throw((err_ + ": inv alg"))
464464 
465465 
466466 func _validateWeb3Id (web3Id_,alg_,err_) = if ((alg_ == ALG_TYPE_WAVES))
467467     then if ((size(web3Id_) != 32))
468468         then throw(err_)
469469         else true
470470     else if ((alg_ == ALG_TYPE_EVM))
471471         then if ((size(web3Id_) != 20))
472472             then throw(err_)
473473             else true
474474         else throw((err_ + ": inv alg"))
475475 
476476 
477477 func _validateWithdrawalSignature (withdrawalHash_,signature_,web3Id_,alg_,err_) = {
478478     let result = if ((alg_ == ALG_TYPE_WAVES))
479479         then {
480-            let hashWithPrefix = keccak256_16Kb((WAVES_PREFIX + toBytes(toBase58String(withdrawalHash_))))
481-            sigVerify(hashWithPrefix, signature_, web3Id_)
480+            let msg = (WAVES_PREFIX + toBytes(toBase58String(withdrawalHash_)))
481+            sigVerify(msg, signature_, web3Id_)
482482             }
483483         else if ((alg_ == ALG_TYPE_EVM))
484484             then {
485485                 let hashWithPrefix = keccak256_16Kb((EVM_SIGNATURE_PREFIX + withdrawalHash_))
486486                 (takeRight(keccak256_16Kb(ecrecover(hashWithPrefix, signature_)), 20) == web3Id_)
487487                 }
488488             else throw((err_ + ": inv alg"))
489489     if (!(result))
490490         then throw(err_)
491491         else true
492492     }
493493 
494494 
495495 func _validateWeb3IdMatchesAddress (web3Id_,from_,alg_,err_) = {
496496     let address = if ((alg_ == ALG_TYPE_WAVES))
497497         then toString(addressFromPublicKey(web3Id_))
498498         else if ((alg_ == ALG_TYPE_EVM))
499499             then ("0x" + toBase16String(web3Id_))
500500             else throw((err_ + ": inv alg"))
501501     if ((address != from_))
502502         then throw(err_)
503503         else true
504504     }
505505 
506506 
507507 @Callable(i)
508508 func init (executor_,pauser_,accountStorage_,wavesVault_,sequencer_,vaultAdapter_) = {
509509     let err = if (if (if (if (if (if (if (if (_onlyThisContract(i.caller))
510510         then _whenNotInitialized()
511511         else false)
512512         then _whenMultisigSet()
513513         else false)
514514         then _validateAddress(executor_, "init: invalid executor")
515515         else false)
516516         then _validateAddress(pauser_, "init: invalid pauser")
517517         else false)
518518         then _validateAddress(accountStorage_, "init: invalid accountStorage")
519519         else false)
520520         then _validateAddress(wavesVault_, "init: invalid wavesVault")
521521         else false)
522522         then _validateAddress(sequencer_, "init: invalid sequencer")
523523         else false)
524524         then _validateAddress(vaultAdapter_, "init: invalid vaultAdapter")
525525         else false
526526     if ((err == err))
527527         then $Tuple2(((((((_saveInit(true) ++ _saveExecutor(addressFromStringValue(executor_))) ++ _savePauser(addressFromStringValue(pauser_))) ++ _saveAccountStorage(addressFromStringValue(accountStorage_))) ++ _saveWavesVault(addressFromStringValue(wavesVault_))) ++ _saveSequencer(addressFromStringValue(sequencer_))) ++ _saveVaultAdapter(addressFromStringValue(vaultAdapter_))), unit)
528528         else throw("Strict value is not equal to itself.")
529529     }
530530 
531531 
532532 
533533 @Callable(i)
534534 func deposit (callerContract_,from_,to_,chainId_,asset_,amount_) = {
535535     let chainId = valueOrErrorMessage(parseInt(chainId_), "deposit: chainId not int")
536536     let amount = valueOrErrorMessage(parseBigInt(amount_), "deposit: amount not int")
537537     let err = if (if (if (if (if (if (_whenInitialized())
538538         then _whenNotPaused()
539539         else false)
540540         then _chainExists(chainId, "deposit: invalid chainId")
541541         else false)
542542         then _validateString(from_, "deposit: invalid from")
543543         else false)
544544         then _validateString(to_, "deposit: invalid to")
545545         else false)
546546         then _assetCurrencyExists(chainId, asset_, "deposit: invalid asset")
547547         else false)
548548         then _validateBigInt(amount, ZERO_BIGINT, "deposit: invalid amount")
549549         else false
550550     if ((err == err))
551551         then {
552552             let err1 = if ((_loadChain(chainId) == WAVES))
553553                 then _validateWavesVault(i.caller, "deposit: invalid waves vault")
554554                 else if (_validateExecutor(i.caller, "deposit: invalid executor"))
555555                     then _validateCallerContract(chainId, callerContract_, "deposit: invalid caller contract")
556556                     else false
557557             if ((err1 == err1))
558558                 then {
559559                     let newAssetReserves = (_loadAssetReserves(chainId, asset_) + amount)
560560                     let currency = _loadAssetCurrency(chainId, asset_)
561561                     let newCurrencyReserves = (_loadCurrencyReserves(currency) + amount)
562562                     let invocation = invoke(_loadAccountStorage(), FUNC_DEPOSIT, [to_, currency, amount_], nil)
563563                     if ((invocation == invocation))
564564                         then $Tuple2((_saveAssetReserves(chainId, asset_, newAssetReserves) ++ _saveCurrencyReserves(currency, newCurrencyReserves)), unit)
565565                         else throw("Strict value is not equal to itself.")
566566                     }
567567                 else throw("Strict value is not equal to itself.")
568568             }
569569         else throw("Strict value is not equal to itself.")
570570     }
571571 
572572 
573573 
574574 @Callable(i)
575575 func requestWithdrawal (callerContract_,from_,to_,fromChainId_,toChainId_,asset_,amount_) = {
576576     let fromChainId = valueOrErrorMessage(parseInt(fromChainId_), "requestWithdrawal: fromChainId not int")
577577     let toChainId = valueOrErrorMessage(parseInt(toChainId_), "requestWithdrawal: toChainId not int")
578578     let amount = valueOrErrorMessage(parseBigInt(amount_), "requestWithdrawal: amount not int")
579579     let err = if (if (if (if (if (if (_whenInitialized())
580580         then _chainExists(fromChainId, "requestWithdrawal: invalid fromChainId")
581581         else false)
582582         then _chainExists(toChainId, "requestWithdrawal: invalid toChainId")
583583         else false)
584584         then _validateString(from_, "requestWithdrawal: invalid from")
585585         else false)
586586         then _validateString(to_, "requestWithdrawal: invalid to")
587587         else false)
588588         then _assetCurrencyExists(toChainId, asset_, "requestWithdrawal: invalid asset")
589589         else false)
590590         then _validateBigInt(amount, ZERO_BIGINT, "requestWithdrawal: invalid amount")
591591         else false
592592     if ((err == err))
593593         then {
594594             let err1 = if ((_loadChain(fromChainId) == WAVES))
595595                 then _validateWavesVault(i.caller, "requestWithdrawal: invalid waves vault")
596596                 else if (_validateExecutor(i.caller, "requestWithdrawal: invalid executor"))
597597                     then _validateCallerContract(fromChainId, callerContract_, "requestWithdrawal: invalid caller contract")
598598                     else false
599599             if ((err1 == err1))
600600                 then {
601601                     let currency = _loadAssetCurrency(toChainId, asset_)
602602                     let availableBalance =                     match invoke(_loadAccountStorage(), FUNC_GET_USER_BALANCE, [from_, SPOT_WALLET, currency], nil) {
603603                         case a: String => 
604604                             parseBigIntValue(a)
605605                         case _ => 
606606                             throw("requestWithdrawal: can't take available balance from storage")
607607                     }
608608                     if ((availableBalance == availableBalance))
609609                         then {
610610                             let lockedReserves = _loadAssetReservesLocked(toChainId, asset_)
611611                             let userLockedCurrency = _loadUserLockedCurrency(currency, from_)
612-                            let $t01943719892 = if (if (((availableBalance - userLockedCurrency) >= amount))
612+                            let $t01939919854 = if (if (((availableBalance - userLockedCurrency) >= amount))
613613                                 then ((_loadAssetReserves(toChainId, asset_) - lockedReserves) >= amount)
614614                                 else false)
615615                                 then $Tuple2(REQUEST_STATUS_CREATED, (_saveAssetReservesLocked(toChainId, asset_, (lockedReserves + amount)) ++ _saveUserLockedCurrency(currency, from_, (amount + userLockedCurrency))))
616616                                 else $Tuple2(REQUEST_STATUS_REJECTED, nil)
617-                            let requestStatus = $t01943719892._1
618-                            let reservesActions = $t01943719892._2
617+                            let requestStatus = $t01939919854._1
618+                            let reservesActions = $t01939919854._2
619619                             let requestWithdrawalSize = _loadRequestWithdrawalSize()
620620                             let requestWithdrawal = $Tuple8(from_, to_, toChainId, asset_, amount, height, toBase58String(i.transactionId), requestStatus)
621621                             $Tuple2(((_saveRequestWithdrawal(requestWithdrawalSize, requestWithdrawal) ++ _saveRequestWithdrawalSize((requestWithdrawalSize + 1))) ++ reservesActions), requestWithdrawalSize)
622622                             }
623623                         else throw("Strict value is not equal to itself.")
624624                     }
625625                 else throw("Strict value is not equal to itself.")
626626             }
627627         else throw("Strict value is not equal to itself.")
628628     }
629629 
630630 
631631 
632632 @Callable(i)
633633 func executeWithdrawal (callerContract_,chainId_,requestWithdrawalId_) = {
634634     let chainId = valueOrErrorMessage(parseInt(chainId_), "executeWithdrawal: chainId not int")
635635     let requestWithdrawalId = valueOrErrorMessage(parseInt(requestWithdrawalId_), "executeWithdrawal: requestWithdrawalId not int")
636636     let requestWithdrawalSize = _loadRequestWithdrawalSize()
637637     let err = if (if (_whenInitialized())
638638         then _chainExists(chainId, "executeWithdrawal: invalid chainId")
639639         else false)
640640         then _validateInt(requestWithdrawalId, 0, (requestWithdrawalSize - 1), "executeWithdrawal: invalid requestWithdrawalId")
641641         else false
642642     if ((err == err))
643643         then {
644644             let err1 = if ((_loadChain(chainId) == WAVES))
645645                 then _validateWavesVault(i.caller, "executeWithdrawal: invalid waves vault")
646646                 else if (_validateExecutor(i.caller, "executeWithdrawal: invalid executor"))
647647                     then _validateCallerContract(chainId, callerContract_, "executeWithdrawal: invalid caller contract")
648648                     else false
649649             if ((err1 == err1))
650650                 then {
651651                     let request = _loadRequestWithdrawal(requestWithdrawalId)
652652                     let requestFrom = request._1
653653                     let requestTo = request._2
654654                     let requestToChainId = request._3
655655                     let requestAsset = request._4
656656                     let requestAmount = request._5
657657                     let requestHeight = request._6
658658                     let requestStatus = request._8
659659                     let newAssetReserves = (_loadAssetReserves(requestToChainId, requestAsset) - requestAmount)
660660                     let newAssetReservesLocked = (_loadAssetReservesLocked(requestToChainId, requestAsset) - requestAmount)
661661                     let currency = _loadAssetCurrency(requestToChainId, requestAsset)
662662                     let newCurrencyReserves = (_loadCurrencyReserves(currency) - requestAmount)
663663                     let newUserLockedCurrency = (_loadUserLockedCurrency(currency, requestFrom) - requestAmount)
664664                     let err2 = if (if (if (if (if (_validateBigInt(newAssetReserves, ZERO_BIGINT, "executeWithdrawal: negative newAssetReserves"))
665665                         then _validateBigInt(newAssetReservesLocked, ZERO_BIGINT, "executeWithdrawal: negative newAssetReservesLocked")
666666                         else false)
667667                         then _validateBigInt(newCurrencyReserves, ZERO_BIGINT, "executeWithdrawal: negative newCurrencyReserves")
668668                         else false)
669669                         then _validateBigInt(newUserLockedCurrency, ZERO_BIGINT, "executeWithdrawal: negative newUserLockedCurrency")
670670                         else false)
671671                         then _validateInt((height - requestHeight), _loadRequestWithdrawalBlockDelay(), MAX_INT, "executeWithdrawal: too early to execute")
672672                         else false)
673673                         then _requestIsCreated(requestStatus, "executeWithdrawal: request is resolved")
674674                         else false
675675                     if ((err2 == err2))
676676                         then {
677677                             let storageInvocation = invoke(_loadAccountStorage(), FUNC_WITHDRAW, [requestFrom, currency, toString(requestAmount)], nil)
678678                             if ((storageInvocation == storageInvocation))
679679                                 then {
680680                                     let withdrawInvocation = if ((_loadChain(requestToChainId) == WAVES))
681681                                         then invoke(_loadWavesVault(), FUNC_WITHDRAW, [requestTo, requestAsset, toString(requestAmount)], nil)
682682                                         else invoke(_loadVaultAdapter(), FUNC_WITHDRAW, [requestToChainId, requestAsset, toString(requestAmount), requestTo], nil)
683683                                     if ((withdrawInvocation == withdrawInvocation))
684684                                         then {
685685                                             let requestUpdated = $Tuple8(request._1, request._2, request._3, request._4, request._5, request._6, request._7, REQUEST_STATUS_DONE)
686686                                             $Tuple2(((((_saveAssetReserves(requestToChainId, requestAsset, newAssetReserves) ++ _saveAssetReservesLocked(requestToChainId, requestAsset, newAssetReservesLocked)) ++ _saveCurrencyReserves(currency, newCurrencyReserves)) ++ _saveUserLockedCurrency(currency, requestFrom, newUserLockedCurrency)) ++ _saveRequestWithdrawal(requestWithdrawalId, requestUpdated)), unit)
687687                                             }
688688                                         else throw("Strict value is not equal to itself.")
689689                                     }
690690                                 else throw("Strict value is not equal to itself.")
691691                             }
692692                         else throw("Strict value is not equal to itself.")
693693                     }
694694                 else throw("Strict value is not equal to itself.")
695695             }
696696         else throw("Strict value is not equal to itself.")
697697     }
698698 
699699 
700700 
701701 @Callable(i)
702702 func rejectWithdrawal (requestWithdrawalId_) = {
703703     let requestWithdrawalId = valueOrErrorMessage(parseInt(requestWithdrawalId_), "rejectWithdrawal: requestWithdrawalId not int")
704704     let requestWithdrawalSize = _loadRequestWithdrawalSize()
705705     let err = if (if (_whenInitialized())
706706         then _validateSequencer(i.caller, "rejectWithdrawal: invalid sequencer")
707707         else false)
708708         then _validateInt(requestWithdrawalId, 0, (requestWithdrawalSize - 1), "rejectWithdrawal: invalid requestWithdrawalId")
709709         else false
710710     if ((err == err))
711711         then {
712712             let request = _loadRequestWithdrawal(requestWithdrawalId)
713713             let requestFrom = request._1
714714             let requestTo = request._2
715715             let requestToChainId = request._3
716716             let requestAsset = request._4
717717             let requestAmount = request._5
718718             let requestHeight = request._6
719719             let requestStatus = request._8
720720             let currency = _loadAssetCurrency(requestToChainId, requestAsset)
721721             let newAssetReservesLocked = (_loadAssetReservesLocked(requestToChainId, requestAsset) - requestAmount)
722722             let newUserLockedCurrency = (_loadUserLockedCurrency(currency, requestFrom) - requestAmount)
723723             let err1 = if (if (_validateBigInt(newAssetReservesLocked, ZERO_BIGINT, "rejectWithdrawal: negative newAssetReservesLocked"))
724724                 then _validateBigInt(newUserLockedCurrency, ZERO_BIGINT, "rejectWithdrawal: negative newUserLockedCurrency")
725725                 else false)
726726                 then _requestIsCreated(requestStatus, "rejectWithdrawal: request is resolved")
727727                 else false
728728             if ((err1 == err1))
729729                 then {
730730                     let availableBalance =                     match invoke(_loadAccountStorage(), FUNC_GET_USER_BALANCE, [requestFrom, SPOT_WALLET, currency], nil) {
731731                         case a: String => 
732732                             parseBigIntValue(a)
733733                         case _ => 
734734                             throw("rejectWithdrawal: can't take available balance from storage")
735735                     }
736736                     if ((availableBalance == availableBalance))
737737                         then if ((requestAmount > availableBalance))
738738                             then {
739739                                 let requestUpdated = $Tuple8(request._1, request._2, request._3, request._4, request._5, request._6, request._7, REQUEST_STATUS_REJECTED)
740740                                 $Tuple2(((_saveAssetReservesLocked(requestToChainId, requestAsset, newAssetReservesLocked) ++ _saveUserLockedCurrency(currency, requestFrom, newUserLockedCurrency)) ++ _saveRequestWithdrawal(requestWithdrawalId, requestUpdated)), true)
741741                                 }
742742                             else $Tuple2(nil, false)
743743                         else throw("Strict value is not equal to itself.")
744744                     }
745745                 else throw("Strict value is not equal to itself.")
746746             }
747747         else throw("Strict value is not equal to itself.")
748748     }
749749 
750750 
751751 
752752 @Callable(i)
753753 func withdraw (from_,to_,toChainId_,asset_,amount_,relayerFee_,timestamp_,web3Id_,alg_,signature_) = {
754754     let toChainId = valueOrErrorMessage(parseInt(toChainId_), "withdraw: toChainId not int")
755755     let amount = valueOrErrorMessage(parseBigInt(amount_), "withdraw: amount not int")
756756     let relayerFee = valueOrErrorMessage(parseBigInt(relayerFee_), "withdraw: relayerFee not int")
757757     let timestamp = valueOrErrorMessage(parseInt(timestamp_), "withdraw: timestamp not int")
758758     let alg = valueOrErrorMessage(parseInt(alg_), "withdraw: alg not int")
759759     let web3Id = fromBase58String(web3Id_)
760760     let signature = fromBase58String(signature_)
761761     let err = if (if (if (if (if (if (if (if (if (if (if (_whenInitialized())
762762         then _validateSequencer(i.caller, "withdraw: invalid sequencer")
763763         else false)
764764         then _validateString(from_, "withdraw: invalid from")
765765         else false)
766766         then _validateString(to_, "withdraw: invalid to")
767767         else false)
768768         then _chainExists(toChainId, "withdraw: invalid toChainId")
769769         else false)
770770         then _assetCurrencyExists(toChainId, asset_, "withdraw: invalid asset")
771771         else false)
772772         then _validateBigInt(amount, ZERO_BIGINT, "withdraw: invalid amount")
773773         else false)
774774         then _validateBigInt_2(relayerFee, ZERO_BIGINT, amount, "withdraw: invalid relayerFee")
775775         else false)
776776         then _validateInt((timestamp + ONE_DAY), lastBlock.timestamp, MAX_INT, "withdraw: invalid timestamp")
777777         else false)
778778         then _validateWeb3Id(web3Id, alg, "withdraw: inv web3Id")
779779         else false)
780780         then _validateSignatureFormat(signature, alg, "withdraw: inv sig format")
781781         else false)
782782         then _validateWeb3IdMatchesAddress(web3Id, from_, alg, "withdraw: web3Id mismatch")
783783         else false
784784     if ((err == err))
785785         then {
786786             let withdrawalBytes = (((((((((((toBytes(size(from_)) + toBytes(from_)) + toBytes(size(to_))) + toBytes(to_)) + toBytes(toChainId)) + toBytes(size(asset_))) + toBytes(asset_)) + toBytes(amount)) + toBytes(relayerFee)) + toBytes(timestamp)) + web3Id) + toBytes(alg))
787787             let withdrawalHash = keccak256_16Kb(withdrawalBytes)
788788             let currency = _loadAssetCurrency(toChainId, asset_)
789789             let availableBalance =             match invoke(_loadAccountStorage(), FUNC_GET_USER_BALANCE, [from_, SPOT_WALLET, currency], nil) {
790790                 case a: String => 
791791                     parseBigIntValue(a)
792792                 case _ => 
793793                     throw("withdraw: can't take available balance from storage")
794794             }
795795             if ((availableBalance == availableBalance))
796796                 then {
797797                     let assetReserves = _loadAssetReserves(toChainId, asset_)
798798                     let lockedReserves = _loadAssetReservesLocked(toChainId, asset_)
799799                     let amountToSend = (amount - relayerFee)
800800                     let amountToSendStr = toString(amountToSend)
801801                     let err1 = if (if (if (_validateWithdrawalSignature(withdrawalHash, signature, web3Id, alg, "withdraw: invalid sig"))
802802                         then _checkWithdrawalHashNotExist(withdrawalHash, "withdraw: already executed")
803803                         else false)
804804                         then _validateBigInt(availableBalance, amountToSend, "withdraw: insufficient balance")
805805                         else false)
806806                         then _validateBigInt((assetReserves - lockedReserves), amountToSend, "withdraw: insufficient reserves")
807807                         else false
808808                     if ((err1 == err1))
809809                         then {
810810                             let newAssetReserves = (assetReserves - amountToSend)
811811                             let newCurrencyReserves = (_loadCurrencyReserves(currency) - amountToSend)
812812                             let err2 = if (_validateBigInt(newAssetReserves, ZERO_BIGINT, "withdraw: negative newAssetReserves"))
813813                                 then _validateBigInt(newCurrencyReserves, ZERO_BIGINT, "withdraw: negative newCurrencyReserves")
814814                                 else false
815815                             if ((err2 == err2))
816816                                 then {
817817                                     let storageInvocation1 = invoke(_loadAccountStorage(), FUNC_WITHDRAW, [from_, currency, amount_], nil)
818818                                     if ((storageInvocation1 == storageInvocation1))
819819                                         then {
820820                                             let storageInvocation2 = invoke(_loadAccountStorage(), FUNC_DEPOSIT, [_loadRelayerFeeRecipient(), currency, relayerFee_], nil)
821821                                             if ((storageInvocation2 == storageInvocation2))
822822                                                 then {
823823                                                     let withdrawInvocation = if ((_loadChain(toChainId) == WAVES))
824824                                                         then invoke(_loadWavesVault(), FUNC_WITHDRAW, [to_, asset_, amountToSendStr], nil)
825825                                                         else invoke(_loadVaultAdapter(), FUNC_WITHDRAW, [toChainId, asset_, amountToSendStr, to_, relayerFee_], nil)
826826                                                     if ((withdrawInvocation == withdrawInvocation))
827827                                                         then $Tuple2(((_saveAssetReserves(toChainId, asset_, newAssetReserves) ++ _saveCurrencyReserves(currency, newCurrencyReserves)) ++ _saveWithdrawalHash(withdrawalHash, toBase58String(i.transactionId))), unit)
828828                                                         else throw("Strict value is not equal to itself.")
829829                                                     }
830830                                                 else throw("Strict value is not equal to itself.")
831831                                             }
832832                                         else throw("Strict value is not equal to itself.")
833833                                     }
834834                                 else throw("Strict value is not equal to itself.")
835835                             }
836836                         else throw("Strict value is not equal to itself.")
837837                     }
838838                 else throw("Strict value is not equal to itself.")
839839             }
840840         else throw("Strict value is not equal to itself.")
841841     }
842842 
843843 
844844 
845845 @Callable(i)
846846 func depositStakingReward (callerContract_,chainId_,asset_,amount_) = {
847847     let chainId = valueOrErrorMessage(parseInt(chainId_), "depositStakingReward: chainId not int")
848848     let amount = valueOrErrorMessage(parseBigInt(amount_), "depositStakingReward: amount not int")
849849     let err = if (if (if (if (_whenInitialized())
850850         then _whenNotPaused()
851851         else false)
852852         then _chainExists(chainId, "depositStakingReward: invalid chainId")
853853         else false)
854854         then _assetCurrencyExists(chainId, asset_, "depositStakingReward: invalid asset")
855855         else false)
856856         then _validateBigInt(amount, ZERO_BIGINT, "depositStakingReward: invalid amount")
857857         else false
858858     if ((err == err))
859859         then {
860860             let err1 = if ((_loadChain(chainId) == WAVES))
861861                 then _validateWavesVault(i.caller, "depositStakingReward: invalid waves vault")
862862                 else if (_validateExecutor(i.caller, "depositStakingReward: invalid executor"))
863863                     then _validateCallerContract(chainId, callerContract_, "depositStakingReward: invalid caller contract")
864864                     else false
865865             if ((err1 == err1))
866866                 then {
867867                     let newAssetReserves = (_loadAssetReserves(chainId, asset_) + amount)
868868                     let currency = _loadAssetCurrency(chainId, asset_)
869869                     let newCurrencyReserves = (_loadCurrencyReserves(currency) + amount)
870870                     let invocation = invoke(_loadAccountStorage(), FUNC_DEPOSIT_STAKING_REWARD, [_loadRewardDistributor(), currency, amount_], nil)
871871                     if ((invocation == invocation))
872872                         then $Tuple2((_saveAssetReserves(chainId, asset_, newAssetReserves) ++ _saveCurrencyReserves(currency, newCurrencyReserves)), unit)
873873                         else throw("Strict value is not equal to itself.")
874874                     }
875875                 else throw("Strict value is not equal to itself.")
876876             }
877877         else throw("Strict value is not equal to itself.")
878878     }
879879 
880880 
881881 
882882 @Callable(i)
883883 func addChain (chainId_,name_,callerContract_) = {
884884     let err = if (if (if (if (if (_onlyThisContract(i.caller))
885885         then _whenInitialized()
886886         else false)
887887         then _validateInt(chainId_, 0, MAX_INT, "addChain: invalid chainId")
888888         else false)
889889         then _validateString(name_, "addChain: invalid name")
890890         else false)
891891         then _validateString(callerContract_, "addChain: invalid callerContract")
892892         else false)
893893         then _chainNotExist(chainId_, "addChain: already exists")
894894         else false
895895     if ((err == err))
896896         then $Tuple2((_saveChain(chainId_, name_) ++ _saveCallerContract(chainId_, callerContract_)), unit)
897897         else throw("Strict value is not equal to itself.")
898898     }
899899 
900900 
901901 
902902 @Callable(i)
903903 func addAsset (chainId_,asset_,currency_) = {
904904     let err = if (if (if (if (if (_onlyThisContract(i.caller))
905905         then _whenInitialized()
906906         else false)
907907         then _chainExists(chainId_, "addAsset: invalid chainId")
908908         else false)
909909         then _validateString(asset_, "addAsset: invalid asset")
910910         else false)
911911         then _validateString(currency_, "addAsset: invalid currency")
912912         else false)
913913         then _assetCurrencyNotExist(chainId_, asset_, "addAsset: already exists")
914914         else false
915915     if ((err == err))
916916         then $Tuple2(_saveAssetCurrency(chainId_, asset_, currency_), unit)
917917         else throw("Strict value is not equal to itself.")
918918     }
919919 
920920 
921921 
922922 @Callable(i)
923923 func setRequestWithdrawalBlockDelay (delay_) = {
924924     let err = if (if (_onlyThisContract(i.caller))
925925         then _whenInitialized()
926926         else false)
927927         then _validateInt(delay_, 0, MAX_INT, "setRequestWithdrawalBlockDelay: invalid delay")
928928         else false
929929     if ((err == err))
930930         then $Tuple2(_saveRequestWithdrawalBlockDelay(delay_), unit)
931931         else throw("Strict value is not equal to itself.")
932932     }
933933 
934934 
935935 
936936 @Callable(i)
937937 func updateRewardDistributor (rewardDistributor_) = {
938938     let err = if (if (_onlyThisContract(i.caller))
939939         then _whenInitialized()
940940         else false)
941941         then _validateString(rewardDistributor_, "updateRewardDistributor: invalid rewardDistributor")
942942         else false
943943     if ((err == err))
944944         then $Tuple2(_saveRewardDistributor(rewardDistributor_), unit)
945945         else throw("Strict value is not equal to itself.")
946946     }
947947 
948948 
949949 
950950 @Callable(i)
951951 func updateRelayerFeeRecipient (relayerFeeRecipient_) = {
952952     let err = if (if (_onlyThisContract(i.caller))
953953         then _whenInitialized()
954954         else false)
955955         then _validateString(relayerFeeRecipient_, "updateRelayerFeeRecipient: invalid relayerFeeRecipient")
956956         else false
957957     if ((err == err))
958958         then $Tuple2(_saveRelayerFeeRecipient(relayerFeeRecipient_), unit)
959959         else throw("Strict value is not equal to itself.")
960960     }
961961 
962962 
963963 
964964 @Callable(i)
965965 func pause () = {
966966     let err = if (if (_onlyPauser(i.caller))
967967         then _whenInitialized()
968968         else false)
969969         then _whenNotPaused()
970970         else false
971971     if ((err == err))
972972         then $Tuple2(_savePause(true), unit)
973973         else throw("Strict value is not equal to itself.")
974974     }
975975 
976976 
977977 
978978 @Callable(i)
979979 func unpause () = {
980980     let err = if (if (_onlyPauser(i.caller))
981981         then _whenInitialized()
982982         else false)
983983         then _whenPaused()
984984         else false
985985     if ((err == err))
986986         then $Tuple2(_savePause(false), unit)
987987         else throw("Strict value is not equal to itself.")
988988     }
989989 
990990 
991991 
992992 @Callable(i)
993993 func updatePauser (pauser_) = {
994994     let err = if (if (_onlyThisContract(i.caller))
995995         then _whenInitialized()
996996         else false)
997997         then _validateAddress(pauser_, "updatePauser: invalid pauser")
998998         else false
999999     if ((err == err))
10001000         then $Tuple2(_savePauser(addressFromStringValue(pauser_)), unit)
10011001         else throw("Strict value is not equal to itself.")
10021002     }
10031003 
10041004 
10051005 
10061006 @Callable(i)
10071007 func setMultisig (multisig_) = {
10081008     let err = if (_onlyThisContract(i.caller))
10091009         then _validateAddress(multisig_, "setMultisig: invalid multisig")
10101010         else false
10111011     if ((err == err))
10121012         then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
10131013         else throw("Strict value is not equal to itself.")
10141014     }
10151015 
10161016 
10171017 @Verifier(tx)
10181018 func verify () = match getString(KEY_MULTISIG) {
10191019     case multisig: String => 
10201020         valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
10211021     case _ => 
10221022         sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
10231023 }
10241024 
github/deemru/w8io/026f985 
107.03 ms ◑