tx · CvSULfUYVtr5buc9CPvVWmqXsmaPHDdjbdtXkwZ6Cd7p

3N1vLkqi1Wz7MDLtpwRFBg5V33fHpnxaFuV:  -0.03300000 Waves

2024.11.21 12:37 [3381040] smart account 3N1vLkqi1Wz7MDLtpwRFBg5V33fHpnxaFuV > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CvSULfUYVtr5buc9CPvVWmqXsmaPHDdjbdtXkwZ6Cd7p",
    "fee": 3300000,
    "feeAssetId": null,
    "timestamp": 1732181845850,
    "version": 2,
    "chainId": 84,
    "sender": "3N1vLkqi1Wz7MDLtpwRFBg5V33fHpnxaFuV",
    "senderPublicKey": "8eBztzvcDYHno9SMCjk6rkQHJHDMXFt5YcknLLsAARn8",
    "proofs": [
        "wvo1ZMGeNc39V4Leq3Xu8VjFR29CfQxZuir6vQbNhhXNjRAKisYqTFV48DXcj6DsQ4buQZPJNQtfZNktk57vZxg"
    ],
    "script": "base64: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",
    "height": 3381040,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 68kEWqAWVfGSHooYJBtCXdhuSE9A2GGtBCQ7nVbMimTw
Next: EcLnWubJd8b39aSV8SPrYpW7ionZh51brxuV7QptJUAJ

Diff: 

