tx · MaC2oQScPuim7GuNbSCMu3DQNKMuYRt8roEavL8JWZD

3NAg2HDvKz7gwrNc2wnUxdK74NydBFUXTYP:  -0.02900000 Waves

2024.07.04 10:38 [3178982] smart account 3NAg2HDvKz7gwrNc2wnUxdK74NydBFUXTYP > SELF 0.00000000 Waves

{ "type": 13, "id": "MaC2oQScPuim7GuNbSCMu3DQNKMuYRt8roEavL8JWZD", "fee": 2900000, "feeAssetId": null, "timestamp": 1720078793867, "version": 2, "chainId": 84, "sender": "3NAg2HDvKz7gwrNc2wnUxdK74NydBFUXTYP", "senderPublicKey": "BEbZF8zo7WjaQFZFFuPs7hqSLEgGwjwQFGg4tSidf9C3", "proofs": [ "5PQF72V8Twsh7AK7vEXHhvqqD16PkAQgLfcEgaTwJBryJ8CQe7NP8dGrh7cz5VXHPMCjm5EGnfT2CfDcsfTZdFtX" ], "script": "base64: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", "height": 3178982, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: HfrtsyoqcdEVaFxU5r5WYqxKStbNaMKKcXtUkx3P5Yxf Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 7 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "__"
5+
6+let b = "MULTISIG"
7+
8+let c = "STATUS"
9+
10+let d = "INIT"
11+
12+let e = "PAUSED"
13+
14+let f = "PAUSER"
15+
16+let g = "EXECUTOR"
17+
18+let h = "CALLER_CONTRACT"
19+
20+let i = "WAVES_VAULT"
21+
22+let j = "ACCOUNT_STORAGE"
23+
24+let k = "CHAIN"
25+
26+let l = "ASSET_CURRENCY"
27+
28+let m = "ASSET_RESERVES"
29+
30+let n = "ASSET_RESERVES_LOCKED"
31+
32+let o = "CURRENCY_RESERVES"
33+
34+let p = "REQUEST_WITHDRAWAL_SIZE"
35+
36+let q = "REQUEST_WITHDRAWAL"
37+
38+let r = "REQUEST_WITHDRAWAL_BLOCK_DELAY"
39+
40+let s = "SEQUENCER"
41+
42+let t = "WITHDRAWAL_HASH"
43+
44+let u = "VAULT_ADAPTER"
45+
46+let v = "REWARD_DISTRIBUTOR"
47+
48+let w = "deposit"
49+
50+let x = "getUserBalance"
51+
52+let y = "internalTransfer"
53+
54+let z = "withdraw"
55+
56+let A = "depositStakingReward"
57+
58+let B = 0
59+
60+let C = 1
61+
62+let D = 2
63+
64+let E = "WAVES"
65+
66+let F = "SPOT"
67+
68+let G = "WITHDRAWALS"
69+
70+let H = 9223372036854775807
71+
72+let I = toBigInt(0)
73+
74+let J = toBigInt(1)
75+
76+let K = 86400000
77+
78+let L = 1
79+
80+let M = 2
81+
82+let N = base58'G5Nu92G2p7moXW9qjjN3na7gtq4dWCeVdaSjry'
83+
84+func O (P,Q) = {
85+ let R = addressFromString(P)
86+ if ($isInstanceOf(R, "Address"))
87+ then {
88+ let S = R
89+ true
90+ }
91+ else throw(Q)
92+ }
93+
94+
95+func T (U,V,W,Q) = if (if ((V > U))
96+ then true
97+ else (U > W))
98+ then throw(Q)
99+ else true
100+
101+
102+func X (U,V,Q) = if ((V > U))
103+ then throw(Q)
104+ else true
105+
106+
107+func Y (U,Q) = if (if ((0 >= size(U)))
108+ then true
109+ else contains(U, a))
110+ then throw(Q)
111+ else true
112+
113+
114+func Z (aa,ab,Q) = if ((aa != ab))
115+ then throw(Q)
116+ else true
117+
118+
119+func ac () = {
120+ let R = getBoolean(d)
121+ if ($isInstanceOf(R, "Boolean"))
122+ then {
123+ let S = R
124+ S
125+ }
126+ else false
127+ }
128+
129+
130+func ad (ae) = [BooleanEntry(d, ae)]
131+
132+
133+func af () = {
134+ let R = getBoolean(e)
135+ if ($isInstanceOf(R, "Boolean"))
136+ then {
137+ let S = R
138+ S
139+ }
140+ else false
141+ }
142+
143+
144+func ag (ah) = [BooleanEntry(e, ah)]
145+
146+
147+func ai () = {
148+ let R = getString(f)
149+ if ($isInstanceOf(R, "String"))
150+ then {
151+ let S = R
152+ addressFromStringValue(S)
153+ }
154+ else Address(base58'')
155+ }
156+
157+
158+func aj (ak) = [StringEntry(f, toString(ak))]
159+
160+
161+func al () = {
162+ let R = getString(b)
163+ if ($isInstanceOf(R, "String"))
164+ then {
165+ let S = R
166+ addressFromStringValue(S)
167+ }
168+ else Address(base58'')
169+ }
170+
171+
172+func am (an) = [StringEntry(b, toString(an))]
173+
174+
175+func ao (ap) = {
176+ let R = getString(makeString([h, toString(ap)], a))
177+ if ($isInstanceOf(R, "String"))
178+ then {
179+ let S = R
180+ S
181+ }
182+ else ""
183+ }
184+
185+
186+func aq (ap,ar) = [StringEntry(makeString([h, toString(ap)], a), ar)]
187+
188+
189+func as () = {
190+ let R = getString(g)
191+ if ($isInstanceOf(R, "String"))
192+ then {
193+ let S = R
194+ addressFromStringValue(S)
195+ }
196+ else Address(base58'')
197+ }
198+
199+
200+func at (au) = [StringEntry(g, toString(au))]
201+
202+
203+func av () = {
204+ let R = getString(j)
205+ if ($isInstanceOf(R, "String"))
206+ then {
207+ let S = R
208+ addressFromStringValue(S)
209+ }
210+ else Address(base58'')
211+ }
212+
213+
214+func aw (ax) = [StringEntry(j, toString(ax))]
215+
216+
217+func ay () = {
218+ let R = getString(i)
219+ if ($isInstanceOf(R, "String"))
220+ then {
221+ let S = R
222+ addressFromStringValue(S)
223+ }
224+ else Address(base58'')
225+ }
226+
227+
228+func az (aA) = [StringEntry(i, toString(aA))]
229+
230+
231+func aB (ap) = {
232+ let R = getString(makeString([k, toString(ap)], a))
233+ if ($isInstanceOf(R, "String"))
234+ then {
235+ let S = R
236+ S
237+ }
238+ else ""
239+ }
240+
241+
242+func aC (ap,aD) = [StringEntry(makeString([k, toString(ap)], a), aD)]
243+
244+
245+func aE (ap,aF) = {
246+ let R = getString(makeString([l, toString(ap), aF], a))
247+ if ($isInstanceOf(R, "String"))
248+ then {
249+ let S = R
250+ S
251+ }
252+ else ""
253+ }
254+
255+
256+func aG (ap,aF,aH) = [StringEntry(makeString([l, toString(ap), aF], a), aH)]
257+
258+
259+func aI (ap,aF) = {
260+ let R = getString(makeString([m, toString(ap), aF], a))
261+ if ($isInstanceOf(R, "String"))
262+ then {
263+ let S = R
264+ parseBigIntValue(S)
265+ }
266+ else I
267+ }
268+
269+
270+func aJ (ap,aF,aK) = [StringEntry(makeString([m, toString(ap), aF], a), toString(aK))]
271+
272+
273+func aL (ap,aF) = {
274+ let R = getString(makeString([n, toString(ap), aF], a))
275+ if ($isInstanceOf(R, "String"))
276+ then {
277+ let S = R
278+ parseBigIntValue(S)
279+ }
280+ else I
281+ }
282+
283+
284+func aM (ap,aF,aK) = [StringEntry(makeString([n, toString(ap), aF], a), toString(aK))]
285+
286+
287+func aN (aH) = {
288+ let R = getString(makeString([o, aH], a))
289+ if ($isInstanceOf(R, "String"))
290+ then {
291+ let S = R
292+ parseBigIntValue(S)
293+ }
294+ else I
295+ }
296+
297+
298+func aO (aH,aK) = [StringEntry(makeString([o, aH], a), toString(aK))]
299+
300+
301+func aP () = {
302+ let R = getInteger(p)
303+ if ($isInstanceOf(R, "Int"))
304+ then {
305+ let S = R
306+ S
307+ }
308+ else 0
309+ }
310+
311+
312+func aQ (U) = [IntegerEntry(p, U)]
313+
314+
315+func aR (aS) = {
316+ let R = getString(makeString([q, toString(aS)], a))
317+ if ($isInstanceOf(R, "String"))
318+ then {
319+ let S = R
320+ let aT = split(S, a)
321+ $Tuple8(aT[0], aT[1], parseIntValue(aT[2]), aT[3], parseBigIntValue(aT[4]), parseIntValue(aT[5]), aT[6], parseIntValue(aT[7]))
322+ }
323+ else $Tuple8("", "", 0, "", I, 0, "", B)
324+ }
325+
326+
327+func aU (aS,aV) = [StringEntry(makeString([q, toString(aS)], a), makeString([aV._1, aV._2, toString(aV._3), aV._4, toString(aV._5), toString(aV._6), aV._7, toString(aV._8)], a))]
328+
329+
330+func aW () = {
331+ let R = getInteger(r)
332+ if ($isInstanceOf(R, "Int"))
333+ then {
334+ let S = R
335+ S
336+ }
337+ else 0
338+ }
339+
340+
341+func aX (aY) = [IntegerEntry(r, aY)]
342+
343+
344+func aZ () = {
345+ let R = getString(s)
346+ if ($isInstanceOf(R, "String"))
347+ then {
348+ let S = R
349+ addressFromStringValue(S)
350+ }
351+ else Address(base58'')
352+ }
353+
354+
355+func ba (bb) = [StringEntry(s, toString(bb))]
356+
357+
358+func bc (bd) = {
359+ let R = getString(makeString([t, toBase58String(bd)], a))
360+ if ($isInstanceOf(R, "String"))
361+ then {
362+ let S = R
363+ S
364+ }
365+ else ""
366+ }
367+
368+
369+func be (bd,bf) = [StringEntry(makeString([t, toBase58String(bd)], a), bf)]
370+
371+
372+func bg () = {
373+ let R = getString(u)
374+ if ($isInstanceOf(R, "String"))
375+ then {
376+ let S = R
377+ addressFromStringValue(S)
378+ }
379+ else Address(base58'')
380+ }
381+
382+
383+func bh (bi) = [StringEntry(u, toString(bi))]
384+
385+
386+func bj () = {
387+ let R = getString(v)
388+ if ($isInstanceOf(R, "String"))
389+ then {
390+ let S = R
391+ S
392+ }
393+ else ""
394+ }
395+
396+
397+func bk (bl) = [StringEntry(v, bl)]
398+
399+
400+func bm (bn) = if ((bn != this))
401+ then throw("_onlyThisContract: revert")
402+ else true
403+
404+
405+func bo () = if ((al() == Address(base58'')))
406+ then throw("_whenMultisigSet: revert")
407+ else true
408+
409+
410+func bp () = if (ac())
411+ then throw("_whenNotInitialized: revert")
412+ else true
413+
414+
415+func bq () = if (!(ac()))
416+ then throw("_whenInitialized: revert")
417+ else true
418+
419+
420+func br () = if (af())
421+ then throw("_whenNotPaused: revert")
422+ else true
423+
424+
425+func bs () = if (!(af()))
426+ then throw("_whenPaused: revert")
427+ else true
428+
429+
430+func bt (bn) = if ((bn != ai()))
431+ then throw("_onlyPauser: revert")
432+ else true
433+
434+
435+func bu (U,Q) = if ((U != as()))
436+ then throw(Q)
437+ else true
438+
439+
440+func bv (ap,ar,Q) = if ((ao(ap) != ar))
441+ then throw(Q)
442+ else true
443+
444+
445+func bw (ap,Q) = if ((0 >= size(aB(ap))))
446+ then throw(Q)
447+ else true
448+
449+
450+func bx (ap,Q) = if ((size(aB(ap)) > 0))
451+ then throw(Q)
452+ else true
453+
454+
455+func by (ap,aF,Q) = if ((0 >= size(aE(ap, aF))))
456+ then throw(Q)
457+ else true
458+
459+
460+func bz (ap,aF,Q) = if ((size(aE(ap, aF)) > 0))
461+ then throw(Q)
462+ else true
463+
464+
465+func bA (bB,Q) = if ((ay() != bB))
466+ then throw(Q)
467+ else true
468+
469+
470+func bC (bD,Q) = if ((bD != B))
471+ then throw(Q)
472+ else true
473+
474+
475+func bE (bB,Q) = if ((aZ() != bB))
476+ then throw(Q)
477+ else true
478+
479+
480+func bF (bd,Q) = if ((size(bc(bd)) > 0))
481+ then throw(Q)
482+ else true
483+
484+
485+func bG (bH,bI,Q) = if ((bI == L))
486+ then if ((size(bH) != 64))
487+ then throw(Q)
488+ else true
489+ else if ((bI == M))
490+ then if ((size(bH) != 65))
491+ then throw(Q)
492+ else true
493+ else throw((Q + ": inv alg"))
494+
495+
496+func bJ (bK,bI,Q) = if ((bI == L))
497+ then if ((size(bK) != 32))
498+ then throw(Q)
499+ else true
500+ else if ((bI == M))
501+ then if ((size(bK) != 20))
502+ then throw(Q)
503+ else true
504+ else throw((Q + ": inv alg"))
505+
506+
507+func bL (bd,bH,bK,bI,Q) = {
508+ let bM = if ((bI == L))
509+ then sigVerify(bd, bH, bK)
510+ else if ((bI == M))
511+ then {
512+ let bN = keccak256_16Kb((N + bd))
513+ (takeRight(keccak256_16Kb(ecrecover(bN, bH)), 20) == bK)
514+ }
515+ else throw((Q + ": inv alg"))
516+ if (!(bM))
517+ then throw(Q)
518+ else true
519+ }
520+
521+
522+func bO (bK,bP,bI,Q) = {
523+ let bQ = if ((bI == L))
524+ then toString(addressFromPublicKey(bK))
525+ else if ((bI == M))
526+ then ("0x" + toBase16String(bK))
527+ else throw((Q + ": inv alg"))
528+ if ((bQ != bP))
529+ then throw(Q)
530+ else true
531+ }
532+
533+
534+@Callable(bR)
535+func init (au,ak,ax,aA,bb,bi) = {
536+ let bS = if (if (if (if (if (if (if (if (bm(bR.caller))
537+ then bp()
538+ else false)
539+ then bo()
540+ else false)
541+ then O(au, "init: invalid executor")
542+ else false)
543+ then O(ak, "init: invalid pauser")
544+ else false)
545+ then O(ax, "init: invalid accountStorage")
546+ else false)
547+ then O(aA, "init: invalid wavesVault")
548+ else false)
549+ then O(bb, "init: invalid sequencer")
550+ else false)
551+ then O(bi, "init: invalid vaultAdapter")
552+ else false
553+ if ((bS == bS))
554+ then $Tuple2(((((((ad(true) ++ at(addressFromStringValue(au))) ++ aj(addressFromStringValue(ak))) ++ aw(addressFromStringValue(ax))) ++ az(addressFromStringValue(aA))) ++ ba(addressFromStringValue(bb))) ++ bh(addressFromStringValue(bi))), unit)
555+ else throw("Strict value is not equal to itself.")
556+ }
557+
558+
559+
560+@Callable(bR)
561+func deposit (ar,bP,bT,ap,aF,bU) = {
562+ let bV = valueOrErrorMessage(parseInt(ap), "deposit: chainId not int")
563+ let bW = valueOrErrorMessage(parseBigInt(bU), "deposit: amount not int")
564+ let bS = if (if (if (if (if (if (bq())
565+ then br()
566+ else false)
567+ then bw(bV, "deposit: invalid chainId")
568+ else false)
569+ then Y(bP, "deposit: invalid from")
570+ else false)
571+ then Y(bT, "deposit: invalid to")
572+ else false)
573+ then by(bV, aF, "deposit: invalid asset")
574+ else false)
575+ then X(bW, I, "deposit: invalid amount")
576+ else false
577+ if ((bS == bS))
578+ then {
579+ let bX = if ((aB(bV) == E))
580+ then bA(bR.caller, "deposit: invalid waves vault")
581+ else if (bu(bR.caller, "deposit: invalid executor"))
582+ then bv(bV, ar, "deposit: invalid caller contract")
583+ else false
584+ if ((bX == bX))
585+ then {
586+ let bY = (aI(bV, aF) + bW)
587+ let bZ = aE(bV, aF)
588+ let ca = (aN(bZ) + bW)
589+ let cb = invoke(av(), w, [bT, bZ, bU], nil)
590+ if ((cb == cb))
591+ then $Tuple2((aJ(bV, aF, bY) ++ aO(bZ, ca)), unit)
592+ else throw("Strict value is not equal to itself.")
593+ }
594+ else throw("Strict value is not equal to itself.")
595+ }
596+ else throw("Strict value is not equal to itself.")
597+ }
598+
599+
600+
601+@Callable(bR)
602+func requestWithdrawal (ar,bP,bT,cc,cd,aF,bU) = {
603+ let ce = valueOrErrorMessage(parseInt(cc), "requestWithdrawal: fromChainId not int")
604+ let cf = valueOrErrorMessage(parseInt(cd), "requestWithdrawal: toChainId not int")
605+ let bW = valueOrErrorMessage(parseBigInt(bU), "requestWithdrawal: amount not int")
606+ let bS = if (if (if (if (if (if (bq())
607+ then bw(ce, "requestWithdrawal: invalid fromChainId")
608+ else false)
609+ then bw(cf, "requestWithdrawal: invalid toChainId")
610+ else false)
611+ then Y(bP, "requestWithdrawal: invalid from")
612+ else false)
613+ then Y(bT, "requestWithdrawal: invalid to")
614+ else false)
615+ then by(cf, aF, "requestWithdrawal: invalid asset")
616+ else false)
617+ then X(bW, I, "requestWithdrawal: invalid amount")
618+ else false
619+ if ((bS == bS))
620+ then {
621+ let bX = if ((aB(ce) == E))
622+ then bA(bR.caller, "requestWithdrawal: invalid waves vault")
623+ else if (bu(bR.caller, "requestWithdrawal: invalid executor"))
624+ then bv(ce, ar, "requestWithdrawal: invalid caller contract")
625+ else false
626+ if ((bX == bX))
627+ then {
628+ let bZ = aE(cf, aF)
629+ let cg = {
630+ let R = invoke(av(), x, [bP, F, bZ], nil)
631+ if ($isInstanceOf(R, "String"))
632+ then {
633+ let S = R
634+ parseBigIntValue(S)
635+ }
636+ else throw("requestWithdrawal: can't take available balance from storage")
637+ }
638+ if ((cg == cg))
639+ then {
640+ let ch = aL(cf, aF)
641+ let ci = if (if ((cg >= bW))
642+ then ((aI(cf, aF) - ch) >= bW)
643+ else false)
644+ then $Tuple3(B, invoke(av(), y, [bP, F, G, bZ, bU], nil), aM(cf, aF, (ch + bW)))
645+ else $Tuple3(D, unit, nil)
646+ if ((ci == ci))
647+ then {
648+ let cj = ci._3
649+ let ck = ci._2
650+ let cl = ci._1
651+ let cm = aP()
652+ let cn = $Tuple8(bP, bT, cf, aF, bW, height, toBase58String(bR.transactionId), cl)
653+ $Tuple2(((aU(cm, cn) ++ aQ((cm + 1))) ++ cj), cm)
654+ }
655+ else throw("Strict value is not equal to itself.")
656+ }
657+ else throw("Strict value is not equal to itself.")
658+ }
659+ else throw("Strict value is not equal to itself.")
660+ }
661+ else throw("Strict value is not equal to itself.")
662+ }
663+
664+
665+
666+@Callable(bR)
667+func executeWithdrawal (ar,ap,co) = {
668+ let bV = valueOrErrorMessage(parseInt(ap), "executeWithdrawal: chainId not int")
669+ let cp = valueOrErrorMessage(parseInt(co), "executeWithdrawal: requestWithdrawalId not int")
670+ let cm = aP()
671+ let bS = if (if (bq())
672+ then bw(bV, "executeWithdrawal: invalid chainId")
673+ else false)
674+ then T(cp, 0, (cm - 1), "executeWithdrawal: invalid requestWithdrawalId")
675+ else false
676+ if ((bS == bS))
677+ then {
678+ let bX = if ((aB(bV) == E))
679+ then bA(bR.caller, "executeWithdrawal: invalid waves vault")
680+ else if (bu(bR.caller, "executeWithdrawal: invalid executor"))
681+ then bv(bV, ar, "executeWithdrawal: invalid caller contract")
682+ else false
683+ if ((bX == bX))
684+ then {
685+ let cq = aR(cp)
686+ let cr = cq._1
687+ let cs = cq._2
688+ let ct = cq._3
689+ let cu = cq._4
690+ let cv = cq._5
691+ let cw = cq._6
692+ let cl = cq._8
693+ let bY = (aI(ct, cu) - cv)
694+ let cx = (aL(ct, cu) - cv)
695+ let bZ = aE(ct, cu)
696+ let ca = (aN(bZ) - cv)
697+ let cy = if (if (if (if (X(bY, I, "executeWithdrawal: negative newAssetReserves"))
698+ then X(cx, I, "executeWithdrawal: negative newAssetReservesLocked")
699+ else false)
700+ then X(ca, I, "executeWithdrawal: negative newCurrencyReserves")
701+ else false)
702+ then T((height - cw), aW(), H, "executeWithdrawal: too early to execute")
703+ else false)
704+ then bC(cl, "executeWithdrawal: request is resolved")
705+ else false
706+ if ((cy == cy))
707+ then {
708+ let ck = invoke(av(), z, [cr, bZ, toString(cv)], nil)
709+ if ((ck == ck))
710+ then {
711+ let cz = if ((aB(ct) == E))
712+ then invoke(ay(), z, [cs, cu, toString(cv)], nil)
713+ else invoke(bg(), z, [ct, cu, toString(cv), cs], nil)
714+ if ((cz == cz))
715+ then {
716+ let cA = $Tuple8(cq._1, cq._2, cq._3, cq._4, cq._5, cq._6, cq._7, C)
717+ $Tuple2((((aJ(ct, cu, bY) ++ aM(ct, cu, cx)) ++ aO(bZ, ca)) ++ aU(cp, cA)), unit)
718+ }
719+ else throw("Strict value is not equal to itself.")
720+ }
721+ else throw("Strict value is not equal to itself.")
722+ }
723+ else throw("Strict value is not equal to itself.")
724+ }
725+ else throw("Strict value is not equal to itself.")
726+ }
727+ else throw("Strict value is not equal to itself.")
728+ }
729+
730+
731+
732+@Callable(bR)
733+func withdraw (bP,bT,cd,aF,bU,cB,bK,bI,bH) = {
734+ let cf = valueOrErrorMessage(parseInt(cd), "withdraw: toChainId not int")
735+ let bW = valueOrErrorMessage(parseBigInt(bU), "withdraw: amount not int")
736+ let cC = valueOrErrorMessage(parseInt(cB), "withdraw: timestamp not int")
737+ let cD = valueOrErrorMessage(parseInt(bI), "withdraw: alg not int")
738+ let cE = fromBase58String(bK)
739+ let cF = fromBase58String(bH)
740+ let bS = if (if (if (if (if (if (if (if (if (if (bq())
741+ then bE(bR.caller, "withdraw: invalid sequencer")
742+ else false)
743+ then Y(bP, "withdraw: invalid from")
744+ else false)
745+ then Y(bT, "withdraw: invalid to")
746+ else false)
747+ then bw(cf, "withdraw: invalid toChainId")
748+ else false)
749+ then by(cf, aF, "withdraw: invalid asset")
750+ else false)
751+ then X(bW, I, "withdraw: invalid amount")
752+ else false)
753+ then T((cC + K), lastBlock.timestamp, H, "withdraw: invalid timestamp")
754+ else false)
755+ then bJ(cE, cD, "withdraw: inv public key")
756+ else false)
757+ then bG(cF, cD, "withdraw: inv sig format")
758+ else false)
759+ then bO(cE, bP, cD, "withdraw: public key mismatch")
760+ else false
761+ if ((bS == bS))
762+ then {
763+ let cG = ((((((((((toBytes(size(bP)) + toBytes(bP)) + toBytes(size(bT))) + toBytes(bT)) + toBytes(cf)) + toBytes(size(aF))) + toBytes(aF)) + toBytes(bW)) + toBytes(cC)) + cE) + toBytes(cD))
764+ let cH = keccak256_16Kb(cG)
765+ let bZ = aE(cf, aF)
766+ let cg = {
767+ let R = invoke(av(), x, [bP, F, bZ], nil)
768+ if ($isInstanceOf(R, "String"))
769+ then {
770+ let S = R
771+ parseBigIntValue(S)
772+ }
773+ else throw("withdraw: can't take available balance from storage")
774+ }
775+ if ((cg == cg))
776+ then {
777+ let cI = aI(cf, aF)
778+ let ch = aL(cf, aF)
779+ let bX = if (if (if (bL(cH, cF, cE, cD, "withdraw: invalid sig"))
780+ then bF(cH, "withdraw: already executed")
781+ else false)
782+ then X(cg, bW, "withdraw: insufficient balance")
783+ else false)
784+ then X((cI - ch), bW, "withdraw: insufficient reserves")
785+ else false
786+ if ((bX == bX))
787+ then {
788+ let bY = (cI - bW)
789+ let ca = (aN(bZ) - bW)
790+ let cy = if (X(bY, I, "withdraw: negative newAssetReserves"))
791+ then X(ca, I, "withdraw: negative newCurrencyReserves")
792+ else false
793+ if ((cy == cy))
794+ then {
795+ let ck = invoke(av(), y, [bP, F, G, bZ, bU], nil)
796+ if ((ck == ck))
797+ then {
798+ let cJ = invoke(av(), z, [bP, bZ, bU], nil)
799+ if ((cJ == cJ))
800+ then {
801+ let cz = if ((aB(cf) == E))
802+ then invoke(ay(), z, [bT, aF, bU], nil)
803+ else invoke(bg(), z, [cf, aF, bU, bT], nil)
804+ if ((cz == cz))
805+ then $Tuple2(((aJ(cf, aF, bY) ++ aO(bZ, ca)) ++ be(cH, toBase58String(bR.transactionId))), unit)
806+ else throw("Strict value is not equal to itself.")
807+ }
808+ else throw("Strict value is not equal to itself.")
809+ }
810+ else throw("Strict value is not equal to itself.")
811+ }
812+ else throw("Strict value is not equal to itself.")
813+ }
814+ else throw("Strict value is not equal to itself.")
815+ }
816+ else throw("Strict value is not equal to itself.")
817+ }
818+ else throw("Strict value is not equal to itself.")
819+ }
820+
821+
822+
823+@Callable(bR)
824+func depositStakingReward (ar,ap,aF,bU) = {
825+ let bV = valueOrErrorMessage(parseInt(ap), "depositStakingReward: chainId not int")
826+ let bW = valueOrErrorMessage(parseBigInt(bU), "depositStakingReward: amount not int")
827+ let bS = if (if (if (if (bq())
828+ then br()
829+ else false)
830+ then bw(bV, "depositStakingReward: invalid chainId")
831+ else false)
832+ then by(bV, aF, "depositStakingReward: invalid asset")
833+ else false)
834+ then X(bW, I, "depositStakingReward: invalid amount")
835+ else false
836+ if ((bS == bS))
837+ then {
838+ let bX = if ((aB(bV) == E))
839+ then bA(bR.caller, "depositStakingReward: invalid waves vault")
840+ else if (bu(bR.caller, "depositStakingReward: invalid executor"))
841+ then bv(bV, ar, "depositStakingReward: invalid caller contract")
842+ else false
843+ if ((bX == bX))
844+ then {
845+ let bY = (aI(bV, aF) + bW)
846+ let bZ = aE(bV, aF)
847+ let ca = (aN(bZ) + bW)
848+ let cb = invoke(av(), A, [bj(), bZ, bU], nil)
849+ if ((cb == cb))
850+ then $Tuple2((aJ(bV, aF, bY) ++ aO(bZ, ca)), unit)
851+ else throw("Strict value is not equal to itself.")
852+ }
853+ else throw("Strict value is not equal to itself.")
854+ }
855+ else throw("Strict value is not equal to itself.")
856+ }
857+
858+
859+
860+@Callable(bR)
861+func addChain (ap,aD,ar) = {
862+ let bS = if (if (if (if (if (bm(bR.caller))
863+ then bq()
864+ else false)
865+ then T(ap, 0, H, "addChain: invalid chainId")
866+ else false)
867+ then Y(aD, "addChain: invalid name")
868+ else false)
869+ then Y(ar, "addChain: invalid callerContract")
870+ else false)
871+ then bx(ap, "addChain: already exists")
872+ else false
873+ if ((bS == bS))
874+ then $Tuple2((aC(ap, aD) ++ aq(ap, ar)), unit)
875+ else throw("Strict value is not equal to itself.")
876+ }
877+
878+
879+
880+@Callable(bR)
881+func addAsset (ap,aF,aH) = {
882+ let bS = if (if (if (if (if (bm(bR.caller))
883+ then bq()
884+ else false)
885+ then bw(ap, "addAsset: invalid chainId")
886+ else false)
887+ then Y(aF, "addAsset: invalid asset")
888+ else false)
889+ then Y(aH, "addAsset: invalid currency")
890+ else false)
891+ then bz(ap, aF, "addAsset: already exists")
892+ else false
893+ if ((bS == bS))
894+ then $Tuple2(aG(ap, aF, aH), unit)
895+ else throw("Strict value is not equal to itself.")
896+ }
897+
898+
899+
900+@Callable(bR)
901+func setRequestWithdrawalBlockDelay (aY) = {
902+ let bS = if (if (bm(bR.caller))
903+ then bq()
904+ else false)
905+ then T(aY, 0, H, "setRequestWithdrawalBlockDelay: invalid delay")
906+ else false
907+ if ((bS == bS))
908+ then $Tuple2(aX(aY), unit)
909+ else throw("Strict value is not equal to itself.")
910+ }
911+
912+
913+
914+@Callable(bR)
915+func updateRewardDistributor (cK) = {
916+ let bS = if (if (bm(bR.caller))
917+ then bq()
918+ else false)
919+ then Y(cK, "updateRewardDistributor: invalid rewardDistributor")
920+ else false
921+ if ((bS == bS))
922+ then $Tuple2(bk(cK), unit)
923+ else throw("Strict value is not equal to itself.")
924+ }
925+
926+
927+
928+@Callable(bR)
929+func pause () = {
930+ let bS = if (if (bt(bR.caller))
931+ then bq()
932+ else false)
933+ then br()
934+ else false
935+ if ((bS == bS))
936+ then $Tuple2(ag(true), unit)
937+ else throw("Strict value is not equal to itself.")
938+ }
939+
940+
941+
942+@Callable(bR)
943+func unpause () = {
944+ let bS = if (if (bt(bR.caller))
945+ then bq()
946+ else false)
947+ then bs()
948+ else false
949+ if ((bS == bS))
950+ then $Tuple2(ag(false), unit)
951+ else throw("Strict value is not equal to itself.")
952+ }
953+
954+
955+
956+@Callable(bR)
957+func updatePauser (ak) = {
958+ let bS = if (if (bm(bR.caller))
959+ then bq()
960+ else false)
961+ then O(ak, "updatePauser: invalid pauser")
962+ else false
963+ if ((bS == bS))
964+ then $Tuple2(aj(addressFromStringValue(ak)), unit)
965+ else throw("Strict value is not equal to itself.")
966+ }
967+
968+
969+
970+@Callable(bR)
971+func setMultisig (an) = {
972+ let bS = if (bm(bR.caller))
973+ then O(an, "setMultisig: invalid multisig")
974+ else false
975+ if ((bS == bS))
976+ then $Tuple2(am(addressFromStringValue(an)), unit)
977+ else throw("Strict value is not equal to itself.")
978+ }
979+
980+
981+@Verifier(cL)
982+func cM () = {
983+ let R = getString(b)
984+ if ($isInstanceOf(R, "String"))
985+ then {
986+ let cN = R
987+ valueOrElse(getBoolean(addressFromStringValue(cN), makeString([c, toString(this), toBase58String(cL.id)], a)), false)
988+ }
989+ else sigVerify(cL.bodyBytes, cL.proofs[0], cL.senderPublicKey)
990+ }
991+

github/deemru/w8io/169f3d6 
44.96 ms