tx · EwKb2Q297EByqBoVLdBHeidEkvRBiKSzXDm1NWmYW346

3N59U742XgXGyo9yu5rW7Y6Nd4k317Z1d3o:  -0.02600000 Waves

2023.03.03 00:39 [2472997] smart account 3N59U742XgXGyo9yu5rW7Y6Nd4k317Z1d3o > SELF 0.00000000 Waves

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

github/deemru/w8io/169f3d6 
45.25 ms