tx · DjvJTxECEqNT2eT1T1BYXAFRmrwEgFHFQoaR7up1QfP6

3N7HtrKeFFLz5oy6PfGv1Lg3GwPk4gCPdGy:  -0.03500000 Waves

2024.12.04 04:40 [3399250] smart account 3N7HtrKeFFLz5oy6PfGv1Lg3GwPk4gCPdGy > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DjvJTxECEqNT2eT1T1BYXAFRmrwEgFHFQoaR7up1QfP6",
    "fee": 3500000,
    "feeAssetId": null,
    "timestamp": 1733276457633,
    "version": 2,
    "chainId": 84,
    "sender": "3N7HtrKeFFLz5oy6PfGv1Lg3GwPk4gCPdGy",
    "senderPublicKey": "FsR18761ZAsUqsTd7TK3XmR6bhihs1UXVmpHYxz5JzQ1",
    "proofs": [
        "UJLWu5TPQ8cYy6X6T4gCQKE4uQsRMS6apDVJySFbwT2NbEv5oPoHiHUBM5ws3etF1jWZ5KyAsZMP93QomruUsDi"
    ],
    "script": "base64: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",
    "height": 3399250,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: HAGsL4fpNExrNrUFy56Uzdu7CoXiuTm41bsu4FxS18dw
Next: EkigtXR54sN3P2SpugWLUV7EeoMQYcb1MXtfaJsCMWUr

Diff: 

