w8 · tx · FG1···UYV

tx · FG1QMyt8oerTcPDkPD5X9DCatxQhmMxaYm4c7oVniUYV

3NABjMfMRixTpWgTygLFwBYkSFLcca4FNx7:  -0.01000000 Waves

2022.02.14 19:44 [1923551] smart account 3NABjMfMRixTpWgTygLFwBYkSFLcca4FNx7 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FG1QMyt8oerTcPDkPD5X9DCatxQhmMxaYm4c7oVniUYV",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1644857076621,
    "version": 1,
    "sender": "3NABjMfMRixTpWgTygLFwBYkSFLcca4FNx7",
    "senderPublicKey": "4qgJUQ5m81fVdDcaspkyKfnZoe2YvQNjbEgy285w4Hib",
    "proofs": [
        "4USpTP77EmiezrBSjYtynwLrx7hr88YsARBAeYeGUbaWAK9cYJPhseK1jjCdBWJdgiiGV3ggQEC7SYPim6aP2AQb"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1923551,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 
Old New Differences
1 - # no script
1 + {-# STDLIB_VERSION 5 #-}
2 + {-# SCRIPT_TYPE ACCOUNT #-}
3 + {-# CONTENT_TYPE DAPP #-}
4 + let a = 8
5 + 
6 + let b = 100000000
7 + 
8 + let c = 18
9 + 
10 + let d = toBigInt(1000000000000000000)
11 + 
12 + let e = "__"
13 + 
14 + let f = b
15 + 
16 + let g = toBigInt(0)
17 + 
18 + let h = 1
19 + 
20 + let i = 2
21 + 
22 + let j = 3
23 + 
24 + let k = 4
25 + 
26 + let l = 5
27 + 
28 + let m = 6
29 + 
30 + let n = 7
31 + 
32 + let o = 8
33 + 
34 + let p = 9
35 + 
36 + let q = 10
37 + 
38 + func r (s) = valueOrErrorMessage(getString(s), (("mandatory this." + s) + " is not defined"))
39 + 
40 + 
41 + func t (u,s) = valueOrErrorMessage(getString(u, s), (((("mandatory " + toString(u)) + ".") + s) + " is not defined"))
42 + 
43 + 
44 + func v (u,s) = valueOrElse(getInteger(u, s), 0)
45 + 
46 + 
47 + func w (u,s) = valueOrErrorMessage(getInteger(u, s), (("mandatory this." + s) + " is not defined"))
48 + 
49 + 
50 + func x (y) = {
51 +     let z = y
52 +     if ($isInstanceOf(z, "List[Any]"))
53 +         then {
54 +             let A = z
55 +             A
56 +             }
57 +         else throw("fail to cast into List[Any]")
58 +     }
59 + 
60 + 
61 + func B (y) = {
62 +     let z = y
63 +     if ($isInstanceOf(z, "Int"))
64 +         then {
65 +             let C = z
66 +             C
67 +             }
68 +         else throw("fail to cast into Int")
69 +     }
70 + 
71 + 
72 + func D (y) = {
73 +     let z = y
74 +     if ($isInstanceOf(z, "String"))
75 +         then {
76 +             let E = z
77 +             E
78 +             }
79 +         else throw("fail to cast into String")
80 +     }
81 + 
82 + 
83 + func F () = "%s%s__config__factoryAddress"
84 + 
85 + 
86 + let G = 1
87 + 
88 + let H = 2
89 + 
90 + let I = 3
91 + 
92 + let J = 4
93 + 
94 + let K = 5
95 + 
96 + let L = 6
97 + 
98 + let M = 7
99 + 
100 + let N = 8
101 + 
102 + func O () = "%s__factoryConfig"
103 + 
104 + 
105 + func P (Q) = makeString(["%s%s%s", Q, "mappings__lpAsset2PoolContract"], e)
106 + 
107 + 
108 + func R () = "%s__lpTokensList"
109 + 
110 + 
111 + func S (Q) = makeString(["%s%s%s", Q, "mappings__lpAsset2PoolContract"], e)
112 + 
113 + 
114 + func T (U) = makeString(["%s%s", "poolWeight", U], e)
115 + 
116 + 
117 + func V () = addressFromStringValue(r(F()))
118 + 
119 + 
120 + func W () = split(valueOrElse(getString(V(), R()), ""), e)
121 + 
122 + 
123 + func X (Y) = split(t(Y, O()), e)
124 + 
125 + 
126 + func Z (aa) = addressFromStringValue(aa[H])
127 + 
128 + 
129 + func ab (aa) = addressFromStringValue(aa[K])
130 + 
131 + 
132 + func ac (aa) = addressFromStringValue(aa[G])
133 + 
134 + 
135 + func ad (aa) = addressFromStringValue(aa[N])
136 + 
137 + 
138 + func ae () = "%s__config"
139 + 
140 + 
141 + func af () = "%s%s__stats__activeTotalLocked"
142 + 
143 + 
144 + func ag () = "%s%s__stats__locksDurationSumInBlocks"
145 + 
146 + 
147 + func ah () = "%s%s__stats__locksCount"
148 + 
149 + 
150 + func ai () = "%s%s__stats__activeUsersCount"
151 + 
152 + 
153 + func aj (ak) = makeString(["%s%s%s__mapping__user2num", ak], e)
154 + 
155 + 
156 + func al (am) = makeString(["%s%s%s__mapping__num2user", am], e)
157 + 
158 + 
159 + func an (ao) = makeString(["%s%d%s__paramByUserNum", ao, "amount"], e)
160 + 
161 + 
162 + func ap (ao) = makeString(["%s%d%s__paramByUserNum", ao, "start"], e)
163 + 
164 + 
165 + func aq (ao) = makeString(["%s%d%s__paramByUserNum", ao, "duration"], e)
166 + 
167 + 
168 + func ar (ao) = makeString(["%s%d%s__paramByUserNum", ao, "k"], e)
169 + 
170 + 
171 + func as (ao) = makeString(["%s%d%s__paramByUserNum", ao, "b"], e)
172 + 
173 + 
174 + func at (ao,au) = makeString(["%s%d%s%d__paramByPeriod", ao, "k", au], e)
175 + 
176 + 
177 + func av (ao,au) = makeString(["%s%d%s%d__paramByPeriod", ao, "b", au], e)
178 + 
179 + 
180 + func aw (ao) = makeString(["%s%d__userBoostEmissionLastInt", ao], e)
181 + 
182 + 
183 + func ax (ao) = makeString(["%s%d__maxBoostInt", ao], e)
184 + 
185 + 
186 + func ay () = "%s%s__maxBoostInt__total"
187 + 
188 + 
189 + func az (ao) = makeString(["%s%d__userBoostAvaliableToClaimTotal", ao], e)
190 + 
191 + 
192 + func aA (ao) = makeString(["%s%d__userBoostClaimed", ao], e)
193 + 
194 + 
195 + func aB () = "%s%s__gwxCached__total"
196 + 
197 + 
198 + func aC (aD,aE) = makeString(["%s%s%s__staked", aD, aE], e)
199 + 
200 + 
201 + func aF (aE) = ("%s%s%s__staked__total__" + aE)
202 + 
203 + 
204 + func aG (aE,aD) = makeString(["%s%s%s__claimed", aD, aE], e)
205 + 
206 + 
207 + func aH (aE,aD) = makeString(["%s%s%s__claimedMinReward", aD, aE], e)
208 + 
209 + 
210 + func aI (aE,aD) = makeString(["%s%s%s__claimedBoostReward", aD, aE], e)
211 + 
212 + 
213 + func aJ (aK,s) = valueOrElse(getInteger(aK, s), 0)
214 + 
215 + 
216 + func aL () = "%s%s__ratePerBlock__current"
217 + 
218 + 
219 + func aM () = "%s%s__ratePerBlockMax__current"
220 + 
221 + 
222 + func aN () = "%s%s__emission__startBlock"
223 + 
224 + 
225 + func aO () = "%s%s__emission__duration"
226 + 
227 + 
228 + func aP () = "%s%s__emission__endBlock"
229 + 
230 + 
231 + let aQ = V()
232 + 
233 + let aR = X(aQ)
234 + 
235 + let aS = ab(aR)
236 + 
237 + let aK = ac(aR)
238 + 
239 + let aT = ad(aR)
240 + 
241 + let aU = Z(aR)
242 + 
243 + func aV (aW) = {
244 +     let aX = t(aQ, S(aW))
245 +     let aY = b
246 +     let aZ = getIntegerValue(aQ, T(aX))
247 +     let ba = w(aS, aL())
248 +     let bb = w(aS, aM())
249 +     let bc = 3
250 +     let bd = (fraction(ba, aZ, aY) / bc)
251 +     let be = fraction(bb, aZ, aY)
252 +     let bf = (bc * b)
253 +     let bg = v(aK, aF(aW))
254 + [bd, bf, bg]
255 +     }
256 + 
257 + 
258 + func bh (bi,bj,bk) = {
259 +     let bl = fraction(bj, b, bk)
260 +     let bm = fraction(bi, bl, b)
261 + [bm]
262 +     }
263 + 
264 + 
265 + @Callable(bn)
266 + func constructor (bo) = if ((bn.caller != this))
267 +     then throw("not authorized")
268 +     else [StringEntry(F(), bo)]
269 + 
270 + 
271 + 
272 + @Callable(bn)
273 + func currentRewardRateREADONLY (aW) = {
274 +     let bp = aV(aW)
275 +     let ba = bp[0]
276 +     let bf = bp[1]
277 +     let bg = bp[2]
278 +     $Tuple2(nil, makeString(["%d%d%d", toString(ba), toString(bf), toString(bg)], e))
279 +     }
280 + 
281 + 
282 + 
283 + @Callable(bn)
284 + func currentUserRewardRateREADONLY (aW,ak) = {
285 +     let bp = aV(aW)
286 +     let ba = bp[0]
287 +     let bf = bp[1]
288 +     let bg = bp[2]
289 +     let bq = v(aK, aC(ak, aW))
290 +     let br = split(D(invoke(aK, "claimWxREADONLY", [aW, ak], nil)), e)
291 +     let bs = valueOrErrorMessage(parseInt(br[5]), "couldn't parse minRewardPart")
292 +     let bt = valueOrErrorMessage(parseInt(br[6]), "couldn't parse boostRewardPart")
293 +     let bu = br[7]
294 +     let bv = if ((bt == 0))
295 +         then (1 * b)
296 +         else fraction((bs + bt), b, bs)
297 +     $Tuple2(nil, makeString(["%d%d%d%d%d%s", toString(ba), toString(bf), toString(bg), toString(bq), toString(bv), bu], e))
298 +     }
299 + 
300 + 
301 + 
302 + @Callable(bn)
303 + func claimedRewardREADONLY (ak) = {
304 +     let bw = W()
305 +     let bx = "%s%d%d%d%s"
306 +     func by (bz,bA) =     {
307 +         let bB = aH(bA, ak)
308 +         let bC = aI(bA, ak)
309 +         let bD = valueOrElse(getInteger(aK, bB), 0)
310 +         let bE = valueOrElse(getInteger(aK, bC), 0)
311 +         let bF = 0
312 +         makeString([(bx + bz), bA, toString(bD), toString(bE), toString(bF), "end"], e)
313 +         }
314 + 
315 +     let bG = {
316 +         let bH = bw
317 +         let bI = size(bH)
318 +         let bJ = "%s"
319 +         func bK (bL,bM) =         if ((bM >= bI))
320 +             then bL
321 +             else by(bL, bH[bM])
322 + 
323 +         func bN (bL,bM) =         if ((bM >= bI))
324 +             then bL
325 +             else throw("List size exceeds 10")
326 + 
327 +         bN(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bJ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
328 +         }
329 +     $Tuple2(nil, ((bG + e) + ak))
330 +     }
331 + 
332 + 
333 + 
334 + @Callable(bn)
335 + func calcBoostREADONLY (bO,bP,bQ,bR,bS) = {
336 +     let bT = aT
337 +     let bU = "empty"
338 +     let bV = parseIntValue(split(t(aU, ae()), e)[4])
339 +     let aE = if ((bR == ""))
340 +         then bU
341 +         else bR
342 +     let aD = if ((bS == ""))
343 +         then bU
344 +         else bS
345 +     let bW = valueOrElse(getString(aU, aj(bS)), bU)
346 +     let bX = valueOrElse(getInteger(aU, an(bW)), 0)
347 +     let bY = valueOrElse(getInteger(aU, ap(bW)), height)
348 +     let bj = valueOrElse(getInteger(aU, aq(bW)), 0)
349 +     let bZ = (bY + bj)
350 +     let ca = max([(bZ - height), 0])
351 +     let cb = (bX + bO)
352 +     let cc = min([(ca + bP), bV])
353 +     let cd = B(x(invoke(aU, "gwxUserInfoREADONLY", [aD], nil))[0])
354 +     let ce = bh(cb, cc, bV)[0]
355 +     let cf = x(invoke(bT, "calcGwxParamsREADONLY", [ce, height, cc], nil))
356 +     let cg = (ce - cd)
357 +     let ch = B(cf[0])
358 +     let ci = B(cf[1])
359 +     let au = toString(B(cf[2]))
360 +     let cj = ay()
361 +     let ck = aB()
362 +     let cl = ((ce * cc) / 2)
363 +     let cm = v(aU, cj)
364 +     let cn = valueOrElse(getInteger(aU, ck), 0)
365 +     let co = 1000
366 +     let cp = (w(aS, aL()) * co)
367 +     let cq = aC(aD, aE)
368 +     let cr = aF(aE)
369 +     let cs = aJ(aK, cq)
370 +     let ct = aJ(aK, cr)
371 +     let cu = (cs + bQ)
372 +     let cv = (ct + bQ)
373 +     let aZ = if ((aE != bU))
374 +         then {
375 +             let aX = valueOrErrorMessage(getString(aQ, P(aE)), ("unsupported lp asset " + aE))
376 +             getIntegerValue(aQ, T(aX))
377 +             }
378 +         else 0
379 +     let cw = fraction(cp, aZ, (f * 3))
380 +     let cx = if ((cv != 0))
381 +         then fraction(cw, b, cv)
382 +         else 0
383 +     let cy = fraction(cx, cu, b)
384 +     let cz = (cw * 2)
385 +     let cA = fraction(ce, cz, (cn + cg))
386 +     let cB = min([cA, (cy * 2)])
387 +     let cC = if ((cy == 0))
388 +         then (1 * b)
389 +         else fraction((cB + cy), b, cy)
390 +     let bu = makeString([("lpAssetIdStr=" + aE), ("userAddressStr=" + aD), ("userNumStr=" + bW), ("userAmount=" + toString(bX)), ("userAmountNew=" + toString(cb)), ("lockDurationNew=" + toString(cc)), ("gWxAmountStart=" + toString(ce)), ("tmpUserBoostPerBlockX3=" + toString(cA)), ("stakedByUserNew=" + toString(cu)), ("stakedTotalNew=" + toString(cv)), ("poolWeight=" + toString(aZ)), ("wxPerLpX3=" + toString(cx)), ("poolWxEmissionPerBlockX3=" + toString(cw)), ("userWxPerBlockX3=" + toString(cy)), ("gWxAmountDiff=" + toString(cg)), ("totalCachedGwx=" + toString(cn)), ("userCurrgWxAmount=" + toString(cd))], "::")
391 +     $Tuple2(nil, makeString(["%d%d%s", toString(ce), toString(cC), bu], e))
392 +     }
393 + 
394 + 
395 + 
396 + @Callable(bn)
397 + func wxEmissionStatsREADONLY () = {
398 +     let cD = toString(b)
399 +     let cE = "1"
400 +     let ba = w(aS, aL())
401 +     let cF = w(aS, aN())
402 +     let cG = if ((cF > height))
403 +         then 0
404 +         else (height - cF)
405 +     let cH = (1440 * 365)
406 +     let cI = (201000000 * b)
407 +     let cJ = if ((cG > cH))
408 +         then cI
409 +         else fraction(cI, cG, cH)
410 +     let cK = ((ba * cG) + cJ)
411 +     let cL = v(aU, af())
412 +     let cM = v(aU, ag())
413 +     let cN = v(aU, ah())
414 +     $Tuple2(nil, makeString(["%d%d%d%d", toString(cK), toString(cL), toString(cM), toString(cN)], e))
415 +     }
416 + 
417 + 
418 + 
419 + @Callable(bn)
420 + func poolStatsREADONLY (cO) = {
421 +     let cP = addressFromStringValue(t(aQ, S(cO)))
422 +     let cQ = x(invoke(cP, "getPoolConfigWrapperREADONLY", nil, nil))
423 +     let aW = fromBase58String(D(cQ[j]))
424 +     let cR = D(cQ[k])
425 +     let cS = D(cQ[l])
426 +     let cT = D(cQ[o])
427 +     let cU = D(cQ[p])
428 +     let cV = parseIntValue(D(cQ[m]))
429 +     let cW = parseIntValue(D(cQ[n]))
430 +     let cX = valueOrErrorMessage(assetInfo(aW), (("Asset " + toBase58String(aW)) + " doesn't exist")).quantity
431 +     let cY = B(invoke(cP, "getAccBalanceWrapperREADONLY", [cR], nil))
432 +     let cZ = B(invoke(cP, "getAccBalanceWrapperREADONLY", [cS], nil))
433 +     let da = if ((cX == 0))
434 +         then [toString(g), toString(g), toString(g)]
435 +         else x(invoke(cP, "calcPricesWrapperREADONLY", [cY, cZ, cX], nil))
436 +     let db = 0
437 +     let dc = B(invoke(cP, "fromX18WrapperREADONLY", [da[1], b], nil))
438 +     let dd = B(invoke(cP, "fromX18WrapperREADONLY", [da[2], b], nil))
439 +     let aZ = getIntegerValue(aQ, T(toString(cP)))
440 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(cY), toString(cZ), toString(cX), toString(db), toString(dc), toString(dd), toString(aZ)], e))
441 +     }
442 + 
443 + 
444 + 
445 + @Callable(bn)
446 + func poolEvaluatePutByAmountAssetREADONLY (cO,de) = {
447 +     let cP = addressFromStringValue(t(aQ, S(cO)))
448 +     let cQ = x(invoke(cP, "getPoolConfigWrapperREADONLY", nil, nil))
449 +     let aW = fromBase58String(D(cQ[j]))
450 +     let df = D(cQ[k])
451 +     let dg = fromBase58String(df)
452 +     let dh = D(cQ[l])
453 +     let di = fromBase58String(dh)
454 +     let cV = parseIntValue(D(cQ[m]))
455 +     let cW = parseIntValue(D(cQ[n]))
456 +     let dj = D(cQ[i])
457 +     let cX = valueOrErrorMessage(assetInfo(aW), (("Asset " + toBase58String(aW)) + " doesn't exist")).quantity
458 +     let cY = B(invoke(cP, "getAccBalanceWrapperREADONLY", [df], nil))
459 +     let cZ = B(invoke(cP, "getAccBalanceWrapperREADONLY", [dh], nil))
460 +     let dk = parseBigIntValue(D(invoke(cP, "toX18WrapperREADONLY", [cY, cV], nil)))
461 +     let dl = parseBigIntValue(D(invoke(cP, "toX18WrapperREADONLY", [cZ, cW], nil)))
462 +     let dm = if ((cX == 0))
463 +         then g
464 +         else parseBigIntValue(D(invoke(cP, "calcPriceBigIntWrapperREADONLY", [toString(dl), toString(dk)], nil)))
465 +     let db = B(invoke(cP, "fromX18WrapperREADONLY", [toString(dm), b], nil))
466 +     let dn = parseBigIntValue(D(invoke(cP, "toX18WrapperREADONLY", [de, cV], nil)))
467 +     let do = fraction(dn, dm, d)
468 +     let dp = B(invoke(cP, "fromX18WrapperREADONLY", [toString(do), cW], nil))
469 +     let dq = invoke(cP, "estimatePutOperationWrapperREADONLY", ["", 500000, de, dg, dp, di, "", true, false], nil)
470 +     let dr = {
471 +         let z = dq
472 +         if (if ($isInstanceOf(z._1, "Int"))
473 +             then if ($isInstanceOf(z._3, "Int"))
474 +                 then if ($isInstanceOf(z._4, "Int"))
475 +                     then if ($isInstanceOf(z._5, "Int"))
476 +                         then $isInstanceOf(z._6, "Int")
477 +                         else false
478 +                     else false
479 +                 else false
480 +             else false)
481 +             then {
482 +                 let ds = z._1
483 +                 let dt = z._3
484 +                 let du = z._4
485 +                 let dv = z._5
486 +                 let dw = z._6
487 +                 $Tuple5(ds, dt, du, dv, dw)
488 +                 }
489 +             else throw("Couldn't cast types")
490 +         }
491 +     let ds = dr._1
492 +     let dt = dr._2
493 +     let du = dr._3
494 +     let dv = dr._4
495 +     let dw = dr._5
496 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(ds), toString(db), toString(du), toString(dv), toString(dw), dj, toString(de), toString(dp)], e))
497 +     }
498 + 
499 + 
500 + 
501 + @Callable(bn)
502 + func poolEvaluatePutByPriceAssetREADONLY (cO,dp) = {
503 +     let cP = addressFromStringValue(t(aQ, S(cO)))
504 +     let cQ = x(invoke(cP, "getPoolConfigWrapperREADONLY", nil, nil))
505 +     let aW = fromBase58String(D(cQ[j]))
506 +     let df = D(cQ[k])
507 +     let dg = fromBase58String(df)
508 +     let dh = D(cQ[l])
509 +     let di = fromBase58String(dh)
510 +     let cV = parseIntValue(D(cQ[m]))
511 +     let cW = parseIntValue(D(cQ[n]))
512 +     let dj = D(cQ[i])
513 +     let cX = valueOrErrorMessage(assetInfo(aW), (("Asset " + toBase58String(aW)) + " doesn't exist")).quantity
514 +     let dx = B(invoke(cP, "getAccBalanceWrapperREADONLY", [df], nil))
515 +     let dy = B(invoke(cP, "getAccBalanceWrapperREADONLY", [dh], nil))
516 +     let dz = parseBigIntValue(D(invoke(cP, "toX18WrapperREADONLY", [dx, cV], nil)))
517 +     let dA = parseBigIntValue(D(invoke(cP, "toX18WrapperREADONLY", [dy, cW], nil)))
518 +     let dm = if ((cX == 0))
519 +         then g
520 +         else parseBigIntValue(D(invoke(cP, "calcPriceBigIntWrapperREADONLY", [toString(dA), toString(dz)], nil)))
521 +     let db = B(invoke(cP, "fromX18WrapperREADONLY", [toString(dm), b], nil))
522 +     let do = parseBigIntValue(D(invoke(cP, "toX18WrapperREADONLY", [dp, cW], nil)))
523 +     let dn = fraction(do, d, dm)
524 +     let de = B(invoke(cP, "fromX18WrapperREADONLY", [toString(dn), cV], nil))
525 +     let dq = invoke(cP, "estimatePutOperationWrapperREADONLY", ["", 500000, de, dg, dp, di, "", true, false], nil)
526 +     let dB = {
527 +         let z = dq
528 +         if (if ($isInstanceOf(z._1, "Int"))
529 +             then if ($isInstanceOf(z._3, "Int"))
530 +                 then if ($isInstanceOf(z._4, "Int"))
531 +                     then if ($isInstanceOf(z._5, "Int"))
532 +                         then $isInstanceOf(z._6, "Int")
533 +                         else false
534 +                     else false
535 +                 else false
536 +             else false)
537 +             then {
538 +                 let ds = z._1
539 +                 let dt = z._3
540 +                 let du = z._4
541 +                 let dv = z._5
542 +                 let dw = z._6
543 +                 $Tuple5(ds, dt, du, dv, dw)
544 +                 }
545 +             else throw("Couldn't cast types")
546 +         }
547 +     let ds = dB._1
548 +     let dt = dB._2
549 +     let du = dB._3
550 +     let dv = dB._4
551 +     let dw = dB._5
552 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(ds), toString(db), toString(du), toString(dv), toString(dw), dj, toString(de), toString(dp)], e))
553 +     }
554 + 
555 + 
556 + 
557 + @Callable(bn)
558 + func poolEvaluateGetREADONLY (dC,dD) = {
559 +     let cP = addressFromStringValue(t(aQ, S(dC)))
560 +     let dq = invoke(cP, "estimateGetOperationWrapperREADONLY", ["", dC, dD, toString(cP)], nil)
561 +     let dE = {
562 +         let z = dq
563 +         if (if ($isInstanceOf(z._1, "Int"))
564 +             then if ($isInstanceOf(z._2, "Int"))
565 +                 then if ($isInstanceOf(z._5, "Int"))
566 +                     then if ($isInstanceOf(z._6, "Int"))
567 +                         then if ($isInstanceOf(z._7, "Int"))
568 +                             then if ($isInstanceOf(z._8, "String"))
569 +                                 then $isInstanceOf(z._9, "String")
570 +                                 else false
571 +                             else false
572 +                         else false
573 +                     else false
574 +                 else false
575 +             else false)
576 +             then {
577 +                 let dF = z._1
578 +                 let dG = z._2
579 +                 let du = z._5
580 +                 let dv = z._6
581 +                 let dw = z._7
582 +                 let db = z._8
583 +                 let dj = z._9
584 +                 $Tuple7(dF, dG, du, dv, dw, db, dj)
585 +                 }
586 +             else throw("Couldn't cast types")
587 +         }
588 +     let dF = dE._1
589 +     let dG = dE._2
590 +     let du = dE._3
591 +     let dv = dE._4
592 +     let dw = dE._5
593 +     let db = dE._6
594 +     let dj = dE._7
595 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(dF), toString(dG), toString(du), toString(dv), toString(dw), db, dj], e))
596 +     }
597 + 
598 + 
599 + 
600 + @Callable(bn)
601 + func gwxUserInfoREADONLY (ak) = {
602 +     let dH = x(invoke(aU, "gwxUserInfoREADONLY", [ak], nil))
603 +     let dI = B(dH[0])
604 +     $Tuple2(nil, makeString(["%d", toString(dI)], e))
605 +     }
606 + 
607 +

