tx · FQCe87NV6PPjKfFyBWiGQeHMgtrfce1jK6UmqengBY8j

3NCJATKcGvC9HbmBJTbeyfcPMfPTYgtyRrk:  -0.03100000 Waves

2022.08.31 16:46 [2208719] smart account 3NCJATKcGvC9HbmBJTbeyfcPMfPTYgtyRrk > SELF 0.00000000 Waves

{ "type": 13, "id": "FQCe87NV6PPjKfFyBWiGQeHMgtrfce1jK6UmqengBY8j", "fee": 3100000, "feeAssetId": null, "timestamp": 1661953632150, "version": 2, "chainId": 84, "sender": "3NCJATKcGvC9HbmBJTbeyfcPMfPTYgtyRrk", "senderPublicKey": "Eqjmgsxu1W6LKavhwYC5Z9wLZR2CLWvYHVgfYNcwTQmH", "proofs": [ "34GSTkhjzMuxsMqZdChrUqw7DzfFTMCBarSgR4Zx6p8iaeKDzcJbHtAn8yuBQABewaqqeUWAZ9LZLmBitMPTNxPa" ], "script": "base64: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", "height": 2208719, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: H28GpQJ5S3Ai4vsExCsB1LFp7HjtCWitEUPXiMAinV6w Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = 1000000
5+
6+let b = 1000000
7+
8+let c = 10
9+
10+let d = 6
11+
12+let e = (86400 / 60)
13+
14+let f = "asset_ids"
15+
16+let g = "_balance"
17+
18+let h = "active"
19+
20+let i = "shutdown_cause"
21+
22+let j = "share_asset_id"
23+
24+let k = "share_asset_supply"
25+
26+let l = "commission"
27+
28+let m = "dAppThresholdCoef"
29+
30+let n = "staking_usdnnsbt_address"
31+
32+let o = "discounts"
33+
34+let p = "discount_values"
35+
36+let q = "_SWOP_amount"
37+
38+let r = "first_harvest"
39+
40+let s = "first_harvest_height"
41+
42+let t = "share_limit_on_first_harvest"
43+
44+let u = "base_period"
45+
46+let v = "period_length"
47+
48+let w = "start_height"
49+
50+let x = "admin_pub_1"
51+
52+let y = "admin_pub_2"
53+
54+let z = "admin_pub_3"
55+
56+let B = "admin_invoke_pub"
57+
58+let C = "money_box_address"
59+
60+let E = "governance_address"
61+
62+let F = "voting_address"
63+
64+let G = "farming_address"
65+
66+let H = Address(base58'3NBBWfzZtZtszaXbitTKnrB2xXwv26Bn7H9')
67+
68+func I (J) = {
69+ let K = getString(H, J)
70+ if ($isInstanceOf(K, "String"))
71+ then {
72+ let L = K
73+ fromBase58String(L)
74+ }
75+ else {
76+ let M = K
77+ throw((J + "is empty"))
78+ }
79+ }
80+
81+
82+let N = I(x)
83+
84+let O = I(y)
85+
86+let P = I(z)
87+
88+let Q = I(B)
89+
90+let R = Address(I(C))
91+
92+let S = Address(I(E))
93+
94+let T = Address(I(n))
95+
96+let U = Address(I(F))
97+
98+let V = Address(I(G))
99+
100+let W = Address(base58'3MxXHaGvmKQHH3kNrPBunhve1sDXf7M5RZt')
101+
102+let X = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
103+
104+let Y = [toBase58String(X)]
105+
106+let Z = valueOrErrorMessage(getInteger(U, u), "Empty kBasePeriod")
107+
108+let aa = valueOrErrorMessage(getInteger(U, w), "Empty kStartHeight")
109+
110+let ab = valueOrErrorMessage(getInteger(U, v), "Empty kPeriodLength")
111+
112+let ac = ((Z + ((height - aa) / ab)) + 3)
113+
114+let ad = getBooleanValue(this, h)
115+
116+let ae = fromBase58String(getStringValue(this, j))
117+
118+let af = getIntegerValue(this, k)
119+
120+let ag = 1000000
121+
122+let ah = getIntegerValue(this, l)
123+
124+let ai = fraction(40, ag, 100)
125+
126+let aj = getIntegerValue(this, "initial_A")
127+
128+let ak = getIntegerValue(this, "future_A")
129+
130+let al = valueOrElse(getInteger(this, "initial_A_time"), 0)
131+
132+let am = valueOrElse(getInteger(this, "future_A_time"), 0)
133+
134+let an = split(getStringValue(this, f), ",")
135+
136+let ao = size(an)
137+
138+func ap (aq) = [BooleanEntry(h, false), StringEntry(i, aq)]
139+
140+
141+func ar () = throw("DApp is already active")
142+
143+
144+func as () = if (ad)
145+ then unit
146+ else throw("DApp is inactive at this moment")
147+
148+
149+func at (au) = if (containsElement([N, O, P], au.callerPublicKey))
150+ then unit
151+ else throw("Only admin can call this function")
152+
153+
154+func av (au) = if ((this == au.caller))
155+ then unit
156+ else throw("Only contract itself can call this function")
157+
158+
159+let aw = toBigInt(2)
160+
161+let ax = height
162+
163+func ay (az) = if (az)
164+ then false
165+ else true
166+
167+
168+func aA (aB) = {
169+ let aC = valueOrElse(getInteger(S, (toString(aB) + q)), 0)
170+ let aD = split(getStringValue(H, p), ",")
171+ let aE = split(getStringValue(H, o), ",")
172+ if (if ((aC >= parseIntValue(aD[0])))
173+ then (parseIntValue(aD[1]) > aC)
174+ else false)
175+ then (ag - parseIntValue(aE[0]))
176+ else if (if ((aC >= parseIntValue(aD[1])))
177+ then (parseIntValue(aD[2]) > aC)
178+ else false)
179+ then (ag - parseIntValue(aE[1]))
180+ else if (if ((aC >= parseIntValue(aD[2])))
181+ then (parseIntValue(aD[3]) > aC)
182+ else false)
183+ then (ag - parseIntValue(aE[2]))
184+ else if (if ((aC >= parseIntValue(aD[3])))
185+ then (parseIntValue(aD[4]) > aC)
186+ else false)
187+ then (ag - parseIntValue(aE[3]))
188+ else if ((aC >= parseIntValue(aD[4])))
189+ then (ag - parseIntValue(aE[4]))
190+ else ag
191+ }
192+
193+
194+func aF () = {
195+ let aG = am
196+ let aH = ak
197+ if ((aG > ax))
198+ then {
199+ let aI = aj
200+ let aJ = al
201+ if ((aH > aI))
202+ then (aI + (((aH - aI) * (ax - aJ)) / (aG - aJ)))
203+ else (aI - (((aI - aH) * (ax - aJ)) / (aG - aJ)))
204+ }
205+ else aH
206+ }
207+
208+
209+func aK () = {
210+ func aL (aM,aN) = (aM :+ valueOrElse(getInteger(this, (aN + g)), 0))
211+
212+ let aO = an
213+ let aP = size(aO)
214+ let aQ = nil
215+ func aR (aS,aT) = if ((aT >= aP))
216+ then aS
217+ else aL(aS, aO[aT])
218+
219+ func aU (aS,aT) = if ((aT >= aP))
220+ then aS
221+ else throw("List size exceeds 15")
222+
223+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
224+ }
225+
226+
227+func aV (aW) = aW
228+
229+
230+func aX (aM,aY) = (aM + aY)
231+
232+
233+func aZ (aW,ba) = {
234+ let bb = invoke(this, "D", [aW, ba], nil)
235+ if ($isInstanceOf(bb, "Int"))
236+ then bb
237+ else throw(($getType(invoke(this, "D", [aW, ba], nil)) + " couldn't be cast to Int"))
238+ }
239+
240+
241+func bc (aW,ba) = {
242+ let bd = {
243+ let aO = aW
244+ let aP = size(aO)
245+ let aQ = 0
246+ func aR (aS,aT) = if ((aT >= aP))
247+ then aS
248+ else aX(aS, aO[aT])
249+
250+ func aU (aS,aT) = if ((aT >= aP))
251+ then aS
252+ else throw("List size exceeds 15")
253+
254+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
255+ }
256+ if ((bd == 0))
257+ then 0
258+ else {
259+ let be = (ba * ao)
260+ let bf = (toBigInt(be) * toBigInt(bd))
261+ let bg = toBigInt((be - 1))
262+ func bh (aM,au) = if ((aM._2 == true))
263+ then aM
264+ else {
265+ let bi = aM._1
266+ func bj (bk,au) = if ((ao > au))
267+ then ((bk * bi) / (toBigInt(aW[au]) * toBigInt(ao)))
268+ else bk
269+
270+ let bk = {
271+ let aO = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
272+ let aP = size(aO)
273+ let aQ = bi
274+ func bl (aS,aT) = if ((aT >= aP))
275+ then aS
276+ else bj(aS, aO[aT])
277+
278+ func bm (aS,aT) = if ((aT >= aP))
279+ then aS
280+ else throw("List size exceeds 15")
281+
282+ bm(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
283+ }
284+ let bn = fraction((bf + (toBigInt(ao) * bk)), bi, ((bg * bi) + (toBigInt((ao + 1)) * bk)))
285+ if ((bn > bi))
286+ then if ((1 >= toInt((bn - bi))))
287+ then $Tuple2(bn, true)
288+ else $Tuple2(bn, false)
289+ else if ((1 >= toInt((bi - bn))))
290+ then $Tuple2(bn, true)
291+ else $Tuple2(bn, false)
292+ }
293+
294+ let bo = {
295+ let aO = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
296+ let aP = size(aO)
297+ let aQ = $Tuple2(toBigInt(bd), false)
298+ func bl (aS,aT) = if ((aT >= aP))
299+ then aS
300+ else bh(aS, aO[aT])
301+
302+ func bm (aS,aT) = if ((aT >= aP))
303+ then aS
304+ else throw("List size exceeds 15")
305+
306+ bm(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
307+ }
308+ let bn = bo._1
309+ let bp = bo._2
310+ if ((bp == false))
311+ then throw(("get_D() not finished with " + toString(bn)))
312+ else toInt(bn)
313+ }
314+ }
315+
316+
317+func bq (aW,ba) = aZ(aV(aW), ba)
318+
319+
320+func br (bs,bt,bu,bv) = if (ay((bs != bt)))
321+ then throw("same coin")
322+ else if (ay(if ((bt >= 0))
323+ then (bs >= 0)
324+ else false))
325+ then throw("below zero")
326+ else if (ay(if ((ao > bt))
327+ then (ao > bs)
328+ else false))
329+ then throw("above N_COINS")
330+ else {
331+ let ba = aF()
332+ let bn = aZ(bv, ba)
333+ let be = (ba * ao)
334+ func bw (aM,au) = {
335+ let bx = aM
336+ let by = bx._1
337+ let bz = bx._2
338+ let bA = if ((bs == au))
339+ then bu
340+ else bv[au]
341+ if (if ((au != bt))
342+ then (ao > au)
343+ else false)
344+ then $Tuple2((by + bA), fraction(bz, toBigInt(bn), toBigInt((bA * ao))))
345+ else $Tuple2(by, bz)
346+ }
347+
348+ let bB = {
349+ let aO = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
350+ let aP = size(aO)
351+ let aQ = $Tuple2(0, toBigInt(bn))
352+ func aR (aS,aT) = if ((aT >= aP))
353+ then aS
354+ else bw(aS, aO[aT])
355+
356+ func aU (aS,aT) = if ((aT >= aP))
357+ then aS
358+ else throw("List size exceeds 15")
359+
360+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
361+ }
362+ let by = bB._1
363+ let bC = bB._2
364+ let bz = fraction(bC, toBigInt(bn), toBigInt((be * ao)))
365+ let bD = toBigInt(((by + (bn / be)) - bn))
366+ func bE (aM,bF) = if ((aM._2 == true))
367+ then aM
368+ else {
369+ let bG = aM._1
370+ let bH = (((bG * bG) + bz) / ((aw * bG) + bD))
371+ if ((bH > bG))
372+ then if ((1 >= toInt((bH - bG))))
373+ then $Tuple2(bH, true)
374+ else $Tuple2(bH, false)
375+ else if ((1 >= toInt((bG - bH))))
376+ then $Tuple2(bH, true)
377+ else $Tuple2(bH, false)
378+ }
379+
380+ let bI = {
381+ let aO = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
382+ let aP = size(aO)
383+ let aQ = $Tuple2(toBigInt(bn), false)
384+ func bl (aS,aT) = if ((aT >= aP))
385+ then aS
386+ else bE(aS, aO[aT])
387+
388+ func bm (aS,aT) = if ((aT >= aP))
389+ then aS
390+ else throw("List size exceeds 16")
391+
392+ bm(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
393+ }
394+ let bH = bI._1
395+ let bp = bI._2
396+ if ((bp == false))
397+ then throw(("getY() not finished with " + toString(bH)))
398+ else toInt(bH)
399+ }
400+
401+
402+func bJ (bK,bs,aW,bn) = if (ay((bs >= 0)))
403+ then throw("i below zero")
404+ else if (ay((ao > bs)))
405+ then throw("i above N_COINS")
406+ else {
407+ let be = (bK * ao)
408+ func bw (aM,au) = {
409+ let bL = aM
410+ let by = bL._1
411+ let bz = bL._2
412+ let bA = if (if ((bs != au))
413+ then (ao > au)
414+ else false)
415+ then aW[au]
416+ else 0
417+ if (if ((ao > au))
418+ then (bs != au)
419+ else false)
420+ then $Tuple2((by + bA), fraction(bz, toBigInt(bn), toBigInt((bA * ao))))
421+ else $Tuple2(by, bz)
422+ }
423+
424+ let bM = {
425+ let aO = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
426+ let aP = size(aO)
427+ let aQ = $Tuple2(0, toBigInt(bn))
428+ func aR (aS,aT) = if ((aT >= aP))
429+ then aS
430+ else bw(aS, aO[aT])
431+
432+ func aU (aS,aT) = if ((aT >= aP))
433+ then aS
434+ else throw("List size exceeds 15")
435+
436+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
437+ }
438+ let by = bM._1
439+ let bC = bM._2
440+ let bz = fraction(bC, toBigInt(bn), toBigInt((be * ao)))
441+ let bD = toBigInt(((by + (bn / be)) - bn))
442+ func bN (aM,au) = if ((aM._2 == true))
443+ then aM
444+ else {
445+ let bG = aM._1
446+ let bH = (((bG * bG) + bz) / ((aw * bG) + bD))
447+ if ((bH > bG))
448+ then if ((1 >= toInt((bH - bG))))
449+ then $Tuple2(bH, true)
450+ else $Tuple2(bH, false)
451+ else if ((1 >= toInt((bG - bH))))
452+ then $Tuple2(bH, true)
453+ else $Tuple2(bH, false)
454+ }
455+
456+ let bO = {
457+ let aO = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
458+ let aP = size(aO)
459+ let aQ = $Tuple2(toBigInt(bn), false)
460+ func bl (aS,aT) = if ((aT >= aP))
461+ then aS
462+ else bN(aS, aO[aT])
463+
464+ func bm (aS,aT) = if ((aT >= aP))
465+ then aS
466+ else throw("List size exceeds 16")
467+
468+ bm(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
469+ }
470+ let bH = bO._1
471+ let bp = bO._2
472+ if ((bp == false))
473+ then throw(("get_y_D() not finished with " + toString(bH)))
474+ else toInt(bH)
475+ }
476+
477+
478+func bP (aW,bQ,au,bR) = {
479+ let bS = aA(bR)
480+ let ba = aF()
481+ let bT = ((fraction(ah, bS, ag, CEILING) * ao) / (4 * (ao - 1)))
482+ let bU = af
483+ let bV = aZ(aW, ba)
484+ let bW = (bV - fraction(bQ, bV, bU))
485+ let bX = bJ(ba, au, aW, bW)
486+ let bY = (aW[au] - bX)
487+ func bZ (aM,ca) = {
488+ let cb = aM
489+ let cc = cb._1
490+ let cd = cb._2
491+ let ce = if ((cd == au))
492+ then (fraction(ca, bW, bV) - bX)
493+ else (ca - fraction(ca, bW, bV))
494+ $Tuple2((cc :+ (ca - fraction(bT, ce, ag))), (cd + 1))
495+ }
496+
497+ let cf = {
498+ let aO = aW
499+ let aP = size(aO)
500+ let aQ = $Tuple2(nil, 0)
501+ func aR (aS,aT) = if ((aT >= aP))
502+ then aS
503+ else bZ(aS, aO[aT])
504+
505+ func aU (aS,aT) = if ((aT >= aP))
506+ then aS
507+ else throw("List size exceeds 15")
508+
509+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
510+ }
511+ let cc = cf._1
512+ let cd = cf._2
513+ let cg = cc[au]
514+ let ch = ((cg - bJ(ba, au, cc, bW)) - 1)
515+ $Tuple2(ch, (bY - ch))
516+ }
517+
518+
519+func ci (aN) = {
520+ let K = aN
521+ if ($isInstanceOf(K, "ByteVector"))
522+ then {
523+ let cj = K
524+ toBase58String(cj)
525+ }
526+ else if ($isInstanceOf(K, "Unit"))
527+ then {
528+ let ck = K
529+ "WAVES"
530+ }
531+ else throw("Match error")
532+ }
533+
534+
535+func cl (cm,aN) = if (cm)
536+ then $Tuple2("lockNeutrino", T)
537+ else $Tuple2("unlockNeutrino", T)
538+
539+
540+func cn (cm,co,aN) = if (cm)
541+ then {
542+ let cp = cl(cm, aN)
543+ let cq = cp._1
544+ let cr = cp._2
545+ $Tuple4(cq, cr, nil, [AttachedPayment(aN, co)])
546+ }
547+ else {
548+ let cs = cl(cm, aN)
549+ let cq = cs._1
550+ let cr = cs._2
551+ $Tuple4(cq, cr, [co, toBase58String(aN)], nil)
552+ }
553+
554+
555+func cm (co,ct) = if (containsElement(Y, ct))
556+ then {
557+ let cu = cn(true, co, fromBase58String(ct))
558+ let cq = cu._1
559+ let cv = cu._2
560+ let cw = cu._3
561+ let cx = cu._4
562+ invoke(cv, cq, cw, cx)
563+ }
564+ else 0
565+
566+
567+func cy (co,ct) = if (containsElement(Y, ct))
568+ then {
569+ let cz = cn(false, co, fromBase58String(ct))
570+ let cq = cz._1
571+ let cv = cz._2
572+ let cw = cz._3
573+ let cx = cz._4
574+ invoke(cv, cq, cw, cx)
575+ }
576+ else 0
577+
578+
579+func cA (aN) = {
580+ let cB = {
581+ let K = aN
582+ if ($isInstanceOf(K, "ByteVector"))
583+ then {
584+ let cC = K
585+ if ((cC == X))
586+ then getInteger(T, ((("rpd_balance_" + toBase58String(cC)) + "_") + toString(this)))
587+ else 0
588+ }
589+ else if ($isInstanceOf(K, "Unit"))
590+ then 0
591+ else throw("Match error")
592+ }
593+ let K = cB
594+ if ($isInstanceOf(K, "Int"))
595+ then {
596+ let au = K
597+ au
598+ }
599+ else 0
600+ }
601+
602+
603+func cD () = {
604+ let cE = aK()
605+ func cF (aM,aN) = {
606+ let cG = aM
607+ let cH = cG._1
608+ let au = cG._2
609+ if (cH)
610+ then $Tuple2(cH, au)
611+ else {
612+ let cI = (assetBalance(this, fromBase58String(aN)) + cA(fromBase58String(aN)))
613+ if ((cE[au] > cI))
614+ then $Tuple2(true, au)
615+ else $Tuple2(false, (au + 1))
616+ }
617+ }
618+
619+ let aO = an
620+ let aP = size(aO)
621+ let aQ = $Tuple2(false, 0)
622+ func aR (aS,aT) = if ((aT >= aP))
623+ then aS
624+ else cF(aS, aO[aT])
625+
626+ func aU (aS,aT) = if ((aT >= aP))
627+ then aS
628+ else throw("List size exceeds 15")
629+
630+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
631+ }
632+
633+
634+func cJ (au) = ap(("Suspicious state with asset: " + an[au]))
635+
636+
637+func cK (bR,cx) = {
638+ func cL (aM,cM) = (aM :+ ScriptTransfer(bR, cM.amount, cM.assetId))
639+
640+ let aO = cx
641+ let aP = size(aO)
642+ let aQ = nil
643+ func aR (aS,aT) = if ((aT >= aP))
644+ then aS
645+ else cL(aS, aO[aT])
646+
647+ func aU (aS,aT) = if ((aT >= aP))
648+ then aS
649+ else throw("List size exceeds 15")
650+
651+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
652+ }
653+
654+
655+func cN (cO) = {
656+ let cP = valueOrErrorMessage(getInteger(this, m), "No dAppThresholdCoef key")
657+ let cQ = 10000
658+ let cR = max(cO)
659+ let cS = min(cO)
660+ let cT = fraction(cR, cQ, cS)
661+ if ((cT > (cP * cQ)))
662+ then throw("New balance in assets of the DApp is less than threshold")
663+ else false
664+ }
665+
666+
667+func cU (an) = {
668+ let cV = split(an, ",")
669+ func cW (cX,aN) = {
670+ let cY = valueOrErrorMessage(fromBase58String(aN), ("fromBase58String: " + aN))
671+ let cZ = valueOrErrorMessage(assetInfo(cY), ("assetInfo: " + aN)).decimals
672+ if ((cZ != d))
673+ then throw("wrong decimals")
674+ else false
675+ }
676+
677+ let aO = cV
678+ let aP = size(aO)
679+ let aQ = false
680+ func aR (aS,aT) = if ((aT >= aP))
681+ then aS
682+ else cW(aS, aO[aT])
683+
684+ func aU (aS,aT) = if ((aT >= aP))
685+ then aS
686+ else throw("List size exceeds 15")
687+
688+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
689+ }
690+
691+
692+@Callable(da)
693+func D (aW,ba) = {
694+ let bn = bc(aW, ba)
695+ $Tuple2([IntegerEntry("D", bn)], bn)
696+ }
697+
698+
699+
700+@Callable(da)
701+func init (an,aF,db) = if (!(isDataStorageUntouched(this)))
702+ then throw("Already initialized")
703+ else {
704+ let dc = "s_Multi_USD"
705+ let dd = ("ShareToken of SwopFi protocol for MultiStable USD pool at address " + toString(this))
706+ let de = Issue(dc, dd, 0, 6, true)
707+ let df = calculateAssetId(de)
708+ if (cU(an))
709+ then throw()
710+ else {
711+ let dg = [StringEntry(f, an), IntegerEntry("initial_A", aF), IntegerEntry("future_A", aF), IntegerEntry(l, getIntegerValue(H, "base_fee_flat")), StringEntry(j, toBase58String(df)), IntegerEntry(k, 0), IntegerEntry(m, 15), BooleanEntry(h, true), de]
712+ if (db)
713+ then (dg ++ [BooleanEntry(r, db), IntegerEntry(s, (aa + (ac * ab)))])
714+ else dg
715+ }
716+ }
717+
718+
719+
720+@Callable(da)
721+func addLiquidity (dh,di) = valueOrElse(as(), {
722+ let ba = aF()
723+ let aW = aK()
724+ let bV = if ((af == 0))
725+ then 0
726+ else bq(aW, ba)
727+ let cx = da.payments
728+ let dj = size(cx)
729+ func dk (dj) = if ((dj > ao))
730+ then throw(("payments size > " + toString(ao)))
731+ else if ((1 > dj))
732+ then throw("payments size < 1")
733+ else if (if ((af == 0))
734+ then (ao != dj)
735+ else false)
736+ then throw("initial deposit requires all coins")
737+ else {
738+ func dl (aM,cM) = if (containsElement(an, ci(cM.assetId)))
739+ then true
740+ else throw("Invalid asset in payment")
741+
742+ let aO = cx
743+ let aP = size(aO)
744+ let aQ = false
745+ func aR (aS,aT) = if ((aT >= aP))
746+ then aS
747+ else dl(aS, aO[aT])
748+
749+ func aU (aS,aT) = if ((aT >= aP))
750+ then aS
751+ else throw("List size exceeds 15")
752+
753+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
754+ }
755+
756+ if (!(dk(dj)))
757+ then throw()
758+ else {
759+ let cH = cD()
760+ if (cH._1)
761+ then (cJ(cH._2) ++ cK(da.caller, cx))
762+ else {
763+ let dm = size(cx)
764+ func cL (aM,aN) = {
765+ let dn = aM
766+ let cO = dn._1
767+ let au = dn._2
768+ let do = dn._3
769+ if (if ((dm > do))
770+ then (ci(cx[do].assetId) == aN)
771+ else false)
772+ then {
773+ let dp = cm(cx[do].amount, ci(cx[do].assetId))
774+ if ((dp == dp))
775+ then $Tuple3((cO :+ (aW[au] + cx[do].amount)), (au + 1), (do + 1))
776+ else throw("Strict value is not equal to itself.")
777+ }
778+ else $Tuple3((cO :+ aW[au]), (au + 1), do)
779+ }
780+
781+ let dq = {
782+ let aO = an
783+ let aP = size(aO)
784+ let aQ = $Tuple3(nil, 0, 0)
785+ func aR (aS,aT) = if ((aT >= aP))
786+ then aS
787+ else cL(aS, aO[aT])
788+
789+ func aU (aS,aT) = if ((aT >= aP))
790+ then aS
791+ else throw("List size exceeds 15")
792+
793+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
794+ }
795+ let cO = dq._1
796+ let dr = dq._2
797+ let ds = dq._3
798+ if (((dm - 1) > ds))
799+ then throw("Incorect payments order")
800+ else if (cN(cO))
801+ then throw()
802+ else {
803+ let bW = bq(cO, ba)
804+ if (ay((bW > bV)))
805+ then throw("D1 > D0")
806+ else {
807+ let bS = aA(da.caller)
808+ func dt (aM,du) = {
809+ let dv = aM
810+ let dw = dv._1
811+ let dx = dv._2
812+ let au = dv._3
813+ if ((af > 0))
814+ then {
815+ let bT = ((fraction(ah, bS, ag, CEILING) * ao) / (4 * (ao - 1)))
816+ let dy = {
817+ let dz = fraction(bW, aW[au], bV)
818+ let dA = if ((dz > du))
819+ then (dz - du)
820+ else (du - dz)
821+ fraction(bT, dA, ag)
822+ }
823+ let dB = fraction(dy, ai, ag)
824+ let dC = (du - dB)
825+ let dD = (du - dy)
826+ let dE = cy(dy, an[au])
827+ if ((dE == dE))
828+ then $Tuple3((dw :+ dD), (dx ++ [ScriptTransfer(W, (dy - dB), fromBase58String(an[au])), ScriptTransfer(R, dB, fromBase58String(an[au])), IntegerEntry((an[au] + g), dC)]), (au + 1))
829+ else throw("Strict value is not equal to itself.")
830+ }
831+ else $Tuple3((dw :+ du), (dx :+ IntegerEntry((an[au] + g), du)), (au + 1))
832+ }
833+
834+ let dF = {
835+ let aO = cO
836+ let aP = size(aO)
837+ let aQ = $Tuple3(nil, nil, 0)
838+ func bl (aS,aT) = if ((aT >= aP))
839+ then aS
840+ else dt(aS, aO[aT])
841+
842+ func bm (aS,aT) = if ((aT >= aP))
843+ then aS
844+ else throw("List size exceeds 15")
845+
846+ bm(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(bl(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
847+ }
848+ let dw = dF._1
849+ let dx = dF._2
850+ let dG = bq(dw, ba)
851+ let dH = if ((af == 0))
852+ then bW
853+ else fraction(af, (dG - bV), bV)
854+ if (ay((dH >= dh)))
855+ then throw("Slippage screwed you")
856+ else if (di)
857+ then {
858+ let dI = invoke(this, "reissueShare", [dH], nil)
859+ if ((dI == dI))
860+ then {
861+ let dp = invoke(V, "lockShareTokens", [toString(this)], [AttachedPayment(ae, dH)])
862+ if ((dp == dp))
863+ then (dx :+ IntegerEntry(k, (af + dH)))
864+ else throw("Strict value is not equal to itself.")
865+ }
866+ else throw("Strict value is not equal to itself.")
867+ }
868+ else (dx ++ [Reissue(ae, dH, true), ScriptTransfer(da.caller, dH, ae), IntegerEntry(k, (af + dH))])
869+ }
870+ }
871+ }
872+ }
873+ })
874+
875+
876+
877+@Callable(da)
878+func reissueShare (co) = valueOrElse(av(da), [Reissue(ae, co, true)])
879+
880+
881+
882+@Callable(da)
883+func getDy (dJ,dK,dL,dM) = {
884+ let aW = aK()
885+ let dN = valueOrErrorMessage(indexOf(an, dJ), "unknown token in")
886+ let dO = valueOrErrorMessage(indexOf(an, dK), "unknown token out")
887+ let bu = (aW[dN] + dL)
888+ let bH = br(dN, dO, bu, aW)
889+ let ch = ((aW[dO] - bH) - 1)
890+ let bS = aA(Address(fromBase58String(dM)))
891+ let bT = fraction(fraction(ah, bS, ag, CEILING), ch, ag)
892+ $Tuple2(nil, $Tuple2((ch - bT), bT))
893+ }
894+
895+
896+
897+@Callable(da)
898+func exchange (dP,dQ) = valueOrElse(as(), if ((size(da.payments) != 1))
899+ then throw("size(payments) != 1")
900+ else {
901+ let cH = cD()
902+ if (cH._1)
903+ then (cJ(cH._2) ++ cK(da.caller, da.payments))
904+ else {
905+ let cM = da.payments[0]
906+ let dR = ci(cM.assetId)
907+ let dS = fromBase58String(dP)
908+ let dL = cM.amount
909+ let dN = valueOrErrorMessage(indexOf(an, dR), "unknown token in")
910+ let dO = valueOrErrorMessage(indexOf(an, dP), "unknown token out")
911+ let aW = aK()
912+ let bu = (aW[dN] + dL)
913+ let bH = br(dN, dO, bu, aW)
914+ let dT = ((aW[dO] - bH) - 1)
915+ let bS = aA(da.caller)
916+ let bT = fraction(dT, fraction(ah, bS, ag, CEILING), ag)
917+ let ch = (dT - bT)
918+ let dB = fraction(bT, ai, ag)
919+ if (ay((ch >= dQ)))
920+ then throw("Exchange resulted in fewer coins than expected")
921+ else {
922+ func dU (aM,dV) = {
923+ let dW = aM
924+ let cO = dW._1
925+ let au = dW._2
926+ if ((au == dN))
927+ then $Tuple2((cO :+ (dV + dL)), (au + 1))
928+ else if ((au == dO))
929+ then $Tuple2((cO :+ (dV - dT)), (au + 1))
930+ else $Tuple2((cO :+ dV), (au + 1))
931+ }
932+
933+ let dX = {
934+ let aO = aW
935+ let aP = size(aO)
936+ let aQ = $Tuple2(nil, 0)
937+ func aR (aS,aT) = if ((aT >= aP))
938+ then aS
939+ else dU(aS, aO[aT])
940+
941+ func aU (aS,aT) = if ((aT >= aP))
942+ then aS
943+ else throw("List size exceeds 15")
944+
945+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
946+ }
947+ let cO = dX._1
948+ let au = dX._2
949+ if (cN(cO))
950+ then throw()
951+ else {
952+ let dp = cm(cM.amount, ci(cM.assetId))
953+ if ((dp == dp))
954+ then {
955+ let dE = cy(dT, dP)
956+ if ((dE == dE))
957+ then $Tuple2([IntegerEntry((dR + g), bu), IntegerEntry((dP + g), (aW[dO] - dT)), ScriptTransfer(da.caller, ch, dS), ScriptTransfer(R, dB, dS), ScriptTransfer(W, (bT - dB), dS)], $Tuple2(ch, dS))
958+ else throw("Strict value is not equal to itself.")
959+ }
960+ else throw("Strict value is not equal to itself.")
961+ }
962+ }
963+ }
964+ })
965+
966+
967+
968+@Callable(da)
969+func withdraw (dY,dZ) = valueOrElse(as(), if ((size(da.payments) != 1))
970+ then throw("size(payments) != 1")
971+ else {
972+ let cH = cD()
973+ if (cH._1)
974+ then (cJ(cH._2) ++ cK(da.caller, da.payments))
975+ else {
976+ let cM = da.payments[0]
977+ let dR = cM.assetId
978+ if ((dR != ae))
979+ then throw("unknown token")
980+ else {
981+ let ea = cM.amount
982+ let bU = af
983+ let eb = if ((dZ > 0))
984+ then invoke(V, "withdrawShareTokens", [toString(this), dZ], nil)
985+ else 0
986+ if ((eb == eb))
987+ then {
988+ let ec = (ea + dZ)
989+ func dt (aM,ed) = {
990+ let ee = aM
991+ let dx = ee._1
992+ let au = ee._2
993+ let ef = fraction(ed, ec, bU)
994+ if (ay((ef >= dY[au])))
995+ then throw("Withdrawal resulted in fewer coins than expected")
996+ else {
997+ let dE = cy(ef, an[au])
998+ if ((dE == dE))
999+ then $Tuple2((dx ++ [IntegerEntry((an[au] + g), (ed - ef)), ScriptTransfer(da.caller, ef, fromBase58String(an[au]))]), (au + 1))
1000+ else throw("Strict value is not equal to itself.")
1001+ }
1002+ }
1003+
1004+ let eg = {
1005+ let aO = aK()
1006+ let aP = size(aO)
1007+ let aQ = $Tuple2(nil, 0)
1008+ func aR (aS,aT) = if ((aT >= aP))
1009+ then aS
1010+ else dt(aS, aO[aT])
1011+
1012+ func aU (aS,aT) = if ((aT >= aP))
1013+ then aS
1014+ else throw("List size exceeds 15")
1015+
1016+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
1017+ }
1018+ let dx = eg._1
1019+ let au = eg._2
1020+ (dx ++ [Burn(ae, ec), IntegerEntry(k, (af - ec))])
1021+ }
1022+ else throw("Strict value is not equal to itself.")
1023+ }
1024+ }
1025+ })
1026+
1027+
1028+
1029+@Callable(da)
1030+func calcWithdrawOneCoin (eh,dP,ei) = {
1031+ let au = valueOrErrorMessage(indexOf(an, dP), "unknown token out")
1032+ $Tuple2(nil, bP(aK(), eh, au, Address(fromBase58String(ei)))._1)
1033+ }
1034+
1035+
1036+
1037+@Callable(da)
1038+func withdrawOneCoin (dP,ej,dZ) = valueOrElse(as(), if ((size(da.payments) != 1))
1039+ then throw("size(payments) != 1")
1040+ else {
1041+ let cH = cD()
1042+ if (cH._1)
1043+ then (cJ(cH._2) ++ cK(da.caller, da.payments))
1044+ else {
1045+ let cM = da.payments[0]
1046+ let dR = cM.assetId
1047+ if ((dR != ae))
1048+ then throw("unknown token")
1049+ else {
1050+ let ek = valueOrErrorMessage(indexOf(an, dP), "unknown token out")
1051+ let el = cM.amount
1052+ let eb = if ((dZ > 0))
1053+ then invoke(V, "withdrawShareTokens", [toString(this), dZ], nil)
1054+ else 0
1055+ if ((eb == eb))
1056+ then {
1057+ let ec = (el + dZ)
1058+ let aW = aK()
1059+ let em = bP(aW, ec, ek, da.caller)
1060+ let ch = em._1
1061+ let en = em._2
1062+ if (ay((ch >= ej)))
1063+ then throw("Not enough coins removed")
1064+ else {
1065+ let dB = fraction(en, ai, ag)
1066+ let eo = (ch + en)
1067+ func dU (aM,dV) = {
1068+ let ep = aM
1069+ let cO = ep._1
1070+ let au = ep._2
1071+ if ((au == ek))
1072+ then $Tuple2((cO :+ (dV - eo)), (au + 1))
1073+ else $Tuple2((cO :+ dV), (au + 1))
1074+ }
1075+
1076+ let eq = {
1077+ let aO = aW
1078+ let aP = size(aO)
1079+ let aQ = $Tuple2(nil, 0)
1080+ func aR (aS,aT) = if ((aT >= aP))
1081+ then aS
1082+ else dU(aS, aO[aT])
1083+
1084+ func aU (aS,aT) = if ((aT >= aP))
1085+ then aS
1086+ else throw("List size exceeds 15")
1087+
1088+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
1089+ }
1090+ let cO = eq._1
1091+ let au = eq._2
1092+ if (cN(cO))
1093+ then throw()
1094+ else {
1095+ let dE = cy(eo, dP)
1096+ if ((dE == dE))
1097+ then [ScriptTransfer(da.caller, ch, fromBase58String(dP)), IntegerEntry((an[au] + g), (aW[au] - eo)), Burn(ae, ec), ScriptTransfer(R, dB, fromBase58String(dP)), ScriptTransfer(W, (en - dB), fromBase58String(dP)), IntegerEntry(k, (af - ec))]
1098+ else throw("Strict value is not equal to itself.")
1099+ }
1100+ }
1101+ }
1102+ else throw("Strict value is not equal to itself.")
1103+ }
1104+ }
1105+ })
1106+
1107+
1108+
1109+@Callable(da)
1110+func A () = $Tuple2(nil, aF())
1111+
1112+
1113+
1114+@Callable(da)
1115+func getVirtualPrice () = {
1116+ let bn = aZ(aK(), aF())
1117+ $Tuple2(nil, fraction(bn, a, af))
1118+ }
1119+
1120+
1121+
1122+@Callable(da)
1123+func calcTokenAmount (er,es) = {
1124+ let ba = aF()
1125+ let et = aK()
1126+ let bV = bq(et, ba)
1127+ func eu (aM,ed) = {
1128+ let ev = aM
1129+ let cO = ev._1
1130+ let au = ev._2
1131+ let du = (ed + (if (es)
1132+ then er[au]
1133+ else -(er[au])))
1134+ $Tuple2((cO :+ du), (au + 1))
1135+ }
1136+
1137+ let cO = ( let aO = et
1138+ let aP = size(aO)
1139+ let aQ = $Tuple2(nil, 0)
1140+ func aR (aS,aT) = if ((aT >= aP))
1141+ then aS
1142+ else eu(aS, aO[aT])
1143+
1144+ func aU (aS,aT) = if ((aT >= aP))
1145+ then aS
1146+ else throw("List size exceeds 15")
1147+
1148+ aU(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aR(aQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15))._1
1149+ let bW = bq(cO, ba)
1150+ let ew = if (es)
1151+ then (bW - bV)
1152+ else (bV - bW)
1153+ $Tuple2(nil, fraction(ew, af, bV))
1154+ }
1155+
1156+
1157+
1158+@Callable(da)
1159+func rampA (ex,ey) = valueOrElse(as(), valueOrElse(at(da), if (ay((ax >= (al + e))))
1160+ then throw("too often")
1161+ else if (ay((ey >= (ax + e))))
1162+ then throw("insufficient time")
1163+ else {
1164+ let ez = aF()
1165+ if (ay(if ((ex > 0))
1166+ then (b > ex)
1167+ else false))
1168+ then throw("out of base range")
1169+ else if (ay(if (if ((ex >= ez))
1170+ then ((ez * c) >= ex)
1171+ else false)
1172+ then true
1173+ else if ((ez > ex))
1174+ then ((ex * c) >= ez)
1175+ else false))
1176+ then throw("out of range")
1177+ else [IntegerEntry("initial_A", ez), IntegerEntry("future_A", ex), IntegerEntry("initial_A_time", ax), IntegerEntry("future_A_time", ey)]
1178+ }))
1179+
1180+
1181+
1182+@Callable(da)
1183+func stopRampA () = valueOrElse(as(), valueOrElse(at(da), {
1184+ let eA = aF()
1185+[IntegerEntry("initial_A", eA), IntegerEntry("future_A", eA), IntegerEntry("initial_A_time", ax), IntegerEntry("future_A_time", ax)]
1186+ }))
1187+
1188+
1189+
1190+@Callable(da)
1191+func shutdown () = valueOrElse(at(da), if (!(ad))
1192+ then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, i), "the cause wasn't specified")))
1193+ else ap("Paused by admin"))
1194+
1195+
1196+
1197+@Callable(da)
1198+func activate () = valueOrElse(at(da), if (ad)
1199+ then ar()
1200+ else [BooleanEntry(h, true), DeleteEntry(i)])
1201+
1202+
1203+
1204+@Callable(da)
1205+func keepLimitForFirstHarvest (eB) = valueOrElse(as(), valueOrElse(at(da), [IntegerEntry(t, eB)]))
1206+
1207+
1208+@Verifier(eC)
1209+func eD () = {
1210+ let eE = {
1211+ let eF = if (sigVerify(eC.bodyBytes, eC.proofs[0], N))
1212+ then 1
1213+ else 0
1214+ let eG = if (sigVerify(eC.bodyBytes, eC.proofs[1], O))
1215+ then 1
1216+ else 0
1217+ let eH = if (sigVerify(eC.bodyBytes, eC.proofs[2], P))
1218+ then 1
1219+ else 0
1220+ (((eF + eG) + eH) >= 2)
1221+ }
1222+ let K = eC
1223+ if ($isInstanceOf(K, "InvokeScriptTransaction"))
1224+ then {
1225+ let eI = K
1226+ let eJ = if ((eI.dApp == this))
1227+ then (eI.function == "takeIntoAccountExtraFunds")
1228+ else false
1229+ let eK = if (if (if (sigVerify(eC.bodyBytes, eC.proofs[0], N))
1230+ then true
1231+ else sigVerify(eC.bodyBytes, eC.proofs[0], O))
1232+ then true
1233+ else sigVerify(eC.bodyBytes, eC.proofs[0], P))
1234+ then true
1235+ else sigVerify(eC.bodyBytes, eC.proofs[0], Q)
1236+ if (if (eJ)
1237+ then eK
1238+ else false)
1239+ then true
1240+ else eE
1241+ }
1242+ else eE
1243+ }
1244+

github/deemru/w8io/169f3d6 
70.91 ms