tx · 5W9d77tS1R42Lh8wgjvJW53Tp9XaRoezYxuncQFJHVUh

3N5mU3v3CtrgYMEBDGm93X9FrP2h3fSg8sL:  -0.01000000 Waves

2022.04.05 15:32 [1995289] smart account 3N5mU3v3CtrgYMEBDGm93X9FrP2h3fSg8sL > SELF 0.00000000 Waves

{ "type": 13, "id": "5W9d77tS1R42Lh8wgjvJW53Tp9XaRoezYxuncQFJHVUh", "fee": 1000000, "feeAssetId": null, "timestamp": 1649162020770, "version": 2, "chainId": 84, "sender": "3N5mU3v3CtrgYMEBDGm93X9FrP2h3fSg8sL", "senderPublicKey": "EWpZ2i6w6d1VzEBR5s47daRMoJ4uBWEtGVFup9eg2vFm", "proofs": [ "3Ngt52tTqLA4vqrQDaVxbHmCqVm2rG9sc5NDPT2jvT8p5uownict9f28uVZFjz9G8mVfq67TjJWSYNXdKgscALu3" ], "script": "base64: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", "height": 1995289, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: 33jXYgP17njAJB3z4mJ6QQR6ChpH4Po6uQHPbnCqxPWU Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "2.0.0"
5+
6+let b = "version"
7+
8+let c = "active"
9+
10+let d = "A_asset_id"
11+
12+let e = "B_asset_id"
13+
14+let f = "A_asset_balance"
15+
16+let g = "B_asset_balance"
17+
18+let h = "share_asset_id"
19+
20+let i = "share_asset_supply"
21+
22+let j = "commission"
23+
24+let k = "commission_scale_delimiter"
25+
26+let l = "invariant"
27+
28+let m = "shutdown_cause"
29+
30+let n = "staking_usdnnsbt_address"
31+
32+let o = "staking_eurn_address"
33+
34+let p = "admin_pub_1"
35+
36+let q = "admin_pub_2"
37+
38+let r = "admin_pub_3"
39+
40+let s = Address(base58'3N77kfPbQyjXWpDALX3xjKw3iEGMWEctV37')
41+
42+let t = Address(base58'3NBBWfzZtZtszaXbitTKnrB2xXwv26Bn7H9')
43+
44+func u (v) = {
45+ let w = getString(t, v)
46+ if ($isInstanceOf(w, "String"))
47+ then {
48+ let x = w
49+ fromBase58String(x)
50+ }
51+ else {
52+ let y = w
53+ throw("Admin public key is empty")
54+ }
55+ }
56+
57+
58+let z = u(p)
59+
60+let A = u(q)
61+
62+let B = u(r)
63+
64+let C = base58'Kn7NpzaG12dLZgcHf2ipUftU6hbJygmrhFqQYE4B7ZK'
65+
66+let D = base58'Kn7NpzaG12dLZgcHf2ipUftU6hbJygmrhFqQYE4B7ZK'
67+
68+let E = Address(base58'3NAGTtZz6WpupSN89NZD5rMZwwziZEg4Kx4')
69+
70+let F = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
71+
72+let G = base58'ECBCkHS68DckpBrzLeoRgYbFg7sCVqR176mPqbXsj9pA'
73+
74+let H = [toBase58String(F), toBase58String(G)]
75+
76+let I = Address(fromBase58String(valueOrErrorMessage(getString(t, n), "no usdn staking address")))
77+
78+let J = Address(fromBase58String(valueOrErrorMessage(getString(t, o), "no usdn staking address")))
79+
80+let K = getBooleanValue(this, c)
81+
82+let L = getStringValue(this, d)
83+
84+let M = getStringValue(this, e)
85+
86+let N = if ((L == "WAVES"))
87+ then unit
88+ else fromBase58String(L)
89+
90+let O = if ((M == "WAVES"))
91+ then unit
92+ else fromBase58String(M)
93+
94+let P = {
95+ let w = N
96+ if ($isInstanceOf(w, "ByteVector"))
97+ then {
98+ let Q = w
99+ value(assetInfo(Q)).name
100+ }
101+ else if ($isInstanceOf(w, "Unit"))
102+ then {
103+ let R = w
104+ "WAVES"
105+ }
106+ else throw("Match error")
107+ }
108+
109+let S = {
110+ let w = O
111+ if ($isInstanceOf(w, "ByteVector"))
112+ then {
113+ let Q = w
114+ value(assetInfo(Q)).name
115+ }
116+ else if ($isInstanceOf(w, "Unit"))
117+ then {
118+ let R = w
119+ "WAVES"
120+ }
121+ else throw("Match error")
122+ }
123+
124+let T = getIntegerValue(this, f)
125+
126+let U = getIntegerValue(this, g)
127+
128+let V = fromBase58String(getStringValue(this, h))
129+
130+let W = getIntegerValue(this, i)
131+
132+let X = getIntegerValue(this, l)
133+
134+let Y = 500
135+
136+let Z = 200
137+
138+let aa = 1000000
139+
140+let ab = 1000
141+
142+let ac = 100000000
143+
144+let ad = 10000000000000000
145+
146+let ae = 1000
147+
148+let af = 8
149+
150+let ag = 50
151+
152+let ah = 100
153+
154+let ai = 90000000
155+
156+let aj = 110000000
157+
158+let ak = 50
159+
160+let al = 2
161+
162+let am = 4600000000000000
163+
164+func an (ao) = {
165+ let w = ao
166+ if ($isInstanceOf(w, "ByteVector"))
167+ then {
168+ let Q = w
169+ assetBalance(this, Q)
170+ }
171+ else if ($isInstanceOf(w, "Unit"))
172+ then {
173+ let R = w
174+ wavesBalance(this).available
175+ }
176+ else throw("Match error")
177+ }
178+
179+
180+func ap (ao) = {
181+ let aq = {
182+ let w = ao
183+ if ($isInstanceOf(w, "ByteVector"))
184+ then {
185+ let ar = w
186+ if ((ar == F))
187+ then getInteger(I, ((("rpd_balance_" + toBase58String(ar)) + "_") + toString(this)))
188+ else if ((ar == G))
189+ then getInteger(J, ((("%s%s%s__stakingBalance__" + toBase58String(ar)) + "__") + toString(this)))
190+ else 0
191+ }
192+ else if ($isInstanceOf(w, "Unit"))
193+ then 0
194+ else throw("Match error")
195+ }
196+ let w = aq
197+ if ($isInstanceOf(w, "Int"))
198+ then {
199+ let as = w
200+ as
201+ }
202+ else 0
203+ }
204+
205+
206+let at = ap(N)
207+
208+let au = ap(O)
209+
210+let av = (T - at)
211+
212+let aw = (U - au)
213+
214+let ax = (an(N) + at)
215+
216+let ay = (an(O) + au)
217+
218+let az = if ((ax >= T))
219+ then (ay >= U)
220+ else false
221+
222+func aA (aB,aC) = ((fraction(ad, aB, aC) + fraction(ad, aC, aB)) / 2)
223+
224+
225+func aD (aB,aC) = {
226+ let aE = aA(aB, aC)
227+ (fraction((aB + aC), ad, pow(aE, af, ak, al, af, CEILING)) + (2 * fraction(toInt(pow(fraction(toBigInt(aB), toBigInt(aC), toBigInt(ac)), 0, toBigInt(5), 1, (af / 2), DOWN)), pow((aE - am), af, ak, al, af, DOWN), ac)))
228+ }
229+
230+
231+func aF (aG,aH,aI,aJ) = {
232+ let aK = (ad - ((ad * 1) / 10000000))
233+ let aL = (aG - aH)
234+ let aB = (T + aI)
235+ let aC = (U + aI)
236+ func aM (aN,aO) = if ((aN._1 == -1))
237+ then {
238+ let aP = (aG - (((aO * aL) / 3) / ab))
239+ let aQ = if ((aJ == N))
240+ then aD(aB, (U - aP))
241+ else aD((T - aP), aC)
242+ if ((aQ > X))
243+ then $Tuple2(aP, aQ)
244+ else $Tuple2(-1, 0)
245+ }
246+ else aN
247+
248+ let aR = aM($Tuple2(-1, 0), 3000)
249+ if ((0 > aR._1))
250+ then throw("Price is worse than minReceived")
251+ else {
252+ let aS = if ((aJ == N))
253+ then aD(aB, (U - aG))
254+ else if ((aJ == O))
255+ then aD((T - aG), aC)
256+ else throw("Wrong asset in payment")
257+ if ((X > aS))
258+ then if ((aK >= fraction(ad, X, aS)))
259+ then throw("The requested price is too not profitable for user")
260+ else {
261+ let aT = {
262+ let aU = [25, 200, 500]
263+ let aV = size(aU)
264+ let aW = $Tuple2(-1, 0)
265+ func aX (aY,aZ) = if ((aZ >= aV))
266+ then aY
267+ else aM(aY, aU[aZ])
268+
269+ func ba (aY,aZ) = if ((aZ >= aV))
270+ then aY
271+ else throw("List size exceeds 3")
272+
273+ ba(aX(aX(aX(aW, 0), 1), 2), 3)
274+ }
275+ if ((0 > aT._1))
276+ then aR._1
277+ else aT._1
278+ }
279+ else {
280+ let aT = {
281+ let aU = [-500, -200, -25]
282+ let aV = size(aU)
283+ let aW = $Tuple2(-1, 0)
284+ func aX (aY,aZ) = if ((aZ >= aV))
285+ then aY
286+ else aM(aY, aU[aZ])
287+
288+ func ba (aY,aZ) = if ((aZ >= aV))
289+ then aY
290+ else throw("List size exceeds 3")
291+
292+ ba(aX(aX(aX(aW, 0), 1), 2), 3)
293+ }
294+ let bb = if ((0 > aT._1))
295+ then $Tuple2(aG, aS)
296+ else aT
297+ if ((aK >= fraction(ad, X, bb._2)))
298+ then throw("The requested price is too not profitable for user")
299+ else bb._1
300+ }
301+ }
302+ }
303+
304+
305+func bc (ao) = {
306+ let w = ao
307+ if ($isInstanceOf(w, "ByteVector"))
308+ then {
309+ let Q = w
310+ let bd = toBase58String(Q)
311+ let be = valueOrErrorMessage(assetInfo(Q), (("Asset " + bd) + " doesn't exist"))
312+ $Tuple3(bd, be.name, be.decimals)
313+ }
314+ else if ($isInstanceOf(w, "Unit"))
315+ then {
316+ let R = w
317+ $Tuple3("WAVES", "WAVES", 8)
318+ }
319+ else throw("Match error")
320+ }
321+
322+
323+func bf (bg) = [BooleanEntry(c, false), StringEntry(m, bg)]
324+
325+
326+func bh () = throw("DApp is already active")
327+
328+
329+func bi () = if (K)
330+ then unit
331+ else throw("DApp is inactive at this moment")
332+
333+
334+func bj (as) = if (containsElement([z, A, B], as.callerPublicKey))
335+ then unit
336+ else throw("Only admin can call this function")
337+
338+
339+func bk () = throw(((("Incorrect assets attached. Expected: " + L) + " and ") + M))
340+
341+
342+func bl () = throw("One attached payment expected")
343+
344+
345+func bm (bn,bo,bp) = throw(((((((((("New balance in assets of the DApp is less than threshold " + toString(bn)) + ": ") + toString(bo)) + " ") + P) + ", ") + toString(bp)) + " ") + S))
346+
347+
348+func bq () = bf(((((((((((((((("Suspicious state. Actual balances: " + toString(T)) + " ") + P) + ", ") + toString(U)) + " ") + S) + ". State: ") + toString(an(N))) + " ") + P) + ", ") + toString(an(O))) + " ") + S))
349+
350+
351+func br (bs,ao) = if (bs)
352+ then if ((ao == F))
353+ then $Tuple2("lockNeutrino", I)
354+ else $Tuple2("startStaking", J)
355+ else if ((ao == F))
356+ then $Tuple2("unlockNeutrino", I)
357+ else $Tuple2("stopStaking", J)
358+
359+
360+func bt (bs,bu,ao) = if (bs)
361+ then {
362+ let bv = br(bs, ao)
363+ let bw = bv._1
364+ let bx = bv._2
365+ $Tuple4(bw, bx, nil, [AttachedPayment(ao, bu)])
366+ }
367+ else {
368+ let by = br(bs, ao)
369+ let bw = by._1
370+ let bx = by._2
371+ $Tuple4(bw, bx, [bu, toBase58String(ao)], nil)
372+ }
373+
374+
375+@Callable(as)
376+func init () = {
377+ let bz = $Tuple2(as.payments[0].amount, as.payments[0].assetId)
378+ let bA = bz._1
379+ let bB = bz._2
380+ let bC = $Tuple2(as.payments[1].amount, as.payments[1].assetId)
381+ let bD = bC._1
382+ let bE = bC._2
383+ let bF = bc(bB)
384+ let bG = bF._1
385+ let bH = bF._2
386+ let bI = bF._3
387+ let bJ = bc(bE)
388+ let bK = bJ._1
389+ let bL = bJ._2
390+ let bM = bJ._3
391+ if (isDefined(getBoolean(this, c)))
392+ then bh()
393+ else if ((bB == bE))
394+ then throw("Assets must be different")
395+ else {
396+ let bN = ((("s" + take(bH, 7)) + "_") + take(bL, 7))
397+ let bO = ((((("ShareToken of SwopFi protocol for " + bH) + " and ") + bL) + " at address ") + toString(this))
398+ let bP = ((bI + bM) / 2)
399+ let bQ = fraction(pow(bA, bI, 5, 1, bI, DOWN), pow(bD, bM, 5, 1, bM, DOWN), pow(10, 0, bP, 0, 0, DOWN))
400+ let bR = Issue(bN, bO, bQ, bP, true)
401+ let bS = calculateAssetId(bR)
402+ let bT = aD(bA, bD)
403+ let bU = if (containsElement(H, bG))
404+ then invoke(this, "stakeUnstake", [true, bA, bG], nil)
405+ else 0
406+ if ((bU == bU))
407+ then {
408+ let bV = if (containsElement(H, bK))
409+ then invoke(this, "stakeUnstake", [true, bD, bK], nil)
410+ else 0
411+ if ((bV == bV))
412+ then [StringEntry(b, a), BooleanEntry(c, true), StringEntry(d, bG), StringEntry(e, bK), IntegerEntry(f, bA), IntegerEntry(g, bD), IntegerEntry(l, bT), IntegerEntry(j, Y), IntegerEntry(k, aa), bR, StringEntry(h, toBase58String(bS)), IntegerEntry(i, bQ), ScriptTransfer(as.caller, bQ, bS)]
413+ else throw("Strict value is not equal to itself.")
414+ }
415+ else throw("Strict value is not equal to itself.")
416+ }
417+ }
418+
419+
420+
421+@Callable(as)
422+func replenishWithTwoTokens () = valueOrElse(bi(), {
423+ let bB = as.payments[0].assetId
424+ let bE = as.payments[1].assetId
425+ let bW = fraction(ac, as.payments[0].amount, T)
426+ let bX = fraction(ac, as.payments[1].amount, U)
427+ let bY = bc(bB)
428+ let bG = bY._1
429+ let bH = bY._2
430+ let bI = bY._3
431+ let bZ = bc(bE)
432+ let bK = bZ._1
433+ let bL = bZ._2
434+ let bM = bZ._3
435+ let ca = if ((bX > bW))
436+ then {
437+ let cb = fraction(U, bW, ac, CEILING)
438+ $Tuple5(as.payments[0].amount, cb, (as.payments[1].amount - cb), bE, bW)
439+ }
440+ else {
441+ let cb = fraction(T, bX, ac, CEILING)
442+ $Tuple5(cb, as.payments[1].amount, (as.payments[0].amount - cb), bB, bX)
443+ }
444+ let bA = ca._1
445+ let bD = ca._2
446+ let cc = ca._3
447+ let cd = ca._4
448+ let ce = ca._5
449+ let cf = fraction(ce, W, ac)
450+ if ((size(as.payments) != 2))
451+ then throw("Two attached assets expected")
452+ else if (if ((bB != N))
453+ then true
454+ else (bE != O))
455+ then bk()
456+ else if ((cf == 0))
457+ then throw("Too small amount to replenish")
458+ else if ((0 > cc))
459+ then throw("Change < 0")
460+ else if (!(az))
461+ then ([ScriptTransfer(as.caller, bA, bB), ScriptTransfer(as.caller, bD, bE)] ++ bq())
462+ else {
463+ let bU = if (containsElement(H, bG))
464+ then invoke(this, "stakeUnstake", [true, bA, bG], nil)
465+ else 0
466+ if ((bU == bU))
467+ then {
468+ let bV = if (containsElement(H, bK))
469+ then invoke(this, "stakeUnstake", [true, bD, bK], nil)
470+ else 0
471+ if ((bV == bV))
472+ then [IntegerEntry(f, (T + bA)), IntegerEntry(g, (U + bD)), IntegerEntry(i, (W + cf)), IntegerEntry(l, aD((T + bA), (U + bD))), Reissue(V, cf, true), ScriptTransfer(as.caller, cf, V), ScriptTransfer(as.caller, cc, cd)]
473+ else throw("Strict value is not equal to itself.")
474+ }
475+ else throw("Strict value is not equal to itself.")
476+ }
477+ })
478+
479+
480+
481+@Callable(as)
482+func replenishWithOneToken (cg,ch) = valueOrElse(bi(), {
483+ let ci = $Tuple2(as.payments[0].amount, as.payments[0].assetId)
484+ let cj = ci._1
485+ let ck = ci._2
486+ let cl = bc(ck)
487+ let cm = cl._1
488+ let cn = cl._2
489+ let co = cl._3
490+ let cp = 5000000
491+ let cq = 50000000
492+ let cr = if ((cq > cj))
493+ then 100000
494+ else 1
495+ let cs = (ac - ((ac * cr) / 10000000))
496+ let ct = (ac + ((ac * cr) / 10000000))
497+ let cu = (ac - ((ac * 1) / 10000000))
498+ if ((cp > cj))
499+ then throw((((("Payment amount " + toString(cj)) + " does not exceed the minimum amount of ") + toString(cp)) + " tokens"))
500+ else if ((size(as.payments) != 1))
501+ then bl()
502+ else if (!(az))
503+ then ([ScriptTransfer(as.caller, cj, ck)] ++ bq())
504+ else if (if ((ck != N))
505+ then (ck != O)
506+ else false)
507+ then bk()
508+ else {
509+ let cv = if ((ck == N))
510+ then $Tuple6((cj - cg), ch, (T + cg), (U - ch), (T + cj), U)
511+ else $Tuple6(ch, (cj - cg), (T - ch), (U + cg), T, (U + cj))
512+ let cw = cv._1
513+ let cx = cv._2
514+ let cy = cv._3
515+ let cz = cv._4
516+ let cA = cv._5
517+ let cB = cv._6
518+ let cC = aD(cy, cz)
519+ let cD = (fraction((ac * ac), cy, cz) / fraction(ac, cw, cx))
520+ let cE = fraction((cA + cB), ag, (2 * ah))
521+ if (if ((cu >= fraction(ac, X, cC)))
522+ then true
523+ else (X > cC))
524+ then throw("Incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
525+ else if (if ((cs > cD))
526+ then true
527+ else (cD > ct))
528+ then throw("Swap with virtualSwapTokenPay and virtualSwapTokenGet is possible, but ratio after virtual swap is incorrect")
529+ else if (if ((cA > cE))
530+ then true
531+ else (cB > cE))
532+ then bm(cE, cA, cB)
533+ else {
534+ let bW = fraction(cw, ac, cy)
535+ let bX = fraction(cx, ac, cz)
536+ let cf = fraction(min([bW, bX]), W, ac)
537+ let cF = fraction(cf, (aa - (Y / 2)), aa)
538+ let cG = fraction(cf, (Z / 2), aa)
539+ let cH = fraction(cG, T, W)
540+ let cI = fraction(cG, U, W)
541+ let cJ = if ((cm == L))
542+ then $Tuple3((cj - cH), cI, M)
543+ else $Tuple3((cj - cI), cH, L)
544+ let cK = cJ._1
545+ let cL = cJ._2
546+ let cM = cJ._3
547+ let bU = if (containsElement(H, cm))
548+ then invoke(this, "stakeUnstake", [true, cK, cm], nil)
549+ else 0
550+ if ((bU == bU))
551+ then {
552+ let bV = if (containsElement(H, cM))
553+ then invoke(this, "stakeUnstake", [false, cL, cM], nil)
554+ else 0
555+ if ((bV == bV))
556+ then [Reissue(V, cF, true), ScriptTransfer(as.caller, cF, V), ScriptTransfer(E, cH, N), ScriptTransfer(E, cI, O), IntegerEntry(f, (cA - cH)), IntegerEntry(g, (cB - cI)), IntegerEntry(i, (W + cF)), IntegerEntry(l, aD((cA - cH), (cB - cI)))]
557+ else throw("Strict value is not equal to itself.")
558+ }
559+ else throw("Strict value is not equal to itself.")
560+ }
561+ }
562+ })
563+
564+
565+
566+@Callable(as)
567+func withdraw () = valueOrElse(bi(), {
568+ let cN = $Tuple2(as.payments[0].amount, as.payments[0].assetId)
569+ let cj = cN._1
570+ let ck = cN._2
571+ let cO = fraction(cj, T, W)
572+ let cP = fraction(cj, U, W)
573+ let bT = aD((T - cO), (U - cP))
574+ if ((size(as.payments) != 1))
575+ then bl()
576+ else if ((ck != V))
577+ then throw(("Incorrect asset attached. Expected: " + toBase58String(V)))
578+ else if (!(az))
579+ then ([ScriptTransfer(as.caller, cj, ck)] ++ bq())
580+ else {
581+ let bU = if (containsElement(H, L))
582+ then invoke(this, "stakeUnstake", [false, cO, L], nil)
583+ else 0
584+ if ((bU == bU))
585+ then {
586+ let bV = if (containsElement(H, M))
587+ then invoke(this, "stakeUnstake", [false, cP, M], nil)
588+ else 0
589+ if ((bV == bV))
590+ then [IntegerEntry(f, (T - cO)), IntegerEntry(g, (U - cP)), IntegerEntry(i, (W - cj)), IntegerEntry(l, bT), Burn(V, cj), ScriptTransfer(as.caller, cO, N), ScriptTransfer(as.caller, cP, O)]
591+ else throw("Strict value is not equal to itself.")
592+ }
593+ else throw("Strict value is not equal to itself.")
594+ }
595+ })
596+
597+
598+
599+@Callable(as)
600+func exchange (cQ,cR) = valueOrElse(bi(), {
601+ let cS = $Tuple2(as.payments[0].amount, as.payments[0].assetId)
602+ let cj = cS._1
603+ let ck = cS._2
604+ if ((0 >= cQ))
605+ then throw(("Estimated amount must be positive. Actual: " + toString(cQ)))
606+ else if ((cR > cQ))
607+ then throw("Minimal amount can't be greater than estimated.")
608+ else if ((size(as.payments) != 1))
609+ then bl()
610+ else if (!(az))
611+ then ([ScriptTransfer(as.caller, cj, ck)] ++ bq())
612+ else if (if ((ck != N))
613+ then (ck != O)
614+ else false)
615+ then bk()
616+ else if ((10000000 > cj))
617+ then throw("Only swap of 10.000000 or more tokens is allowed")
618+ else if (if ((ai > fraction(ac, cR, cj)))
619+ then true
620+ else (fraction(ac, cQ, cj) > aj))
621+ then throw("Incorrect args and pmt ratio")
622+ else {
623+ let cT = if ((ck == N))
624+ then O
625+ else N
626+ let bu = aF(cQ, cR, cj, ck)
627+ let cU = fraction(bu, Z, aa)
628+ let cV = fraction(bu, (aa - Y), aa)
629+ let cW = if ((ck == N))
630+ then $Tuple2((T + cj), ((U - cV) - cU))
631+ else $Tuple2(((T - cV) - cU), (U + cj))
632+ let cA = cW._1
633+ let cB = cW._2
634+ let cE = fraction((cA + cB), ag, (2 * ah))
635+ if (if ((cE > cA))
636+ then true
637+ else (cE > cB))
638+ then bm(cE, cA, cB)
639+ else {
640+ let cX = bc(ck)
641+ let cm = cX._1
642+ let cn = cX._2
643+ let co = cX._3
644+ let cY = bc(cT)
645+ let cZ = cY._1
646+ let da = cY._2
647+ let db = cY._3
648+ let bU = if (containsElement(H, cm))
649+ then invoke(this, "stakeUnstake", [true, cj, cm], nil)
650+ else 0
651+ if ((bU == bU))
652+ then {
653+ let bV = if (containsElement(H, cZ))
654+ then invoke(this, "stakeUnstake", [false, (cV + cU), cZ], nil)
655+ else 0
656+ if ((bV == bV))
657+ then [IntegerEntry(f, cA), IntegerEntry(g, cB), IntegerEntry(l, aD(cA, cB)), ScriptTransfer(as.caller, cV, cT), ScriptTransfer(E, cU, cT)]
658+ else throw("Strict value is not equal to itself.")
659+ }
660+ else throw("Strict value is not equal to itself.")
661+ }
662+ }
663+ })
664+
665+
666+
667+@Callable(as)
668+func shutdown () = valueOrElse(bj(as), if (!(K))
669+ then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, m), "the cause wasn't specified")))
670+ else bf("Paused by admin"))
671+
672+
673+
674+@Callable(as)
675+func activate () = valueOrElse(bj(as), if (K)
676+ then bh()
677+ else [BooleanEntry(c, true), DeleteEntry(m)])
678+
679+
680+
681+@Callable(as)
682+func takeIntoAccountExtraFunds () = valueOrElse(bi(), {
683+ let dc = (ax - T)
684+ let dd = (ay - U)
685+ let cC = aD((T + dc), (U + dd))
686+ if ((as.caller != E))
687+ then throw("Only the wallet can call this function")
688+ else if (if ((0 > dc))
689+ then true
690+ else (0 > dd))
691+ then bf("Enroll amount negative")
692+ else if (if ((dc == 0))
693+ then (dd == 0)
694+ else false)
695+ then throw("No money to take")
696+ else {
697+ let bU = if (if (containsElement(H, L))
698+ then (dc > 0)
699+ else false)
700+ then invoke(this, "stakeUnstake", [true, dc, L], nil)
701+ else 0
702+ if ((bU == bU))
703+ then {
704+ let bV = if (if (containsElement(H, M))
705+ then (dd > 0)
706+ else false)
707+ then invoke(this, "stakeUnstake", [true, dd, M], nil)
708+ else 0
709+ if ((bV == bV))
710+ then [IntegerEntry(l, cC), IntegerEntry(f, (T + dc)), IntegerEntry(g, (U + dd)), IntegerEntry(("last_income_" + L), dc), IntegerEntry(("last_income_" + M), dd)]
711+ else throw("Strict value is not equal to itself.")
712+ }
713+ else throw("Strict value is not equal to itself.")
714+ }
715+ })
716+
717+
718+
719+@Callable(as)
720+func stakeUnstake (bs,bu,de) = if ((as.caller != this))
721+ then throw("Only contract itself can invoke this function")
722+ else {
723+ let df = bt(bs, bu, fromBase58String(de))
724+ let bw = df._1
725+ let dg = df._2
726+ let dh = df._3
727+ let di = df._4
728+ let dj = invoke(dg, bw, dh, di)
729+ if ((dj == dj))
730+ then nil
731+ else throw("Strict value is not equal to itself.")
732+ }
733+
734+
735+@Verifier(dk)
736+func dl () = {
737+ let dm = {
738+ let dn = if (sigVerify(dk.bodyBytes, dk.proofs[0], z))
739+ then 1
740+ else 0
741+ let do = if (sigVerify(dk.bodyBytes, dk.proofs[1], A))
742+ then 1
743+ else 0
744+ let dp = if (sigVerify(dk.bodyBytes, dk.proofs[2], B))
745+ then 1
746+ else 0
747+ (((dn + do) + dp) >= 2)
748+ }
749+ let w = dk
750+ if ($isInstanceOf(w, "InvokeScriptTransaction"))
751+ then {
752+ let dj = w
753+ let dq = if ((dj.dApp == this))
754+ then (dj.function == "takeIntoAccountExtraFunds")
755+ else false
756+ let dr = if (if (if (sigVerify(dk.bodyBytes, dk.proofs[0], z))
757+ then true
758+ else sigVerify(dk.bodyBytes, dk.proofs[0], A))
759+ then true
760+ else sigVerify(dk.bodyBytes, dk.proofs[0], B))
761+ then true
762+ else sigVerify(dk.bodyBytes, dk.proofs[0], D)
763+ if (if (dq)
764+ then dr
765+ else false)
766+ then true
767+ else dm
768+ }
769+ else dm
770+ }
771+

github/deemru/w8io/169f3d6 
47.14 ms