OldNewDifferences
461461         else throw((err_ + ": inv alg"))
462462 
463463 
464-func _validatePublicKey (publicKey_,alg_,err_) = if ((alg_ == ALG_TYPE_WAVES))
465-    then if ((size(publicKey_) != 32))
464+func _validateWeb3Id (web3Id_,alg_,err_) = if ((alg_ == ALG_TYPE_WAVES))
465+    then if ((size(web3Id_) != 32))
466466         then throw(err_)
467467         else true
468468     else if ((alg_ == ALG_TYPE_EVM))
469-        then if ((size(publicKey_) != 20))
469+        then if ((size(web3Id_) != 20))
470470             then throw(err_)
471471             else true
472472         else throw((err_ + ": inv alg"))
473473 
474474 
475-func _validateWithdrawalSignature (withdrawalHash_,signature_,publicKey_,alg_,err_) = {
475+func _validateWithdrawalSignature (withdrawalHash_,signature_,web3Id_,alg_,err_) = {
476476     let result = if ((alg_ == ALG_TYPE_WAVES))
477-        then sigVerify(withdrawalHash_, signature_, publicKey_)
477+        then sigVerify(withdrawalHash_, signature_, web3Id_)
478478         else if ((alg_ == ALG_TYPE_EVM))
479479             then {
480480                 let hashWithPrefix = keccak256_16Kb((EVM_SIGNATURE_PREFIX + withdrawalHash_))
481-                (takeRight(keccak256_16Kb(ecrecover(hashWithPrefix, signature_)), 20) == publicKey_)
481+                (takeRight(keccak256_16Kb(ecrecover(hashWithPrefix, signature_)), 20) == web3Id_)
482482                 }
483483             else throw((err_ + ": inv alg"))
484484     if (!(result))
487487     }
488488 
489489 
490-func _validatePublicKeyMatchesAddress (publicKey_,from_,alg_,err_) = {
490+func _validateWeb3IdMatchesAddress (web3Id_,from_,alg_,err_) = {
491491     let address = if ((alg_ == ALG_TYPE_WAVES))
492-        then toString(addressFromPublicKey(publicKey_))
492+        then toString(addressFromPublicKey(web3Id_))
493493         else if ((alg_ == ALG_TYPE_EVM))
494-            then ("0x" + toBase16String(publicKey_))
494+            then ("0x" + toBase16String(web3Id_))
495495             else throw((err_ + ": inv alg"))
496496     if ((address != from_))
497497         then throw(err_)
604604                         then {
605605                             let lockedReserves = _loadAssetReservesLocked(toChainId, asset_)
606606                             let userLockedCurrency = _loadUserLockedCurrency(currency, from_)
607-                            let $t01928819743 = if (if (((availableBalance - userLockedCurrency) >= amount))
607+                            let $t01929519750 = if (if (((availableBalance - userLockedCurrency) >= amount))
608608                                 then ((_loadAssetReserves(toChainId, asset_) - lockedReserves) >= amount)
609609                                 else false)
610610                                 then $Tuple2(REQUEST_STATUS_CREATED, (_saveAssetReservesLocked(toChainId, asset_, (lockedReserves + amount)) ++ _saveUserLockedCurrency(currency, from_, (amount + userLockedCurrency))))
611611                                 else $Tuple2(REQUEST_STATUS_REJECTED, nil)
612-                            let requestStatus = $t01928819743._1
613-                            let reservesActions = $t01928819743._2
612+                            let requestStatus = $t01929519750._1
613+                            let reservesActions = $t01929519750._2
614614                             let requestWithdrawalSize = _loadRequestWithdrawalSize()
615615                             let requestWithdrawal = $Tuple8(from_, to_, toChainId, asset_, amount, height, toBase58String(i.transactionId), requestStatus)
616616                             $Tuple2(((_saveRequestWithdrawal(requestWithdrawalSize, requestWithdrawal) ++ _saveRequestWithdrawalSize((requestWithdrawalSize + 1))) ++ reservesActions), requestWithdrawalSize)
745745 
746746 
747747 @Callable(i)
748-func withdraw (from_,to_,toChainId_,asset_,amount_,gaslessFee_,timestamp_,publicKey_,alg_,signature_) = {
748+func withdraw (from_,to_,toChainId_,asset_,amount_,relayerFee_,timestamp_,web3Id_,alg_,signature_) = {
749749     let toChainId = valueOrErrorMessage(parseInt(toChainId_), "withdraw: toChainId not int")
750750     let amount = valueOrErrorMessage(parseBigInt(amount_), "withdraw: amount not int")
751-    let gaslessFee = valueOrErrorMessage(parseBigInt(gaslessFee_), "withdraw: gaslessFee not int")
751+    let relayerFee = valueOrErrorMessage(parseBigInt(relayerFee_), "withdraw: relayerFee not int")
752752     let timestamp = valueOrErrorMessage(parseInt(timestamp_), "withdraw: timestamp not int")
753753     let alg = valueOrErrorMessage(parseInt(alg_), "withdraw: alg not int")
754-    let publicKey = fromBase58String(publicKey_)
754+    let web3Id = fromBase58String(web3Id_)
755755     let signature = fromBase58String(signature_)
756756     let err = if (if (if (if (if (if (if (if (if (if (if (_whenInitialized())
757757         then _validateSequencer(i.caller, "withdraw: invalid sequencer")
766766         else false)
767767         then _validateBigInt(amount, ZERO_BIGINT, "withdraw: invalid amount")
768768         else false)
769-        then _validateBigInt_2(gaslessFee, ZERO_BIGINT, amount, "withdraw: invalid gaslessFee")
769+        then _validateBigInt_2(relayerFee, ZERO_BIGINT, amount, "withdraw: invalid relayerFee")
770770         else false)
771771         then _validateInt((timestamp + ONE_DAY), lastBlock.timestamp, MAX_INT, "withdraw: invalid timestamp")
772772         else false)
773-        then _validatePublicKey(publicKey, alg, "withdraw: inv public key")
773+        then _validateWeb3Id(web3Id, alg, "withdraw: inv web3Id")
774774         else false)
775775         then _validateSignatureFormat(signature, alg, "withdraw: inv sig format")
776776         else false)
777-        then _validatePublicKeyMatchesAddress(publicKey, from_, alg, "withdraw: public key mismatch")
777+        then _validateWeb3IdMatchesAddress(web3Id, from_, alg, "withdraw: web3Id mismatch")
778778         else false
779779     if ((err == err))
780780         then {
781-            let withdrawalBytes = (((((((((((toBytes(size(from_)) + toBytes(from_)) + toBytes(size(to_))) + toBytes(to_)) + toBytes(toChainId)) + toBytes(size(asset_))) + toBytes(asset_)) + toBytes(amount)) + toBytes(gaslessFee)) + toBytes(timestamp)) + publicKey) + toBytes(alg))
781+            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))
782782             let withdrawalHash = keccak256_16Kb(withdrawalBytes)
783783             let currency = _loadAssetCurrency(toChainId, asset_)
784784             let availableBalance =             match invoke(_loadAccountStorage(), FUNC_GET_USER_BALANCE, [from_, SPOT_WALLET, currency], nil) {
791791                 then {
792792                     let assetReserves = _loadAssetReserves(toChainId, asset_)
793793                     let lockedReserves = _loadAssetReservesLocked(toChainId, asset_)
794-                    let amountToSend = (amount - gaslessFee)
794+                    let amountToSend = (amount - relayerFee)
795795                     let amountToSendStr = toString(amountToSend)
796-                    let err1 = if (if (if (_validateWithdrawalSignature(withdrawalHash, signature, publicKey, alg, "withdraw: invalid sig"))
796+                    let err1 = if (if (if (_validateWithdrawalSignature(withdrawalHash, signature, web3Id, alg, "withdraw: invalid sig"))
797797                         then _checkWithdrawalHashNotExist(withdrawalHash, "withdraw: already executed")
798798                         else false)
799799                         then _validateBigInt(availableBalance, amountToSend, "withdraw: insufficient balance")
812812                                     let storageInvocation1 = invoke(_loadAccountStorage(), FUNC_WITHDRAW, [from_, currency, amount_], nil)
813813                                     if ((storageInvocation1 == storageInvocation1))
814814                                         then {
815-                                            let storageInvocation2 = invoke(_loadAccountStorage(), FUNC_DEPOSIT, [_loadRelayerFeeRecipient(), currency, gaslessFee_], nil)
815+                                            let storageInvocation2 = invoke(_loadAccountStorage(), FUNC_DEPOSIT, [_loadRelayerFeeRecipient(), currency, relayerFee_], nil)
816816                                             if ((storageInvocation2 == storageInvocation2))
817817                                                 then {
818818                                                     let withdrawInvocation = if ((_loadChain(toChainId) == WAVES))
819819                                                         then invoke(_loadWavesVault(), FUNC_WITHDRAW, [to_, asset_, amountToSendStr], nil)
820-                                                        else invoke(_loadVaultAdapter(), FUNC_WITHDRAW, [toChainId, asset_, amountToSendStr, to_, gaslessFee_], nil)
820+                                                        else invoke(_loadVaultAdapter(), FUNC_WITHDRAW, [toChainId, asset_, amountToSendStr, to_, relayerFee_], nil)
821821                                                     if ((withdrawInvocation == withdrawInvocation))
822822                                                         then $Tuple2(((_saveAssetReserves(toChainId, asset_, newAssetReserves) ++ _saveCurrencyReserves(currency, newCurrencyReserves)) ++ _saveWithdrawalHash(withdrawalHash, toBase58String(i.transactionId))), unit)
823823                                                         else throw("Strict value is not equal to itself.")

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