OldNewDifferences
290290 
291291 let bm = "stakersAmountLeft"
292292 
293-func bn (P) = ("lastClaimedTimeUser_" + P)
293+func bn (P) = ("lastClaimedTimeUserOld_" + P)
294294 
295295 
296296 func bo (P) = ("lastArbTimeUser_" + P)

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let a = "__"
55 
66 let b = 1000000
77 
88 let c = 100000000
99 
1010 let d = 100000
1111 
1212 let e = 86400000
1313 
1414 let f = take(drop(this.bytes, 1), 1)
1515 
1616 let g = {
1717     let h = f
1818     if ((base58'2W' == h))
1919         then 1440
2020         else if ((base58'2T' == h))
2121             then 60
2222             else throw("Unknown chain")
2323     }
2424 
2525 let i = {
2626     let h = f
2727     if ((base58'2W' == h))
2828         then 10080
2929         else if ((base58'2T' == h))
3030             then 180
3131             else throw("Unknown chain")
3232     }
3333 
3434 let j = {
3535     let h = f
3636     if ((base58'2W' == h))
3737         then 0
3838         else if ((base58'2T' == h))
3939             then 1146000
4040             else throw("Unknown chain")
4141     }
4242 
4343 let k = {
4444     let h = f
4545     if ((base58'2W' == h))
4646         then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
4747         else if ((base58'2T' == h))
4848             then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
4949             else throw("Unknown chain")
5050     }
5151 
5252 let l = {
5353     let h = f
5454     if ((base58'2W' == h))
5555         then "3PFwYta8biEz31zpeFe5DJK8wE5trSpQVF8"
5656         else if ((base58'2T' == h))
5757             then "3N7UuYar6264P58FBhVWKPQAh4Yua2hgngv"
5858             else throw("Unknown chain")
5959     }
6060 
6161 let m = {
6262     let h = f
6363     if ((base58'2W' == h))
6464         then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
6565         else if ((base58'2T' == h))
6666             then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
6767             else throw("Unknown chain")
6868     }
6969 
7070 let n = {
7171     let h = f
7272     if ((base58'2W' == h))
7373         then "3P2sk1KncSxRaZs8b4CWGPw2jkvvav74u4D"
7474         else if ((base58'2T' == h))
7575             then "3N8y4wxX3JC4TdrCJBXX16SjWf6X256hrep"
7676             else throw("Unknown chain")
7777     }
7878 
7979 func o (p,q) = valueOrErrorMessage(getString(p, q), makeString(["mandatory ", toString(p), ".", q, " is not defined"], ""))
8080 
8181 
8282 let r = 1
8383 
8484 let s = 2
8585 
8686 let t = 4
8787 
8888 let u = 5
8989 
9090 func v () = "%s__restConfig"
9191 
9292 
9393 func w () = "%s__rest2Addr"
9494 
9595 
9696 func x () = "%s__restAddr"
9797 
9898 
9999 let y = addressFromStringValue(valueOrElse(getString(this, x()), m))
100100 
101101 func z (A) = split_4C(o(A, v()), a)
102102 
103103 
104104 func B (C,D) = valueOrErrorMessage(addressFromString(C[D]), ("Rest cfg doesn't contain address at index " + toString(D)))
105105 
106106 
107107 let E = 1
108108 
109109 let F = 8
110110 
111111 let G = z(y)
112112 
113113 let H = B(G, E)
114114 
115115 let I = B(G, F)
116116 
117117 let J = addressFromStringValue(valueOrElse(getString(this, w()), l))
118118 
119119 let C = z(J)
120120 
121121 let K = B(C, r)
122122 
123123 let L = B(C, s)
124124 
125125 let M = B(C, t)
126126 
127127 let N = B(C, u)
128128 
129129 func O (P) = ("lastWeekTxIdByUser_" + P)
130130 
131131 
132132 let Q = "wlg_assetId"
133133 
134134 let R = valueOrErrorMessage(getBinary(L, Q), "WLGOLD is not issued yet")
135135 
136136 func S (P) = ("userBet_" + P)
137137 
138138 
139139 func T (P,U) = ((("userWeekTickets_" + P) + "_") + toString(U))
140140 
141141 
142142 func V (U) = ("totalWeekTickets_" + toString(U))
143143 
144144 
145145 func W (U) = ("totalWeekParticipants_" + toString(U))
146146 
147147 
148148 func X (U) = ("numNFT2Draw_" + toString(U))
149149 
150150 
151151 func Y (U) = ("numNFTDrawn_" + toString(U))
152152 
153153 
154154 func Z (U) = ("weekWinners_" + toString(U))
155155 
156156 
157157 func aa (ab) = {
158158     let ac = (ab * g)
159159     let ad = if ((ac > j))
160160         then ac
161161         else (ac + j)
162162     (toInt(value(value(blockInfoByHeight(ad)).vrf)) % 4)
163163     }
164164 
165165 
166166 let ae = 0
167167 
168168 let af = 1
169169 
170170 let ag = 2
171171 
172172 let ah = 8
173173 
174174 let ai = 11
175175 
176176 let aj = 12
177177 
178178 let ak = 15
179179 
180180 let al = 16
181181 
182182 let am = 19
183183 
184184 let an = 23
185185 
186186 let ao = 24
187187 
188188 let ap = 25
189189 
190190 let aq = 26
191191 
192192 let ar = 27
193193 
194194 let as = 28
195195 
196196 let at = 29
197197 
198198 func au (av) = {
199199     let h = av
200200     if ($isInstanceOf(h, "Int"))
201201         then {
202202             let aw = h
203203             aw
204204             }
205205         else throw("fail to cast into Int")
206206     }
207207 
208208 
209209 func ax (ay,az) = {
210210     let aA = pow(10, 0, az, 0, 0, DOWN)
211211     let aB = toString((ay % aA))
212212     let aC = drop(toString(aA), (1 + size(aB)))
213213     (((toString((ay / aA)) + ".") + aC) + aB)
214214     }
215215 
216216 
217217 func aD (aE,aF,aG) = if ((0 >= aE))
218218     then throw("maxValue should be > 0")
219219     else {
220220         let aH = sha256_16Kb((aF + aG))
221221         (toInt(aH) % aE)
222222         }
223223 
224224 
225225 let aI = 100000000
226226 
227227 let aJ = 3200
228228 
229229 let aK = 4000
230230 
231231 let aL = 3
232232 
233233 let aM = 100000000000
234234 
235235 func aN (P) = ("userXP_" + P)
236236 
237237 
238238 func aO (P) = ("userLevel_" + P)
239239 
240240 
241241 let aP = 10000
242242 
243243 func aQ (aR) = fraction(aJ, pow(aR, 4, aK, 4, 4, DOWN), aI)
244244 
245245 
246246 func aS (aT,aU) = {
247247     let aV = aQ(aU)
248248 [aV, (aL * (aV - aT))]
249249     }
250250 
251251 
252252 let aW = 1000000
253253 
254254 let aX = 100000000
255255 
256256 let aY = 100000000000000
257257 
258258 let aZ = 200000
259259 
260260 let ba = 100000
261261 
262262 let bb = 400000
263263 
264264 let bc = 31557600000
265265 
266266 let bd = 86400000
267267 
268268 let be = 50000
269269 
270270 let bf = take(drop(this.bytes, 1), 1)
271271 
272272 let bg = {
273273     let h = bf
274274     if ((base58'2W' == h))
275275         then 1208630000
276276         else if ((base58'2T' == h))
277277             then 0
278278             else throw("Unknown chain")
279279     }
280280 
281281 let bh = "teamAddr"
282282 
283283 let bi = "lastClaimedTime_team"
284284 
285285 let bj = "teamAmountLeft"
286286 
287287 let bk = "lastClaimedTime_activities"
288288 
289289 let bl = "activitiesAmountLeft"
290290 
291291 let bm = "stakersAmountLeft"
292292 
293-func bn (P) = ("lastClaimedTimeUser_" + P)
293+func bn (P) = ("lastClaimedTimeUserOld_" + P)
294294 
295295 
296296 func bo (P) = ("lastArbTimeUser_" + P)
297297 
298298 
299299 func bp (P) = ("lastWlgLimitUser_" + P)
300300 
301301 
302302 func bq (br) = fraction(aY, (bb * (br + 1)), (6 * aW))
303303 
304304 
305305 let bs = "wlg_issueTime"
306306 
307307 let bt = "wlg_issuedAmount"
308308 
309309 let bu = "zbill_issuedAmount"
310310 
311311 func bv (P) = ("acresStakedAmountByUser_" + P)
312312 
313313 
314314 let bw = "acresStakedAmountTotal"
315315 
316316 func bx (P) = ("wlgStakedAmountByUser_" + P)
317317 
318318 
319319 let by = "wlgStakedAmountTotal"
320320 
321321 func bz (P) = ("wlgStakedTimeByUser_" + P)
322322 
323323 
324324 let bA = 0
325325 
326326 let bB = 1
327327 
328328 let bC = 2
329329 
330330 let bD = 3
331331 
332332 let bE = 4
333333 
334334 let bF = 5
335335 
336336 let bG = 6
337337 
338338 func bH (bI,H,I) = {
339339     let bJ = split(valueOrElse(getString(H, "resTypesProportions"), "0_0_0_0_0_0"), "_")
340340     func bK (bL,bM) =     (bL + parseIntValue(bM))
341341 
342342     let bN = {
343343         let bO = bJ
344344         let bP = size(bO)
345345         let bQ = 0
346346         func bR (bS,bT) =         if ((bT >= bP))
347347             then bS
348348             else bK(bS, bO[bT])
349349 
350350         func bU (bS,bT) =         if ((bT >= bP))
351351             then bS
352352             else throw("List size exceeds 6")
353353 
354354         bU(bR(bR(bR(bR(bR(bR(bQ, 0), 1), 2), 3), 4), 5), 6)
355355         }
356356     let bV = valueOrElse(getInteger(H, ("stakedPiecesByOwner_" + bI)), 0)
357357     let bW = valueOrElse(getInteger(I, bw), 0)
358358     let bX = valueOrElse(getInteger(I, bv(bI)), 0)
359359 [bN, bV, bW, bX]
360360     }
361361 
362362 
363363 let bY = 0
364364 
365365 let bZ = 1
366366 
367367 let ca = 2
368368 
369369 let cb = 3
370370 
371371 func cc (cd,ce,cf,cg,ch) = {
372372     let ci = valueOrErrorMessage(getInteger(ce[bD], bt), "WLGOLD is not issued yet")
373373     let cj = assetBalance(ce[bC], cf)
374374     let ck = assetBalance(ce[bA], cf)
375375     let cl = (assetBalance(ce[bD], cf) - cg)
376376     let cm = assetBalance(ce[bE], cf)
377377     let cn = ce[bF]
378378     let co = (assetBalance(cn, cf) + valueOrElse(getInteger(cn, bu), 0))
379379     let cp = ((cj + cl) + co)
380380     let cq = valueOrErrorMessage(getBinary(ce[bD], "wlg_assetId"), "Not initialized yet")
381381     let cr = lastBlock.timestamp
382382     let cs = valueOrErrorMessage(getInteger(ce[bD], bs), "Not initialized")
383383     let ct = assetBalance(ce[bB], cq)
384384     let cu = fraction(aY, aZ, aW)
385385     let cv = valueOrElse(getInteger(ce[bD], bj), cu)
386386     let cw = valueOrElse(getInteger(ce[bD], bi), cs)
387387     let cx = addressFromStringValue(value(getString(ce[bD], bh)))
388388     let cy = min([fraction(cu, (cr - cw), (3 * bc)), cv])
389389     let cz = assetBalance(cx, cq)
390390     let cA = fraction(aY, ba, aW)
391391     let cB = valueOrElse(getInteger(ce[bD], bl), cA)
392392     let cC = valueOrElse(getInteger(ce[bD], bk), cs)
393393     let cD = min([fraction(cA, (cr - cC), (3 * bc)), cB])
394394     let cE = assetBalance(ce[bA], cq)
395395     let cF = valueOrElse(getInteger(ce[bD], bn(cd)), cs)
396396     let cG = ((cF - cs) / bc)
397397     let cH = min([cr, (cs + (3 * bc))])
398398     let cI = min([((cr - cs) / bc), 2])
399399     let cJ = bH(cd, ce[bB], ce[bG])
400400     let cK = bq(cI)
401401     let cL = if ((cG == cI))
402402         then {
403403             let cM = fraction(cK, (cH - cF), bc)
404404             let cN = fraction(cM, ch, aW)
405405             let cO = (cF + fraction((cH - cF), ch, aW))
406406             $Tuple3(cN, cM, cO)
407407             }
408408         else if ((cG == (cI - 1)))
409409             then {
410410                 let cP = fraction(bq((cI - 1)), ((cs + (bc * cI)) - cF), bc)
411411                 let cM = fraction(cK, (cH - (cs + (bc * cI))), bc)
412412                 let cQ = (cP + cM)
413413                 let cN = fraction(cQ, ch, aW)
414414                 let cO = if ((cP >= cN))
415415                     then (cF + fraction(bc, cN, bq((cI - 1))))
416416                     else ((cs + (bc * cI)) + fraction(bc, (cN - cP), cK))
417417                 $Tuple3(cN, cQ, cO)
418418                 }
419419             else {
420420                 let cR = fraction(bq((cI - 2)), ((cs + (bc * (cI - 1))) - cF), bc)
421421                 let cP = bq((cI - 1))
422422                 let cM = fraction(cK, (cH - (cs + (bc * cI))), bc)
423423                 let cQ = ((cR + cP) + cM)
424424                 let cN = fraction(cQ, ch, aW)
425425                 let cO = if ((cR >= cN))
426426                     then (cF + fraction(bc, cN, bq((cI - 2))))
427427                     else if (((cR + cP) >= cN))
428428                         then ((cs + (bc * (cI - 1))) + fraction(bc, (cN - cR), bq((cI - 1))))
429429                         else ((cs + (bc * cI)) + fraction(bc, ((cN - cR) - cP), cK))
430430                 $Tuple3(cN, cQ, cO)
431431                 }
432432     let cS = cL._1
433433     let cT = cL._2
434434     let cU = cL._3
435435     let cV = fraction(fraction(cK, bd, bc), 25, cJ[bY])
436436     let cW = valueOrElse(getInteger(ce[bD], bm), 0)
437437     let cX = fraction(cS, ((cJ[bZ] * aX) + cJ[cb]), ((cJ[bY] * aX) + cJ[ca]))
438438     let cY = fraction(cX, be, aW)
439439     let cZ = (cX - cY)
440440     let da = fraction(cT, ((cJ[bZ] * aX) + cJ[cb]), ((cJ[bY] * aX) + cJ[ca]))
441441 [ci, fraction((cp - bg), aX, ci), cp, cj, ck, cl, cm, cs, cw, cu, cv, cy, cz, cA, cB, cD, cE, cI, cW, cK, cF, cZ, cV, co, da, cU, ct]
442442     }
443443 
444444 
445445 let db = 1000000
446446 
447447 let dc = 100000000
448448 
449449 let dd = 200000
450450 
451451 let de = 100000
452452 
453453 let df = 400000
454454 
455455 let dg = 31557600000
456456 
457457 let dh = 86400000
458458 
459459 let di = 1000000000
460460 
461461 let dj = 800000
462462 
463463 let dk = 100000
464464 
465465 let dl = 100000
466466 
467467 let dm = 1731279600000
468468 
469469 let dn = "marketingAddr"
470470 
471471 let do = "teamAddr"
472472 
473473 let dp = "lastClaimedTime_team"
474474 
475475 let dq = "teamAmountLeft"
476476 
477477 let dr = "lastClaimedTime_activities"
478478 
479479 let ds = "activitiesAmountLeft"
480480 
481481 let dt = "stakersAmountLeft"
482482 
483483 func du (P) = ("lastClaimedTimeUser_" + P)
484484 
485485 
486486 func dv (ci,br) = fraction(ci, (df * (br + 1)), (6 * db))
487487 
488488 
489489 let dw = "wlg_issue10Time"
490490 
491491 let dx = "wlg_issueTime"
492492 
493493 let dy = "wlg_issuedAmount"
494494 
495495 let dz = "zbill_issuedAmount"
496496 
497497 func dA (P) = ("acresStakedAmountByUser_" + P)
498498 
499499 
500500 let dB = "acresStakedAmountTotal"
501501 
502502 let dC = "totalFarmingPower"
503503 
504504 let dD = 0
505505 
506506 let dE = 1
507507 
508508 let dF = 2
509509 
510510 let dG = 3
511511 
512512 let dH = 4
513513 
514514 let dI = 5
515515 
516516 let dJ = 100000000
517517 
518518 let dK = "nftTotalIssued"
519519 
520520 let dL = "nftTotalBurned"
521521 
522522 let dM = "WlNftTotalStaked"
523523 
524524 func dN (P) = ("userWlNftNumber_" + P)
525525 
526526 
527527 func dO (P) = ("userFullBonus_" + P)
528528 
529529 
530530 let dP = [0, 10, 20, 40, 80, 150, 250, 400, 700, 1000]
531531 
532532 func dQ (dR) = {
533533     let dS = ((dR + 99999999) / dc)
534534     func dT (bL,bM) =     if ((bM >= dS))
535535         then bL
536536         else (bL + 1)
537537 
538538     let bO = dP
539539     let bP = size(bO)
540540     let bQ = 0
541541     func bR (bS,bT) =     if ((bT >= bP))
542542         then bS
543543         else dT(bS, bO[bT])
544544 
545545     func bU (bS,bT) =     if ((bT >= bP))
546546         then bS
547547         else throw("List size exceeds 10")
548548 
549549     bU(bR(bR(bR(bR(bR(bR(bR(bR(bR(bR(bQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
550550     }
551551 
552552 
553553 func dU (dR) = ((dR * 20) * (dQ(dR) + 4))
554554 
555555 
556556 func dV (dR,dW) = {
557557     let dX = dU(dR)
558558     $Tuple2(fraction(dX, (db + dW), db), dX)
559559     }
560560 
561561 
562562 func dY (bI,K) = {
563563     let dZ = valueOrElse(getInteger(K, dC), 0)
564564     let bX = valueOrElse(getInteger(K, dA(bI)), 0)
565565     let ea = valueOrElse(getInteger(K, dO(bI)), 0)
566566     let cL = dV(bX, ea)
567567     let eb = cL._1
568568     let ec = cL._2
569569 [dZ, eb, ec, ea]
570570     }
571571 
572572 
573573 let ed = 0
574574 
575575 let ee = 1
576576 
577577 func ef (cd,ce,cf,cg) = {
578578     let ci = valueOrErrorMessage(getInteger(ce[dF], dy), "WLGOLD is not issued yet")
579579     let ck = assetBalance(ce[dD], cf)
580580     let cl = (assetBalance(ce[dF], cf) - cg)
581581     let cm = assetBalance(ce[dG], cf)
582582     let eg = assetBalance(ce[dE], cf)
583583     let cn = ce[dH]
584584     let co = (assetBalance(cn, cf) + valueOrElse(getInteger(cn, dz), 0))
585585     let cp = ((eg + cl) + co)
586586     let cq = valueOrErrorMessage(getBinary(ce[dF], "wlg_assetId"), "Not initialized yet")
587587     let cr = lastBlock.timestamp
588588     let cs = valueOrErrorMessage(getInteger(ce[dF], dx), "Not initialized")
589589     let eh = assetBalance(ce[dF], cq)
590590     let cu = fraction(ci, dd, db)
591591     let cv = valueOrElse(getInteger(ce[dF], dq), cu)
592592     let cw = valueOrElse(getInteger(ce[dF], dp), cs)
593593     let cx = addressFromStringValue(value(getString(ce[dF], do)))
594594     let cy = min([fraction(cu, (cr - cw), (3 * dg)), cv])
595595     let cz = assetBalance(cx, cq)
596596     let cA = fraction(ci, de, db)
597597     let cB = valueOrElse(getInteger(ce[dF], ds), cA)
598598     let cC = valueOrElse(getInteger(ce[dF], dr), cs)
599599     let cD = min([fraction(cA, (cr - cC), (3 * dg)), cB])
600600     let cE = assetBalance(ce[dD], cq)
601601     let cF = valueOrElse(getInteger(ce[dF], du(cd)), cs)
602602     let cG = ((cF - cs) / dg)
603603     let cH = min([cr, (cs + (3 * dg))])
604604     let cI = min([((cr - cs) / dg), 2])
605605     let cJ = dY(cd, ce[dE])
606606     let cK = dv(ci, cI)
607607     let ei = (cs + (dg * cI))
608608     let ej = (cs + (dg * (cI - 1)))
609609     let cM = fraction(cK, (cH - cF), dg)
610610     let cT = if ((cG == cI))
611611         then cM
612612         else if ((cG == (cI - 1)))
613613             then {
614614                 let cP = fraction(dv(ci, (cI - 1)), (ei - cF), dg)
615615                 (cP + cM)
616616                 }
617617             else {
618618                 let cR = fraction(dv(ci, (cI - 2)), (ej - cF), dg)
619619                 let cP = dv(ci, (cI - 1))
620620                 ((cR + cP) + cM)
621621                 }
622622     let cW = valueOrElse(getInteger(ce[dF], dt), 0)
623623     let cS = if ((cJ[ed] != 0))
624624         then fraction(cT, cJ[ee], cJ[ed])
625625         else 0
626626     let ek = valueOrElse(getInteger(ce[dF], dw), dm)
627627     let el = fraction(di, max([(cr - ek), 0]), dh)
628628     let em = fraction(el, dk, db)
629629     let en = fraction(el, dl, db)
630630     let eo = max([(cr - max([dm, cF])), 0])
631631     let ep = if ((cJ[ed] != 0))
632632         then fraction(fraction(fraction(di, eo, dh), cJ[ee], cJ[ed]), dj, db)
633633         else 0
634634     let eq = max([dm, cr])
635635     let er = valueOrElse(getInteger(ce[dE], dB), 0)
636636     let es = valueOrElse(getInteger(ce[dE], dK), 0)
637637     let et = valueOrElse(getInteger(ce[dE], dL), 0)
638638     let eu = valueOrElse(getInteger(ce[dE], dM), 0)
639639     let ev = valueOrElse(getInteger(ce[dE], dN(valueOrElse(cd, ""))), 0)
640640 [ci, eh, fraction(cp, dc, ci), cp, ck, eg, cl, cm, cs, cw, cu, cv, cy, cz, cA, cB, cD, cE, cI, cW, cK, cF, co, cS, cH, el, em, en, ep, eq, cJ[ed], er, es, et, eu, ev]
641641     }
642642 
643643 
644644 let ew = "profitAddr"
645645 
646646 let ex = "stakersAmountPaidTotal"
647647 
648648 func ey (P) = ("stakersAmountPaidUser_" + P)
649649 
650650 
651651 func ez () = au(reentrantInvoke(K, "saveLastTx", nil, nil))
652652 
653653 
654654 func eA (P) = {
655655     let eB = valueOrElse(getInteger(bo(P)), 0)
656656     let eC = valueOrElse(getInteger(K, bv(P)), 0)
657657     let eD = valueOrElse(getInteger(bp(P)), eC)
658658     let eE = (eD + fraction(eC, (lastBlock.timestamp - eB), e))
659659     min([eE, eC])
660660     }
661661 
662662 
663663 let eF = 10
664664 
665665 let eG = 11
666666 
667667 let eH = 14
668668 
669669 let eI = 15
670670 
671671 let eJ = 18
672672 
673673 let eK = 21
674674 
675675 let eL = 24
676676 
677677 let eM = 25
678678 
679679 func eN (P) = {
680680     let eO = addressFromStringValue(P)
681681     let eP = addressFromStringValue(n)
682682     let eQ = cc(P, [y, H, eP, L, M, N, I], k, 0, b)
683683     let cr = lastBlock.timestamp
684684     let cv = eQ[eF]
685685     let eR = eQ[eG]
686686     let cB = eQ[eH]
687687     let eS = eQ[eI]
688688     let cS = eQ[eK]
689689     let eT = ey(P)
690690     let eU = eQ[eL]
691691     let eV = eQ[eM]
692692     $Tuple2([ScriptTransfer(addressFromStringValue(value(getString(bh))), eR, R), ScriptTransfer(y, eS, R), IntegerEntry(eT, (valueOrElse(getInteger(eT), 0) + cS)), IntegerEntry(ex, (valueOrElse(getInteger(ex), 0) + eU)), IntegerEntry(bm, (eQ[eJ] - eU)), IntegerEntry(bj, (cv - eR)), IntegerEntry(bi, cr), IntegerEntry(bl, (cB - eS)), IntegerEntry(bk, cr), IntegerEntry(bn(P), eV)], cS)
693693     }
694694 
695695 
696696 func eW (P) = {
697697     let eQ = ef(P, [J, K, L, M, N], k, 0)
698698     let eX = du(P)
699699     let cF = valueOrElse(getInteger(eX), 0)
700700     let eV = eQ[ao]
701701     if ((cF == eV))
702702         then $Tuple2(nil, 0)
703703         else {
704704             let cr = lastBlock.timestamp
705705             let cs = eQ[ah]
706706             let cv = eQ[ai]
707707             let eR = (eQ[aj] + eQ[ar])
708708             let eY = if ((eR > 0))
709709                 then [ScriptTransfer(addressFromStringValue(value(getString(bh))), eR, R)]
710710                 else nil
711711             let cB = eQ[ak]
712712             let eS = eQ[al]
713713             let eZ = if ((eS > 0))
714714                 then [ScriptTransfer(y, eS, R)]
715715                 else nil
716716             let fa = eQ[aq]
717717             let fb = if ((fa > 0))
718718                 then [ScriptTransfer(addressFromStringValue(value(getString(dn))), fa, R)]
719719                 else nil
720720             let cS = eQ[an]
721721             let eT = ey(P)
722722             let eU = (cS + eQ[as])
723723             let fc = eQ[ap]
724724             $Tuple2(((([Reissue(R, fc, true), IntegerEntry(bt, (eQ[ae] + fc)), IntegerEntry(dw, eQ[at]), IntegerEntry(eT, (valueOrElse(getInteger(eT), 0) + cS)), IntegerEntry(ex, (valueOrElse(getInteger(ex), 0) + cS)), IntegerEntry(bm, (eQ[am] - cS)), IntegerEntry(bj, ((cv - eR) + eQ[ar])), IntegerEntry(bi, cr), IntegerEntry(bl, (cB - eS)), IntegerEntry(bk, cr), IntegerEntry(eX, eV)] ++ eY) ++ eZ) ++ fb), eU)
725725             }
726726     }
727727 
728728 
729729 func fd (P,fe) = {
730730     let cr = lastBlock.timestamp
731731     let ff = bz(P)
732732     let fg = bx(P)
733733     let eB = valueOrElse(getInteger(ff), 0)
734734     let fh = valueOrElse(getInteger(fg), 0)
735735     let fi = valueOrElse(getInteger(by), 0)
736736     let aR = fraction(fraction(aP, fh, aM), (eB - cr), bd)
737737     $Tuple3([IntegerEntry(ff, cr), IntegerEntry(fg, (fh + fe)), IntegerEntry(by, (fi + fe))], aR, fh)
738738     }
739739 
740740 
741741 func fj (P) = {
742742     let U = (height / i)
743743     let fk = (U - 1)
744744     let fl = valueOrElse(getInteger(X(fk)), dI)
745745     let fm = valueOrElse(getInteger(Y(fk)), 0)
746746     let fn = valueOrElse(getInteger(T(P, fk)), 0)
747747     if ((0 >= fn))
748748         then $Tuple2(nil, unit)
749749         else {
750750             let fo = valueOrElse(getInteger(V(fk)), 0)
751751             if ((0 >= fo))
752752                 then $Tuple2([DeleteEntry(T(P, fk))], unit)
753753                 else {
754754                     let aG = value(value(blockInfoByHeight((U * i))).vrf)
755755                     let aF = fromBase58String(split(valueOrElse(getString(K, O(P)), "42_DEFAULT"), "_")[1])
756756                     let fp = aD(fo, aF, aG)
757757                     if (((fn * fl) > fp))
758758                         then {
759759                             let fq = invoke(K, "issuePickC1", [P], nil)
760760                             let fr = getString(Z(fk))
761761                             let fs = if (isDefined(fr))
762762                                 then ((value(fr) + "_") + P)
763763                                 else P
764764                             $Tuple2([IntegerEntry(Y(fk), (fm + 1)), DeleteEntry(T(P, fk)), StringEntry(Z(fk), fs)], fq)
765765                             }
766766                         else {
767767                             let ft = (aD(9, (base58'29' + aF), aG) + 1)
768768                             let fu = fraction(fn, ft, 10)
769769                             let fv = T(P, U)
770770                             let fw = valueOrElse(getInteger(fv), 0)
771771                             $Tuple2(((if ((fu == 0))
772772                                 then nil
773773                                 else {
774774                                     let fx = [IntegerEntry(V(U), (valueOrElse(getInteger(V(U)), 0) + fu)), IntegerEntry(fv, (fw + fu))]
775775                                     if ((fw > 0))
776776                                         then fx
777777                                         else (fx :+ IntegerEntry(W(U), (valueOrElse(getInteger(W(U)), 0) + 1)))
778778                                     }) :+ DeleteEntry(T(P, fk))), fu)
779779                             }
780780                     }
781781             }
782782     }
783783 
784784 
785785 func fy (P,fz) = {
786786     let U = (height / i)
787787     let fv = T(P, U)
788788     let fA = split(fz, "_")
789789     let fB = valueOrElse(getInteger(V(U)), 0)
790790     let fw = valueOrElse(getInteger(fv), 0)
791791     let fC = if ((aa(parseIntValue(fA[0])) == parseIntValue(fA[1])))
792792         then 1
793793         else 0
794794     let fD = valueOrElse(getInteger(W(U)), 0)
795795     let fE = if (if ((fw == 0))
796796         then (fC == 1)
797797         else false)
798798         then [IntegerEntry(W(U), (fD + 1))]
799799         else nil
800800     $Tuple2(if ((fC == 0))
801801         then nil
802802         else ((fE :+ IntegerEntry(fv, (fw + fC))) :+ IntegerEntry(V(U), (fB + fC))), fC)
803803     }
804804 
805805 
806806 @Callable(fF)
807807 func constructorV1 (fG,fH,cx,fI) = if ((fF.caller != this))
808808     then throw("Permission denied")
809809     else if (isDefined(getBinary(Q)))
810810         then throw("Already initialized")
811811         else {
812812             let ci = aY
813813             let fJ = Issue("WLGOLD", "WavesLands Gold investment token", ci, 8, true, unit, 0)
814814             let fK = calculateAssetId(fJ)
815815 [fJ, IntegerEntry(bs, lastBlock.timestamp), IntegerEntry(bt, ci), IntegerEntry(ex, 0), IntegerEntry(bm, fraction(aY, bb, b)), BinaryEntry(Q, fK), StringEntry(x(), fG), StringEntry(dn, fH), StringEntry(bh, cx), StringEntry(ew, fI)]
816816             }
817817 
818818 
819819 
820820 @Callable(fF)
821821 func constructorV2 (fL) = if ((fF.caller != this))
822822     then throw("Permission denied")
823823     else [StringEntry(w(), fL)]
824824 
825825 
826826 
827827 @Callable(fF)
828828 func buyWlg (fM) = {
829829     let fN = ez()
830830     if ((fN == fN))
831831         then if ((size(fF.payments) != 1))
832832             then throw("exactly 1 payment must be attached")
833833             else {
834834                 let fO = fF.payments[0]
835835                 let fP = fO.amount
836836                 if (if (!(isDefined(fO.assetId)))
837837                     then true
838838                     else (value(fO.assetId) != k))
839839                     then throw("USDT payments only!")
840840                     else {
841841                         let eO = fF.caller
842842                         let P = toString(eO)
843843                         if ((d > fP))
844844                             then throw((("You can trade min " + ax(d, 6)) + " USDT"))
845845                             else {
846846                                 let eQ = ef("", [J, K, L, M, N], k, fP)
847847                                 let fQ = eQ[ae]
848848                                 let fR = eQ[ag]
849849                                 let fS = fraction(fR, 6, 5, CEILING)
850850                                 let fT = fraction(fP, c, fS)
851851                                 let fU = eA(P)
852852                                 if ((fT > fU))
853853                                     then throw((("You can get max " + ax(fU, 8)) + " WLGOLD at the moment"))
854854                                     else if ((fM > fT))
855855                                         then throw("Price changed during operation, please try again")
856856                                         else {
857857                                             let fV = (fP / 6)
858858                                             $Tuple2([Reissue(R, fT, true), IntegerEntry(bt, (fQ + fT)), IntegerEntry(bo(P), lastBlock.timestamp), IntegerEntry(bp(P), (fU - fT)), ScriptTransfer(addressFromStringValue(value(getString(ew))), fV, k), ScriptTransfer(eO, fT, R)], fN)
859859                                             }
860860                                 }
861861                         }
862862                 }
863863         else throw("Strict value is not equal to itself.")
864864     }
865865 
866866 
867867 
868868 @Callable(fF)
869869 func buyWlgREADONLY (p,fP) = {
870870     let eQ = ef("", [J, K, L, M, N], k, fP)
871871     let fR = eQ[ag]
872872     let fS = fraction(fR, 6, 5, CEILING)
873873     let fT = fraction(fP, c, fS)
874874     let fU = eA(p)
875875     let fW = fraction(fU, fS, c)
876876     let fV = (fP / 6)
877877     $Tuple2(nil, [fT, d, fW, fV])
878878     }
879879 
880880 
881881 
882882 @Callable(fF)
883883 func sellWlg (fX) = {
884884     let fN = ez()
885885     if ((fN == fN))
886886         then if ((size(fF.payments) != 1))
887887             then throw("exactly 1 payment must be attached")
888888             else {
889889                 let fO = fF.payments[0]
890890                 let fY = fO.amount
891891                 let eO = fF.caller
892892                 let P = toString(eO)
893893                 let fU = eA(P)
894894                 if ((fY > fU))
895895                     then throw((("You can spend max " + ax(fU, 8)) + " WLGOLD at the moment"))
896896                     else if (if (!(isDefined(fO.assetId)))
897897                         then true
898898                         else (value(fO.assetId) != R))
899899                         then throw("WLGOLD payments only!")
900900                         else {
901901                             let eQ = ef("", [J, K, L, M, N], k, 0)
902902                             let fQ = eQ[ae]
903903                             let fZ = (eQ[ag] / 2)
904904                             let fP = fraction(fY, fZ, c)
905905                             if ((d > fP))
906906                                 then throw((("You can trade min " + ax(d, 6)) + " USDT"))
907907                                 else if ((fX > fP))
908908                                     then throw("Price changed during operation, please try again")
909909                                     else {
910910                                         let fV = (fP / 5)
911911                                         $Tuple2([Burn(R, fY), IntegerEntry(bt, (fQ - fY)), IntegerEntry(bo(P), lastBlock.timestamp), IntegerEntry(bp(P), (fU - fY)), ScriptTransfer(addressFromStringValue(value(getString(ew))), fV, k), ScriptTransfer(eO, fP, k)], fN)
912912                                         }
913913                             }
914914                 }
915915         else throw("Strict value is not equal to itself.")
916916     }
917917 
918918 
919919 
920920 @Callable(fF)
921921 func sellWlgREADONLY (p,fY) = {
922922     let fU = eA(p)
923923     let eQ = ef("", [J, K, L, M, N], k, 0)
924924     let fZ = (eQ[ag] / 2)
925925     let fP = fraction(fY, fZ, c)
926926     let ga = fraction(d, c, fZ)
927927     let fV = (fP / 5)
928928     $Tuple2(nil, [fP, ga, fU, fV])
929929     }
930930 
931931 
932932 
933933 @Callable(fF)
934934 func claim () = {
935935     let fN = ez()
936936     if ((fN == fN))
937937         then if ((size(fF.payments) != 0))
938938             then throw("No payments required")
939939             else {
940940                 let gb = eW(toString(fF.caller))
941941                 let gc = gb._1
942942                 let gd = gb._2
943943                 $Tuple2((gc :+ ScriptTransfer(fF.caller, gd, R)), fN)
944944                 }
945945         else throw("Strict value is not equal to itself.")
946946     }
947947 
948948 
949949 
950950 @Callable(fF)
951951 func onStakeUnstakeLand (P,ge) = if (if (if ((fF.caller != H))
952952     then (fF.caller != I)
953953     else false)
954954     then (fF.caller != K)
955955     else false)
956956     then throw("Permission denied")
957957     else {
958958         let gf = if (ge)
959959             then eW(P)
960960             else eN(P)
961961         let gc = gf._1
962962         let gd = gf._2
963963         $Tuple2(if ((gd > 0))
964964             then (gc :+ ScriptTransfer(addressFromStringValue(P), gd, R))
965965             else gc, gd)
966966         }
967967 
968968 
969969 
970970 @Callable(fF)
971971 func burnWlgold (fY) = if ((fF.caller != K))
972972     then throw("Permission denied")
973973     else {
974974         let eQ = ef("", [J, K, L, M, N], k, 0)
975975         if ((fY > eQ[af]))
976976             then throw(((("Only " + ax(eQ[af], 8)) + " WLGOLD left on contract, can't burn ") + ax(fY, 8)))
977977             else {
978978                 let gg = (eQ[ae] - fY)
979979                 $Tuple2([Burn(R, fY), IntegerEntry(bt, gg)], gg)
980980                 }
981981         }
982982 
983983 
984984 
985985 @Callable(fF)
986986 func betForTicket (gh) = {
987987     let fN = ez()
988988     if ((fN == fN))
989989         then if ((size(fF.payments) != 0))
990990             then throw("No payments required")
991991             else {
992992                 let P = toString(fF.caller)
993993                 let fk = ((height / i) - 1)
994994                 let fn = valueOrElse(getInteger(T(P, fk)), 0)
995995                 let fo = valueOrElse(getInteger(V(fk)), 0)
996996                 if (if ((fn > 0))
997997                     then (fo > 0)
998998                     else false)
999999                     then throw("Please open the chest first")
10001000                     else if (((gh / 4) != 0))
10011001                         then throw("Invalid bet: should be 0..3")
10021002                         else {
10031003                             let gi = (height % g)
10041004                             if ((gi > (g - 3)))
10051005                                 then throw((("Cannot bet: the day is almost ended, please wait " + toString((g - gi))) + " blocks"))
10061006                                 else {
10071007                                     let gj = valueOrElse(getInteger(K, dA(P)), 0)
10081008                                     if ((dJ > gj))
10091009                                         then throw((("You need to stake at least " + ax(dJ, 8)) + " ACRES to bet"))
10101010                                         else {
10111011                                             let gk = ((height / g) + 1)
10121012                                             let gl = S(P)
10131013                                             let gm = getString(gl)
10141014                                             let gn = StringEntry(gl, ((toString(gk) + "_") + toString(gh)))
10151015                                             if (isDefined(gm))
10161016                                                 then {
10171017                                                     let go = value(gm)
10181018                                                     if ((split(go, "_")[0] == toString(gk)))
10191019                                                         then throw("You already bet for tomorrow")
10201020                                                         else {
10211021                                                             let gp = fy(P, go)
10221022                                                             $Tuple2((gp._1 :+ gn), gp._2)
10231023                                                             }
10241024                                                     }
10251025                                                 else $Tuple2([gn], 0)
10261026                                             }
10271027                                     }
10281028                             }
10291029                 }
10301030         else throw("Strict value is not equal to itself.")
10311031     }
10321032 
10331033 
10341034 
10351035 @Callable(fF)
10361036 func takeWlgXp (P) = if ((fF.caller != H))
10371037     then throw("Permission denied")
10381038     else {
10391039         let gq = fd(P, 0)
10401040         let gc = gq._1
10411041         let aR = gq._2
10421042         $Tuple2(gc, aR)
10431043         }
10441044 
10451045 
10461046 
10471047 @Callable(fF)
10481048 func checkWlgXpREADONLY (P) = {
10491049     let gr = fd(P, 0)
10501050     let gs = gr._1
10511051     let gt = gr._2
10521052     let aU = (valueOrElse(getInteger(H, aN(P)), 0) + gt)
10531053     let gu = aS(valueOrElse(getInteger(H, aO(P)), 0), aU)
10541054     $Tuple2(nil, (gu :+ aU))
10551055     }
10561056 
10571057 
10581058 
10591059 @Callable(fF)
10601060 func setNumPrizes (fl) = if ((fF.caller != this))
10611061     then throw("Permission denied")
10621062     else {
10631063         let U = (height / i)
10641064         $Tuple2([IntegerEntry(X(U), fl)], fl)
10651065         }
10661066 
10671067 
10681068 
10691069 @Callable(fF)
10701070 func openChest () = {
10711071     let fN = ez()
10721072     if ((fN == fN))
10731073         then if ((size(fF.payments) != 0))
10741074             then throw("No payments required")
10751075             else {
10761076                 let fk = ((height / i) - 1)
10771077                 let P = toString(fF.caller)
10781078                 let fn = valueOrElse(getInteger(T(P, fk)), 0)
10791079                 if ((0 >= fn))
10801080                     then throw("No gems to open the chest")
10811081                     else fj(P)
10821082                 }
10831083         else throw("Strict value is not equal to itself.")
10841084     }
10851085 
10861086 
10871087 
10881088 @Callable(fF)
10891089 func addGemsFor (P,fC) = if ((fF.caller != this))
10901090     then throw("Permission denied")
10911091     else {
10921092         let U = (height / i)
10931093         let fv = T(P, U)
10941094         let fB = valueOrElse(getInteger(V(U)), 0)
10951095         let fw = valueOrElse(getInteger(fv), 0)
10961096         let fD = valueOrElse(getInteger(W(U)), 0)
10971097         let fE = if (if ((fw == 0))
10981098             then (fC == 1)
10991099             else false)
11001100             then [IntegerEntry(W(U), (fD + 1))]
11011101             else nil
11021102         $Tuple2(((fE :+ IntegerEntry(fv, (fw + fC))) :+ IntegerEntry(V(U), (fB + fC))), fC)
11031103         }
11041104 
11051105 
github/deemru/w8io/169f3d6 
110.56 ms ◑