Old	New		Differences
1		-	# no script
	1	+	{-# STDLIB_VERSION 5 #-}
	2	+	{-# SCRIPT_TYPE ACCOUNT #-}
	3	+	{-# CONTENT_TYPE DAPP #-}
	4	+	let a = 8
	5	+
	6	+	let b = 100000000
	7	+
	8	+	let c = 18
	9	+
	10	+	let d = toBigInt(1000000000000000000)
	11	+
	12	+	let e = "__"
	13	+
	14	+	let f = b
	15	+
	16	+	let g = toBigInt(0)
	17	+
	18	+	let h = 1
	19	+
	20	+	let i = 2
	21	+
	22	+	let j = 3
	23	+
	24	+	let k = 4
	25	+
	26	+	let l = 5
	27	+
	28	+	let m = 6
	29	+
	30	+	let n = 7
	31	+
	32	+	let o = 8
	33	+
	34	+	let p = 9
	35	+
	36	+	let q = 10
	37	+
	38	+	func r (s) = valueOrErrorMessage(getString(s), (("mandatory this." + s) + " is not defined"))
	39	+
	40	+
	41	+	func t (u,s) = valueOrErrorMessage(getString(u, s), (((("mandatory " + toString(u)) + ".") + s) + " is not defined"))
	42	+
	43	+
	44	+	func v (u,s) = valueOrElse(getInteger(u, s), 0)
	45	+
	46	+
	47	+	func w (u,s) = valueOrErrorMessage(getInteger(u, s), (("mandatory this." + s) + " is not defined"))
	48	+
	49	+
	50	+	func x (y) = {
	51	+	let z = y
	52	+	if ($isInstanceOf(z, "List[Any]"))
	53	+	then {
	54	+	let A = z
	55	+	A
	56	+	}
	57	+	else throw("fail to cast into List[Any]")
	58	+	}
	59	+
	60	+
	61	+	func B (y) = {
	62	+	let z = y
	63	+	if ($isInstanceOf(z, "Int"))
	64	+	then {
	65	+	let C = z
	66	+	C
	67	+	}
	68	+	else throw("fail to cast into Int")
	69	+	}
	70	+
	71	+
	72	+	func D (y) = {
	73	+	let z = y
	74	+	if ($isInstanceOf(z, "String"))
	75	+	then {
	76	+	let E = z
	77	+	E
	78	+	}
	79	+	else throw("fail to cast into String")
	80	+	}
	81	+
	82	+
	83	+	func F () = "%s%s__config__factoryAddress"
	84	+
	85	+
	86	+	let G = 1
	87	+
	88	+	let H = 2
	89	+
	90	+	let I = 3
	91	+
	92	+	let J = 4
	93	+
	94	+	let K = 5
	95	+
	96	+	let L = 6
	97	+
	98	+	let M = 7
	99	+
	100	+	let N = 8
	101	+
	102	+	func O () = "%s__factoryConfig"
	103	+
	104	+
	105	+	func P (Q) = makeString(["%s%s%s", Q, "mappings__lpAsset2PoolContract"], e)
	106	+
	107	+
	108	+	func R () = "%s__lpTokensList"
	109	+
	110	+
	111	+	func S (Q) = makeString(["%s%s%s", Q, "mappings__lpAsset2PoolContract"], e)
	112	+
	113	+
	114	+	func T (U) = makeString(["%s%s", "poolWeight", U], e)
	115	+
	116	+
	117	+	func V () = addressFromStringValue(r(F()))
	118	+
	119	+
	120	+	func W () = split(valueOrElse(getString(V(), R()), ""), e)
	121	+
	122	+
	123	+	func X (Y) = split(t(Y, O()), e)
	124	+
	125	+
	126	+	func Z (aa) = addressFromStringValue(aa[H])
	127	+
	128	+
	129	+	func ab (aa) = addressFromStringValue(aa[K])
	130	+
	131	+
	132	+	func ac (aa) = addressFromStringValue(aa[G])
	133	+
	134	+
	135	+	func ad (aa) = addressFromStringValue(aa[N])
	136	+
	137	+
	138	+	func ae () = "%s__config"
	139	+
	140	+
	141	+	func af () = "%s%s__stats__activeTotalLocked"
	142	+
	143	+
	144	+	func ag () = "%s%s__stats__locksDurationSumInBlocks"
	145	+
	146	+
	147	+	func ah () = "%s%s__stats__locksCount"
	148	+
	149	+
	150	+	func ai () = "%s%s__stats__activeUsersCount"
	151	+
	152	+
	153	+	func aj (ak) = makeString(["%s%s%s__mapping__user2num", ak], e)
	154	+
	155	+
	156	+	func al (am) = makeString(["%s%s%s__mapping__num2user", am], e)
	157	+
	158	+
	159	+	func an (ao) = makeString(["%s%d%s__paramByUserNum", ao, "amount"], e)
	160	+
	161	+
	162	+	func ap (ao) = makeString(["%s%d%s__paramByUserNum", ao, "start"], e)
	163	+
	164	+
	165	+	func aq (ao) = makeString(["%s%d%s__paramByUserNum", ao, "duration"], e)
	166	+
	167	+
	168	+	func ar (ao) = makeString(["%s%d%s__paramByUserNum", ao, "k"], e)
	169	+
	170	+
	171	+	func as (ao) = makeString(["%s%d%s__paramByUserNum", ao, "b"], e)
	172	+
	173	+
	174	+	func at (ao,au) = makeString(["%s%d%s%d__paramByPeriod", ao, "k", au], e)
	175	+
	176	+
	177	+	func av (ao,au) = makeString(["%s%d%s%d__paramByPeriod", ao, "b", au], e)
	178	+
	179	+
	180	+	func aw (ao) = makeString(["%s%d__userBoostEmissionLastInt", ao], e)
	181	+
	182	+
	183	+	func ax (ao) = makeString(["%s%d__maxBoostInt", ao], e)
	184	+
	185	+
	186	+	func ay () = "%s%s__maxBoostInt__total"
	187	+
	188	+
	189	+	func az (ao) = makeString(["%s%d__userBoostAvaliableToClaimTotal", ao], e)
	190	+
	191	+
	192	+	func aA (ao) = makeString(["%s%d__userBoostClaimed", ao], e)
	193	+
	194	+
	195	+	func aB () = "%s%s__gwxCached__total"
	196	+
	197	+
	198	+	func aC (aD,aE) = makeString(["%s%s%s__staked", aD, aE], e)
	199	+
	200	+
	201	+	func aF (aE) = ("%s%s%s__staked__total__" + aE)
	202	+
	203	+
	204	+	func aG (aE,aD) = makeString(["%s%s%s__claimed", aD, aE], e)
	205	+
	206	+
	207	+	func aH (aE,aD) = makeString(["%s%s%s__claimedMinReward", aD, aE], e)
	208	+
	209	+
	210	+	func aI (aE,aD) = makeString(["%s%s%s__claimedBoostReward", aD, aE], e)
	211	+
	212	+
	213	+	func aJ (aK,s) = valueOrElse(getInteger(aK, s), 0)
	214	+
	215	+
	216	+	func aL () = "%s%s__ratePerBlock__current"
	217	+
	218	+
	219	+	func aM () = "%s%s__ratePerBlockMax__current"
	220	+
	221	+
	222	+	func aN () = "%s%s__emission__startBlock"
	223	+
	224	+
	225	+	func aO () = "%s%s__emission__duration"
	226	+
	227	+
	228	+	func aP () = "%s%s__emission__endBlock"
	229	+
	230	+
	231	+	let aQ = V()
	232	+
	233	+	let aR = X(aQ)
	234	+
	235	+	let aS = ab(aR)
	236	+
	237	+	let aK = ac(aR)
	238	+
	239	+	let aT = ad(aR)
	240	+
	241	+	let aU = Z(aR)
	242	+
	243	+	func aV (aW) = {
	244	+	let aX = t(aQ, S(aW))
	245	+	let aY = b
	246	+	let aZ = getIntegerValue(aQ, T(aX))
	247	+	let ba = w(aS, aL())
	248	+	let bb = w(aS, aM())
	249	+	let bc = 3
	250	+	let bd = (fraction(ba, aZ, aY) / bc)
	251	+	let be = fraction(bb, aZ, aY)
	252	+	let bf = (bc * b)
	253	+	let bg = v(aK, aF(aW))
	254	+	[bd, bf, bg]
	255	+	}
	256	+
	257	+
	258	+	func bh (bi,bj,bk) = {
	259	+	let bl = fraction(bj, b, bk)
	260	+	let bm = fraction(bi, bl, b)
	261	+	[bm]
	262	+	}
	263	+
	264	+
	265	+	@Callable(bn)
	266	+	func constructor (bo) = if ((bn.caller != this))
	267	+	then throw("not authorized")
	268	+	else [StringEntry(F(), bo)]
	269	+
	270	+
	271	+
	272	+	@Callable(bn)
	273	+	func currentRewardRateREADONLY (aW) = {
	274	+	let bp = aV(aW)
	275	+	let ba = bp[0]
	276	+	let bf = bp[1]
	277	+	let bg = bp[2]
	278	+	$Tuple2(nil, makeString(["%d%d%d", toString(ba), toString(bf), toString(bg)], e))
	279	+	}
	280	+
	281	+
	282	+
	283	+	@Callable(bn)
	284	+	func currentUserRewardRateREADONLY (aW,ak) = {
	285	+	let bp = aV(aW)
	286	+	let ba = bp[0]
	287	+	let bf = bp[1]
	288	+	let bg = bp[2]
	289	+	let bq = v(aK, aC(ak, aW))
	290	+	let br = split(D(invoke(aK, "claimWxREADONLY", [aW, ak], nil)), e)
	291	+	let bs = valueOrErrorMessage(parseInt(br[5]), "couldn't parse minRewardPart")
	292	+	let bt = valueOrErrorMessage(parseInt(br[6]), "couldn't parse boostRewardPart")
	293	+	let bu = br[7]
	294	+	let bv = if ((bt == 0))
	295	+	then (1 * b)
	296	+	else fraction((bs + bt), b, bs)
	297	+	$Tuple2(nil, makeString(["%d%d%d%d%d%s", toString(ba), toString(bf), toString(bg), toString(bq), toString(bv), bu], e))
	298	+	}
	299	+
	300	+
	301	+
	302	+	@Callable(bn)
	303	+	func claimedRewardREADONLY (ak) = {
	304	+	let bw = W()
	305	+	let bx = "%s%d%d%d%s"
	306	+	func by (bz,bA) = {
	307	+	let bB = aH(bA, ak)
	308	+	let bC = aI(bA, ak)
	309	+	let bD = valueOrElse(getInteger(aK, bB), 0)
	310	+	let bE = valueOrElse(getInteger(aK, bC), 0)
	311	+	let bF = 0
	312	+	makeString([(bx + bz), bA, toString(bD), toString(bE), toString(bF), "end"], e)
	313	+	}
	314	+
	315	+	let bG = {
	316	+	let bH = bw
	317	+	let bI = size(bH)
	318	+	let bJ = "%s"
	319	+	func bK (bL,bM) = if ((bM >= bI))
	320	+	then bL
	321	+	else by(bL, bH[bM])
	322	+
	323	+	func bN (bL,bM) = if ((bM >= bI))
	324	+	then bL
	325	+	else throw("List size exceeds 10")
	326	+
	327	+	bN(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bJ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
	328	+	}
	329	+	$Tuple2(nil, ((bG + e) + ak))
	330	+	}
	331	+
	332	+
	333	+
	334	+	@Callable(bn)
	335	+	func calcBoostREADONLY (bO,bP,bQ,bR,bS) = {
	336	+	let bT = aT
	337	+	let bU = "empty"
	338	+	let bV = parseIntValue(split(t(aU, ae()), e)[4])
	339	+	let aE = if ((bR == ""))
	340	+	then bU
	341	+	else bR
	342	+	let aD = if ((bS == ""))
	343	+	then bU
	344	+	else bS
	345	+	let bW = valueOrElse(getString(aU, aj(bS)), bU)
	346	+	let bX = valueOrElse(getInteger(aU, an(bW)), 0)
	347	+	let bY = valueOrElse(getInteger(aU, ap(bW)), height)
	348	+	let bj = valueOrElse(getInteger(aU, aq(bW)), 0)
	349	+	let bZ = (bY + bj)
	350	+	let ca = max([(bZ - height), 0])
	351	+	let cb = (bX + bO)
	352	+	let cc = min([(ca + bP), bV])
	353	+	let cd = B(x(invoke(aU, "gwxUserInfoREADONLY", [aD], nil))[0])
	354	+	let ce = bh(cb, cc, bV)[0]
	355	+	let cf = x(invoke(bT, "calcGwxParamsREADONLY", [ce, height, cc], nil))
	356	+	let cg = (ce - cd)
	357	+	let ch = B(cf[0])
	358	+	let ci = B(cf[1])
	359	+	let au = toString(B(cf[2]))
	360	+	let cj = ay()
	361	+	let ck = aB()
	362	+	let cl = ((ce * cc) / 2)
	363	+	let cm = v(aU, cj)
	364	+	let cn = valueOrElse(getInteger(aU, ck), 0)
	365	+	let co = 1000
	366	+	let cp = (w(aS, aL()) * co)
	367	+	let cq = aC(aD, aE)
	368	+	let cr = aF(aE)
	369	+	let cs = aJ(aK, cq)
	370	+	let ct = aJ(aK, cr)
	371	+	let cu = (cs + bQ)
	372	+	let cv = (ct + bQ)
	373	+	let aZ = if ((aE != bU))
	374	+	then {
	375	+	let aX = valueOrErrorMessage(getString(aQ, P(aE)), ("unsupported lp asset " + aE))
	376	+	getIntegerValue(aQ, T(aX))
	377	+	}
	378	+	else 0
	379	+	let cw = fraction(cp, aZ, (f * 3))
	380	+	let cx = if ((cv != 0))
	381	+	then fraction(cw, b, cv)
	382	+	else 0
	383	+	let cy = fraction(cx, cu, b)
	384	+	let cz = (cw * 2)
	385	+	let cA = fraction(ce, cz, (cn + cg))
	386	+	let cB = min([cA, (cy * 2)])
	387	+	let cC = if ((cy == 0))
	388	+	then (1 * b)
	389	+	else fraction((cB + cy), b, cy)
	390	+	let bu = makeString([("lpAssetIdStr=" + aE), ("userAddressStr=" + aD), ("userNumStr=" + bW), ("userAmount=" + toString(bX)), ("userAmountNew=" + toString(cb)), ("lockDurationNew=" + toString(cc)), ("gWxAmountStart=" + toString(ce)), ("tmpUserBoostPerBlockX3=" + toString(cA)), ("stakedByUserNew=" + toString(cu)), ("stakedTotalNew=" + toString(cv)), ("poolWeight=" + toString(aZ)), ("wxPerLpX3=" + toString(cx)), ("poolWxEmissionPerBlockX3=" + toString(cw)), ("userWxPerBlockX3=" + toString(cy)), ("gWxAmountDiff=" + toString(cg)), ("totalCachedGwx=" + toString(cn)), ("userCurrgWxAmount=" + toString(cd))], "::")
	391	+	$Tuple2(nil, makeString(["%d%d%s", toString(ce), toString(cC), bu], e))
	392	+	}
	393	+
	394	+
	395	+
	396	+	@Callable(bn)
	397	+	func wxEmissionStatsREADONLY () = {
	398	+	let cD = toString(b)
	399	+	let cE = "1"
	400	+	let ba = w(aS, aL())
	401	+	let cF = w(aS, aN())
	402	+	let cG = if ((cF > height))
	403	+	then 0
	404	+	else (height - cF)
	405	+	let cH = (1440 * 365)
	406	+	let cI = (201000000 * b)
	407	+	let cJ = if ((cG > cH))
	408	+	then cI
	409	+	else fraction(cI, cG, cH)
	410	+	let cK = ((ba * cG) + cJ)
	411	+	let cL = v(aU, af())
	412	+	let cM = v(aU, ag())
	413	+	let cN = v(aU, ah())
	414	+	$Tuple2(nil, makeString(["%d%d%d%d", toString(cK), toString(cL), toString(cM), toString(cN)], e))
	415	+	}
	416	+
	417	+
	418	+
	419	+	@Callable(bn)
	420	+	func poolStatsREADONLY (cO) = {
	421	+	let cP = addressFromStringValue(t(aQ, S(cO)))
	422	+	let cQ = x(invoke(cP, "getPoolConfigWrapperREADONLY", nil, nil))
	423	+	let aW = fromBase58String(D(cQ[j]))
	424	+	let cR = D(cQ[k])
	425	+	let cS = D(cQ[l])
	426	+	let cT = D(cQ[o])
	427	+	let cU = D(cQ[p])
	428	+	let cV = parseIntValue(D(cQ[m]))
	429	+	let cW = parseIntValue(D(cQ[n]))
	430	+	let cX = valueOrErrorMessage(assetInfo(aW), (("Asset " + toBase58String(aW)) + " doesn't exist")).quantity
	431	+	let cY = B(invoke(cP, "getAccBalanceWrapperREADONLY", [cR], nil))
	432	+	let cZ = B(invoke(cP, "getAccBalanceWrapperREADONLY", [cS], nil))
	433	+	let da = if ((cX == 0))
	434	+	then [toString(g), toString(g), toString(g)]
	435	+	else x(invoke(cP, "calcPricesWrapperREADONLY", [cY, cZ, cX], nil))
	436	+	let db = 0
	437	+	let dc = B(invoke(cP, "fromX18WrapperREADONLY", [da[1], b], nil))
	438	+	let dd = B(invoke(cP, "fromX18WrapperREADONLY", [da[2], b], nil))
	439	+	let aZ = getIntegerValue(aQ, T(toString(cP)))
	440	+	$Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(cY), toString(cZ), toString(cX), toString(db), toString(dc), toString(dd), toString(aZ)], e))
	441	+	}
	442	+
	443	+
	444	+
	445	+	@Callable(bn)
	446	+	func poolEvaluatePutByAmountAssetREADONLY (cO,de) = {
	447	+	let cP = addressFromStringValue(t(aQ, S(cO)))
	448	+	let cQ = x(invoke(cP, "getPoolConfigWrapperREADONLY", nil, nil))
	449	+	let aW = fromBase58String(D(cQ[j]))
	450	+	let df = D(cQ[k])
	451	+	let dg = fromBase58String(df)
	452	+	let dh = D(cQ[l])
	453	+	let di = fromBase58String(dh)
	454	+	let cV = parseIntValue(D(cQ[m]))
	455	+	let cW = parseIntValue(D(cQ[n]))
	456	+	let dj = D(cQ[i])
	457	+	let cX = valueOrErrorMessage(assetInfo(aW), (("Asset " + toBase58String(aW)) + " doesn't exist")).quantity
	458	+	let cY = B(invoke(cP, "getAccBalanceWrapperREADONLY", [df], nil))
	459	+	let cZ = B(invoke(cP, "getAccBalanceWrapperREADONLY", [dh], nil))
	460	+	let dk = parseBigIntValue(D(invoke(cP, "toX18WrapperREADONLY", [cY, cV], nil)))
	461	+	let dl = parseBigIntValue(D(invoke(cP, "toX18WrapperREADONLY", [cZ, cW], nil)))
	462	+	let dm = if ((cX == 0))
	463	+	then g
	464	+	else parseBigIntValue(D(invoke(cP, "calcPriceBigIntWrapperREADONLY", [toString(dl), toString(dk)], nil)))
	465	+	let db = B(invoke(cP, "fromX18WrapperREADONLY", [toString(dm), b], nil))
	466	+	let dn = parseBigIntValue(D(invoke(cP, "toX18WrapperREADONLY", [de, cV], nil)))
	467	+	let do = fraction(dn, dm, d)
	468	+	let dp = B(invoke(cP, "fromX18WrapperREADONLY", [toString(do), cW], nil))
	469	+	let dq = invoke(cP, "estimatePutOperationWrapperREADONLY", ["", 500000, de, dg, dp, di, "", true, false], nil)
	470	+	let dr = {
	471	+	let z = dq
	472	+	if (if ($isInstanceOf(z._1, "Int"))
	473	+	then if ($isInstanceOf(z._3, "Int"))
	474	+	then if ($isInstanceOf(z._4, "Int"))
	475	+	then if ($isInstanceOf(z._5, "Int"))
	476	+	then $isInstanceOf(z._6, "Int")
	477	+	else false
	478	+	else false
	479	+	else false
	480	+	else false)
	481	+	then {
	482	+	let ds = z._1
	483	+	let dt = z._3
	484	+	let du = z._4
	485	+	let dv = z._5
	486	+	let dw = z._6
	487	+	$Tuple5(ds, dt, du, dv, dw)
	488	+	}
	489	+	else throw("Couldn't cast types")
	490	+	}
	491	+	let ds = dr._1
	492	+	let dt = dr._2
	493	+	let du = dr._3
	494	+	let dv = dr._4
	495	+	let dw = dr._5
	496	+	$Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(ds), toString(db), toString(du), toString(dv), toString(dw), dj, toString(de), toString(dp)], e))
	497	+	}
	498	+
	499	+

github/deemru/w8io/026f985 
36.09 ms ◑