tx · 3FvJxmJR9sgBtD197FaZNXvGHBau9GFUq8weBbWd2LC4

3N7HtrKeFFLz5oy6PfGv1Lg3GwPk4gCPdGy:  -0.03500000 Waves

2024.12.04 20:19 [3400192] smart account 3N7HtrKeFFLz5oy6PfGv1Lg3GwPk4gCPdGy > SELF 0.00000000 Waves

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

View: original | compacted
Prev: EkigtXR54sN3P2SpugWLUV7EeoMQYcb1MXtfaJsCMWUr
Next: 4S51ysrJjgm1mZCCEJjnAWht1eeiDBgTkeLxW81habi4

Diff: 

OldNewDifferences
368368 
369369 let cb = 3
370370 
371-let cc = 1733335200000
371+let cc = 1733346000000
372372 
373373 func cd (ce,cf,cg,ch,ci) = {
374374     let cj = valueOrErrorMessage(getInteger(cf[bD], bt), "WLGOLD is not issued yet")

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 
293293 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 
371-let cc = 1733335200000
371+let cc = 1733346000000
372372 
373373 func cd (ce,cf,cg,ch,ci) = {
374374     let cj = valueOrErrorMessage(getInteger(cf[bD], bt), "WLGOLD is not issued yet")
375375     let ck = assetBalance(cf[bC], cg)
376376     let cl = assetBalance(cf[bA], cg)
377377     let cm = (assetBalance(cf[bD], cg) - ch)
378378     let cn = assetBalance(cf[bE], cg)
379379     let co = cf[bF]
380380     let cp = (assetBalance(co, cg) + valueOrElse(getInteger(co, bu), 0))
381381     let cq = ((ck + cm) + cp)
382382     let cr = valueOrErrorMessage(getBinary(cf[bD], "wlg_assetId"), "Not initialized yet")
383383     let cs = lastBlock.timestamp
384384     let ct = valueOrErrorMessage(getInteger(cf[bD], bs), "Not initialized")
385385     let cu = assetBalance(cf[bB], cr)
386386     let cv = fraction(aY, aZ, aW)
387387     let cw = valueOrElse(getInteger(cf[bD], bj), cv)
388388     let cx = valueOrElse(getInteger(cf[bD], bi), ct)
389389     let cy = addressFromStringValue(value(getString(cf[bD], bh)))
390390     let cz = min([fraction(cv, (cs - cx), (3 * bc)), cw])
391391     let cA = assetBalance(cy, cr)
392392     let cB = fraction(aY, ba, aW)
393393     let cC = valueOrElse(getInteger(cf[bD], bl), cB)
394394     let cD = valueOrElse(getInteger(cf[bD], bk), ct)
395395     let cE = min([fraction(cB, (cs - cD), (3 * bc)), cC])
396396     let cF = assetBalance(cf[bA], cr)
397397     let cG = valueOrElse(getInteger(cf[bD], bn(ce)), ct)
398398     let cH = ((cG - ct) / bc)
399399     let cI = min([min([cs, (ct + (3 * bc))]), cc])
400400     let cJ = min([((cs - ct) / bc), 2])
401401     let cK = bH(ce, cf[bB], cf[bG])
402402     let cL = bq(cJ)
403403     let cM = if ((cH == cJ))
404404         then {
405405             let cN = fraction(cL, (cI - cG), bc)
406406             let cO = fraction(cN, ci, aW)
407407             let cP = (cG + fraction((cI - cG), ci, aW))
408408             $Tuple3(cO, cN, cP)
409409             }
410410         else if ((cH == (cJ - 1)))
411411             then {
412412                 let cQ = fraction(bq((cJ - 1)), ((ct + (bc * cJ)) - cG), bc)
413413                 let cN = fraction(cL, (cI - (ct + (bc * cJ))), bc)
414414                 let cR = (cQ + cN)
415415                 let cO = fraction(cR, ci, aW)
416416                 let cP = if ((cQ >= cO))
417417                     then (cG + fraction(bc, cO, bq((cJ - 1))))
418418                     else ((ct + (bc * cJ)) + fraction(bc, (cO - cQ), cL))
419419                 $Tuple3(cO, cR, cP)
420420                 }
421421             else {
422422                 let cS = fraction(bq((cJ - 2)), ((ct + (bc * (cJ - 1))) - cG), bc)
423423                 let cQ = bq((cJ - 1))
424424                 let cN = fraction(cL, (cI - (ct + (bc * cJ))), bc)
425425                 let cR = ((cS + cQ) + cN)
426426                 let cO = fraction(cR, ci, aW)
427427                 let cP = if ((cS >= cO))
428428                     then (cG + fraction(bc, cO, bq((cJ - 2))))
429429                     else if (((cS + cQ) >= cO))
430430                         then ((ct + (bc * (cJ - 1))) + fraction(bc, (cO - cS), bq((cJ - 1))))
431431                         else ((ct + (bc * cJ)) + fraction(bc, ((cO - cS) - cQ), cL))
432432                 $Tuple3(cO, cR, cP)
433433                 }
434434     let cT = cM._1
435435     let cU = cM._2
436436     let cV = cM._3
437437     let cW = fraction(fraction(cL, bd, bc), 25, cK[bY])
438438     let cX = valueOrElse(getInteger(cf[bD], bm), 0)
439439     let cY = fraction(cT, ((cK[bZ] * aX) + cK[cb]), ((cK[bY] * aX) + cK[ca]))
440440     let cZ = fraction(cY, be, aW)
441441     let da = (cY - cZ)
442442     let db = fraction(cU, ((cK[bZ] * aX) + cK[cb]), ((cK[bY] * aX) + cK[ca]))
443443 [cj, fraction((cq - bg), aX, cj), cq, ck, cl, cm, cn, ct, cx, cv, cw, cz, cA, cB, cC, cE, cF, cJ, cX, cL, cG, da, cW, cp, db, cV, cu]
444444     }
445445 
446446 
447447 let dc = 1000000
448448 
449449 let dd = 100000000
450450 
451451 let de = 200000
452452 
453453 let df = 100000
454454 
455455 let dg = 400000
456456 
457457 let dh = 31557600000
458458 
459459 let di = 86400000
460460 
461461 let dj = 1000000000
462462 
463463 let dk = 800000
464464 
465465 let dl = 100000
466466 
467467 let dm = 100000
468468 
469469 let dn = 1731279600000
470470 
471471 let do = "marketingAddr"
472472 
473473 let dp = "teamAddr"
474474 
475475 let dq = "lastClaimedTime_team"
476476 
477477 let dr = "teamAmountLeft"
478478 
479479 let ds = "lastClaimedTime_activities"
480480 
481481 let dt = "activitiesAmountLeft"
482482 
483483 let du = "stakersAmountLeft"
484484 
485485 func dv (P) = ("lastClaimedTimeUser_" + P)
486486 
487487 
488488 func dw (cj,br) = fraction(cj, (dg * (br + 1)), (6 * dc))
489489 
490490 
491491 let dx = "wlg_issue10Time"
492492 
493493 let dy = "wlg_issueTime"
494494 
495495 let dz = "wlg_issuedAmount"
496496 
497497 let dA = "zbill_issuedAmount"
498498 
499499 func dB (P) = ("acresStakedAmountByUser_" + P)
500500 
501501 
502502 let dC = "acresStakedAmountTotal"
503503 
504504 let dD = "totalFarmingPower"
505505 
506506 let dE = 0
507507 
508508 let dF = 1
509509 
510510 let dG = 2
511511 
512512 let dH = 3
513513 
514514 let dI = 4
515515 
516516 let dJ = 5
517517 
518518 let dK = 100000000
519519 
520520 let dL = "nftTotalIssued"
521521 
522522 let dM = "nftTotalBurned"
523523 
524524 let dN = "WlNftTotalStaked"
525525 
526526 func dO (P) = ("userWlNftNumber_" + P)
527527 
528528 
529529 func dP (P) = ("userFullBonus_" + P)
530530 
531531 
532532 let dQ = [0, 10, 20, 40, 80, 150, 250, 400, 700, 1000]
533533 
534534 func dR (dS) = {
535535     let dT = ((dS + 99999999) / dd)
536536     func dU (bL,bM) =     if ((bM >= dT))
537537         then bL
538538         else (bL + 1)
539539 
540540     let bO = dQ
541541     let bP = size(bO)
542542     let bQ = 0
543543     func bR (bS,bT) =     if ((bT >= bP))
544544         then bS
545545         else dU(bS, bO[bT])
546546 
547547     func bU (bS,bT) =     if ((bT >= bP))
548548         then bS
549549         else throw("List size exceeds 10")
550550 
551551     bU(bR(bR(bR(bR(bR(bR(bR(bR(bR(bR(bQ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
552552     }
553553 
554554 
555555 func dV (dS) = ((dS * 20) * (dR(dS) + 4))
556556 
557557 
558558 func dW (dS,dX) = {
559559     let dY = dV(dS)
560560     $Tuple2(fraction(dY, (dc + dX), dc), dY)
561561     }
562562 
563563 
564564 func dZ (bI,K) = {
565565     let ea = valueOrElse(getInteger(K, dD), 0)
566566     let bX = valueOrElse(getInteger(K, dB(bI)), 0)
567567     let eb = valueOrElse(getInteger(K, dP(bI)), 0)
568568     let cM = dW(bX, eb)
569569     let ec = cM._1
570570     let ed = cM._2
571571 [ea, ec, ed, eb]
572572     }
573573 
574574 
575575 let ee = 0
576576 
577577 let ef = 1
578578 
579579 func eg (ce,cf,cg,ch) = {
580580     let cj = valueOrErrorMessage(getInteger(cf[dG], dz), "WLGOLD is not issued yet")
581581     let cl = assetBalance(cf[dE], cg)
582582     let cm = (assetBalance(cf[dG], cg) - ch)
583583     let cn = assetBalance(cf[dH], cg)
584584     let eh = assetBalance(cf[dF], cg)
585585     let co = cf[dI]
586586     let cp = (assetBalance(co, cg) + valueOrElse(getInteger(co, dA), 0))
587587     let cq = ((eh + cm) + cp)
588588     let cr = valueOrErrorMessage(getBinary(cf[dG], "wlg_assetId"), "Not initialized yet")
589589     let cs = lastBlock.timestamp
590590     let ct = valueOrErrorMessage(getInteger(cf[dG], dy), "Not initialized")
591591     let ei = assetBalance(cf[dG], cr)
592592     let cv = fraction(cj, de, dc)
593593     let cw = valueOrElse(getInteger(cf[dG], dr), cv)
594594     let cx = valueOrElse(getInteger(cf[dG], dq), ct)
595595     let cy = addressFromStringValue(value(getString(cf[dG], dp)))
596596     let cz = min([fraction(cv, (cs - cx), (3 * dh)), cw])
597597     let cA = assetBalance(cy, cr)
598598     let cB = fraction(cj, df, dc)
599599     let cC = valueOrElse(getInteger(cf[dG], dt), cB)
600600     let cD = valueOrElse(getInteger(cf[dG], ds), ct)
601601     let cE = min([fraction(cB, (cs - cD), (3 * dh)), cC])
602602     let cF = assetBalance(cf[dE], cr)
603603     let cG = valueOrElse(getInteger(cf[dG], dv(ce)), ct)
604604     let cH = ((cG - ct) / dh)
605605     let cI = min([cs, (ct + (3 * dh))])
606606     let cJ = min([((cs - ct) / dh), 2])
607607     let cK = dZ(ce, cf[dF])
608608     let cL = dw(cj, cJ)
609609     let ej = (ct + (dh * cJ))
610610     let ek = (ct + (dh * (cJ - 1)))
611611     let cN = fraction(cL, (cI - cG), dh)
612612     let cU = if ((cH == cJ))
613613         then cN
614614         else if ((cH == (cJ - 1)))
615615             then {
616616                 let cQ = fraction(dw(cj, (cJ - 1)), (ej - cG), dh)
617617                 (cQ + cN)
618618                 }
619619             else {
620620                 let cS = fraction(dw(cj, (cJ - 2)), (ek - cG), dh)
621621                 let cQ = dw(cj, (cJ - 1))
622622                 ((cS + cQ) + cN)
623623                 }
624624     let cX = valueOrElse(getInteger(cf[dG], du), 0)
625625     let cT = if ((cK[ee] != 0))
626626         then fraction(cU, cK[ef], cK[ee])
627627         else 0
628628     let el = valueOrElse(getInteger(cf[dG], dx), dn)
629629     let em = fraction(dj, max([(cs - el), 0]), di)
630630     let en = fraction(em, dl, dc)
631631     let eo = fraction(em, dm, dc)
632632     let ep = max([(cs - max([dn, cG])), 0])
633633     let eq = if ((cK[ee] != 0))
634634         then fraction(fraction(fraction(dj, ep, di), cK[ef], cK[ee]), dk, dc)
635635         else 0
636636     let er = max([dn, cs])
637637     let es = valueOrElse(getInteger(cf[dF], dC), 0)
638638     let et = valueOrElse(getInteger(cf[dF], dL), 0)
639639     let eu = valueOrElse(getInteger(cf[dF], dM), 0)
640640     let ev = valueOrElse(getInteger(cf[dF], dN), 0)
641641     let ew = valueOrElse(getInteger(cf[dF], dO(valueOrElse(ce, ""))), 0)
642642 [cj, ei, fraction(cq, dd, cj), cq, cl, eh, cm, cn, ct, cx, cv, cw, cz, cA, cB, cC, cE, cF, cJ, cX, cL, cG, cp, cT, cI, em, en, eo, eq, er, cK[ee], es, et, eu, ev, ew]
643643     }
644644 
645645 
646646 let ex = "profitAddr"
647647 
648648 let ey = "stakersAmountPaidTotal"
649649 
650650 func ez (P) = ("stakersAmountPaidUser_" + P)
651651 
652652 
653653 func eA () = au(reentrantInvoke(K, "saveLastTx", nil, nil))
654654 
655655 
656656 func eB (P) = {
657657     let eC = valueOrElse(getInteger(bo(P)), 0)
658658     let eD = valueOrElse(getInteger(K, bv(P)), 0)
659659     let eE = valueOrElse(getInteger(bp(P)), eD)
660660     let eF = (eE + fraction(eD, (lastBlock.timestamp - eC), e))
661661     min([eF, eD])
662662     }
663663 
664664 
665665 let eG = 10
666666 
667667 let eH = 11
668668 
669669 let eI = 14
670670 
671671 let eJ = 15
672672 
673673 let eK = 18
674674 
675675 let eL = 21
676676 
677677 let eM = 24
678678 
679679 let eN = 25
680680 
681681 func eO (P) = {
682682     let eP = addressFromStringValue(P)
683683     let eQ = addressFromStringValue(n)
684684     let eR = cd(P, [y, H, eQ, L, M, N, I], k, 0, b)
685685     let cs = lastBlock.timestamp
686686     let cw = eR[eG]
687687     let eS = eR[eH]
688688     let cC = eR[eI]
689689     let eT = eR[eJ]
690690     let cT = eR[eL]
691691     let eU = ez(P)
692692     let eV = eR[eM]
693693     let eW = eR[eN]
694694     $Tuple2([ScriptTransfer(addressFromStringValue(value(getString(bh))), eS, R), ScriptTransfer(y, eT, R), IntegerEntry(eU, (valueOrElse(getInteger(eU), 0) + cT)), IntegerEntry(ey, (valueOrElse(getInteger(ey), 0) + eV)), IntegerEntry(bm, (eR[eK] - eV)), IntegerEntry(bj, (cw - eS)), IntegerEntry(bi, cs), IntegerEntry(bl, (cC - eT)), IntegerEntry(bk, cs), IntegerEntry(bn(P), eW)], cT)
695695     }
696696 
697697 
698698 func eX (P) = {
699699     let eR = eg(P, [J, K, L, M, N], k, 0)
700700     let eY = dv(P)
701701     let cG = valueOrElse(getInteger(eY), 0)
702702     let eW = eR[ao]
703703     if ((cG == eW))
704704         then $Tuple2(nil, 0)
705705         else {
706706             let cs = lastBlock.timestamp
707707             let ct = eR[ah]
708708             let cw = eR[ai]
709709             let eS = (eR[aj] + eR[ar])
710710             let eZ = if ((eS > 0))
711711                 then [ScriptTransfer(addressFromStringValue(value(getString(bh))), eS, R)]
712712                 else nil
713713             let cC = eR[ak]
714714             let eT = eR[al]
715715             let fa = if ((eT > 0))
716716                 then [ScriptTransfer(y, eT, R)]
717717                 else nil
718718             let fb = eR[aq]
719719             let fc = if ((fb > 0))
720720                 then [ScriptTransfer(addressFromStringValue(value(getString(do))), fb, R)]
721721                 else nil
722722             let cT = eR[an]
723723             let eU = ez(P)
724724             let eV = (cT + eR[as])
725725             let fd = eR[ap]
726726             $Tuple2(((([Reissue(R, fd, true), IntegerEntry(bt, (eR[ae] + fd)), IntegerEntry(dx, eR[at]), IntegerEntry(eU, (valueOrElse(getInteger(eU), 0) + cT)), IntegerEntry(ey, (valueOrElse(getInteger(ey), 0) + cT)), IntegerEntry(bm, (eR[am] - cT)), IntegerEntry(bj, ((cw - eS) + eR[ar])), IntegerEntry(bi, cs), IntegerEntry(bl, (cC - eT)), IntegerEntry(bk, cs), IntegerEntry(eY, eW)] ++ eZ) ++ fa) ++ fc), eV)
727727             }
728728     }
729729 
730730 
731731 func fe (P,ff) = {
732732     let cs = lastBlock.timestamp
733733     let fg = bz(P)
734734     let fh = bx(P)
735735     let eC = valueOrElse(getInteger(fg), 0)
736736     let fi = valueOrElse(getInteger(fh), 0)
737737     let fj = valueOrElse(getInteger(by), 0)
738738     let aR = fraction(fraction(aP, fi, aM), (eC - cs), bd)
739739     $Tuple3([IntegerEntry(fg, cs), IntegerEntry(fh, (fi + ff)), IntegerEntry(by, (fj + ff))], aR, fi)
740740     }
741741 
742742 
743743 func fk (P) = {
744744     let U = (height / i)
745745     let fl = (U - 1)
746746     let fm = valueOrElse(getInteger(X(fl)), dJ)
747747     let fn = valueOrElse(getInteger(Y(fl)), 0)
748748     let fo = valueOrElse(getInteger(T(P, fl)), 0)
749749     if ((0 >= fo))
750750         then $Tuple2(nil, unit)
751751         else {
752752             let fp = valueOrElse(getInteger(V(fl)), 0)
753753             if ((0 >= fp))
754754                 then $Tuple2([DeleteEntry(T(P, fl))], unit)
755755                 else {
756756                     let aG = value(value(blockInfoByHeight((U * i))).vrf)
757757                     let aF = fromBase58String(split(valueOrElse(getString(K, O(P)), "42_DEFAULT"), "_")[1])
758758                     let fq = aD(fp, aF, aG)
759759                     if (((fo * fm) > fq))
760760                         then {
761761                             let fr = invoke(K, "issuePickC1", [P], nil)
762762                             let fs = getString(Z(fl))
763763                             let ft = if (isDefined(fs))
764764                                 then ((value(fs) + "_") + P)
765765                                 else P
766766                             $Tuple2([IntegerEntry(Y(fl), (fn + 1)), DeleteEntry(T(P, fl)), StringEntry(Z(fl), ft)], fr)
767767                             }
768768                         else {
769769                             let fu = (aD(9, (base58'29' + aF), aG) + 1)
770770                             let fv = fraction(fo, fu, 10)
771771                             let fw = T(P, U)
772772                             let fx = valueOrElse(getInteger(fw), 0)
773773                             $Tuple2(((if ((fv == 0))
774774                                 then nil
775775                                 else {
776776                                     let fy = [IntegerEntry(V(U), (valueOrElse(getInteger(V(U)), 0) + fv)), IntegerEntry(fw, (fx + fv))]
777777                                     if ((fx > 0))
778778                                         then fy
779779                                         else (fy :+ IntegerEntry(W(U), (valueOrElse(getInteger(W(U)), 0) + 1)))
780780                                     }) :+ DeleteEntry(T(P, fl))), fv)
781781                             }
782782                     }
783783             }
784784     }
785785 
786786 
787787 func fz (P,fA) = {
788788     let U = (height / i)
789789     let fw = T(P, U)
790790     let fB = split(fA, "_")
791791     let fC = valueOrElse(getInteger(V(U)), 0)
792792     let fx = valueOrElse(getInteger(fw), 0)
793793     let fD = if ((aa(parseIntValue(fB[0])) == parseIntValue(fB[1])))
794794         then 1
795795         else 0
796796     let fE = valueOrElse(getInteger(W(U)), 0)
797797     let fF = if (if ((fx == 0))
798798         then (fD == 1)
799799         else false)
800800         then [IntegerEntry(W(U), (fE + 1))]
801801         else nil
802802     $Tuple2(if ((fD == 0))
803803         then nil
804804         else ((fF :+ IntegerEntry(fw, (fx + fD))) :+ IntegerEntry(V(U), (fC + fD))), fD)
805805     }
806806 
807807 
808808 @Callable(fG)
809809 func constructorV1 (fH,fI,cy,fJ) = if ((fG.caller != this))
810810     then throw("Permission denied")
811811     else if (isDefined(getBinary(Q)))
812812         then throw("Already initialized")
813813         else {
814814             let cj = aY
815815             let fK = Issue("WLGOLD", "WavesLands Gold investment token", cj, 8, true, unit, 0)
816816             let fL = calculateAssetId(fK)
817817 [fK, IntegerEntry(bs, lastBlock.timestamp), IntegerEntry(bt, cj), IntegerEntry(ey, 0), IntegerEntry(bm, fraction(aY, bb, b)), BinaryEntry(Q, fL), StringEntry(x(), fH), StringEntry(do, fI), StringEntry(bh, cy), StringEntry(ex, fJ)]
818818             }
819819 
820820 
821821 
822822 @Callable(fG)
823823 func constructorV2 (fM) = if ((fG.caller != this))
824824     then throw("Permission denied")
825825     else [StringEntry(w(), fM)]
826826 
827827 
828828 
829829 @Callable(fG)
830830 func buyWlg (fN) = {
831831     let fO = eA()
832832     if ((fO == fO))
833833         then if ((size(fG.payments) != 1))
834834             then throw("exactly 1 payment must be attached")
835835             else {
836836                 let fP = fG.payments[0]
837837                 let fQ = fP.amount
838838                 if (if (!(isDefined(fP.assetId)))
839839                     then true
840840                     else (value(fP.assetId) != k))
841841                     then throw("USDT payments only!")
842842                     else {
843843                         let eP = fG.caller
844844                         let P = toString(eP)
845845                         if ((d > fQ))
846846                             then throw((("You can trade min " + ax(d, 6)) + " USDT"))
847847                             else {
848848                                 let eR = eg("", [J, K, L, M, N], k, fQ)
849849                                 let fR = eR[ae]
850850                                 let fS = eR[ag]
851851                                 let fT = fraction(fS, 6, 5, CEILING)
852852                                 let fU = fraction(fQ, c, fT)
853853                                 let fV = eB(P)
854854                                 if ((fU > fV))
855855                                     then throw((("You can get max " + ax(fV, 8)) + " WLGOLD at the moment"))
856856                                     else if ((fN > fU))
857857                                         then throw("Price changed during operation, please try again")
858858                                         else {
859859                                             let fW = (fQ / 6)
860860                                             $Tuple2([Reissue(R, fU, true), IntegerEntry(bt, (fR + fU)), IntegerEntry(bo(P), lastBlock.timestamp), IntegerEntry(bp(P), (fV - fU)), ScriptTransfer(addressFromStringValue(value(getString(ex))), fW, k), ScriptTransfer(eP, fU, R)], fO)
861861                                             }
862862                                 }
863863                         }
864864                 }
865865         else throw("Strict value is not equal to itself.")
866866     }
867867 
868868 
869869 
870870 @Callable(fG)
871871 func buyWlgREADONLY (p,fQ) = {
872872     let eR = eg("", [J, K, L, M, N], k, fQ)
873873     let fS = eR[ag]
874874     let fT = fraction(fS, 6, 5, CEILING)
875875     let fU = fraction(fQ, c, fT)
876876     let fV = eB(p)
877877     let fX = fraction(fV, fT, c)
878878     let fW = (fQ / 6)
879879     $Tuple2(nil, [fU, d, fX, fW])
880880     }
881881 
882882 
883883 
884884 @Callable(fG)
885885 func sellWlg (fY) = {
886886     let fO = eA()
887887     if ((fO == fO))
888888         then if ((size(fG.payments) != 1))
889889             then throw("exactly 1 payment must be attached")
890890             else {
891891                 let fP = fG.payments[0]
892892                 let fZ = fP.amount
893893                 let eP = fG.caller
894894                 let P = toString(eP)
895895                 let fV = eB(P)
896896                 if ((fZ > fV))
897897                     then throw((("You can spend max " + ax(fV, 8)) + " WLGOLD at the moment"))
898898                     else if (if (!(isDefined(fP.assetId)))
899899                         then true
900900                         else (value(fP.assetId) != R))
901901                         then throw("WLGOLD payments only!")
902902                         else {
903903                             let eR = eg("", [J, K, L, M, N], k, 0)
904904                             let fR = eR[ae]
905905                             let ga = (eR[ag] / 2)
906906                             let fQ = fraction(fZ, ga, c)
907907                             if ((d > fQ))
908908                                 then throw((("You can trade min " + ax(d, 6)) + " USDT"))
909909                                 else if ((fY > fQ))
910910                                     then throw("Price changed during operation, please try again")
911911                                     else {
912912                                         let fW = (fQ / 5)
913913                                         $Tuple2([Burn(R, fZ), IntegerEntry(bt, (fR - fZ)), IntegerEntry(bo(P), lastBlock.timestamp), IntegerEntry(bp(P), (fV - fZ)), ScriptTransfer(addressFromStringValue(value(getString(ex))), fW, k), ScriptTransfer(eP, fQ, k)], fO)
914914                                         }
915915                             }
916916                 }
917917         else throw("Strict value is not equal to itself.")
918918     }
919919 
920920 
921921 
922922 @Callable(fG)
923923 func sellWlgREADONLY (p,fZ) = {
924924     let fV = eB(p)
925925     let eR = eg("", [J, K, L, M, N], k, 0)
926926     let ga = (eR[ag] / 2)
927927     let fQ = fraction(fZ, ga, c)
928928     let gb = fraction(d, c, ga)
929929     let fW = (fQ / 5)
930930     $Tuple2(nil, [fQ, gb, fV, fW])
931931     }
932932 
933933 
934934 
935935 @Callable(fG)
936936 func claim () = {
937937     let fO = eA()
938938     if ((fO == fO))
939939         then if ((size(fG.payments) != 0))
940940             then throw("No payments required")
941941             else {
942942                 let gc = eX(toString(fG.caller))
943943                 let gd = gc._1
944944                 let ge = gc._2
945945                 $Tuple2((gd :+ ScriptTransfer(fG.caller, ge, R)), fO)
946946                 }
947947         else throw("Strict value is not equal to itself.")
948948     }
949949 
950950 
951951 
952952 @Callable(fG)
953953 func onStakeUnstakeLand (P,gf) = if (if (if ((fG.caller != H))
954954     then (fG.caller != I)
955955     else false)
956956     then (fG.caller != K)
957957     else false)
958958     then throw("Permission denied")
959959     else {
960960         let gg = if (gf)
961961             then eX(P)
962962             else eO(P)
963963         let gd = gg._1
964964         let ge = gg._2
965965         $Tuple2(if ((ge > 0))
966966             then (gd :+ ScriptTransfer(addressFromStringValue(P), ge, R))
967967             else gd, ge)
968968         }
969969 
970970 
971971 
972972 @Callable(fG)
973973 func burnWlgold (fZ) = if ((fG.caller != K))
974974     then throw("Permission denied")
975975     else {
976976         let eR = eg("", [J, K, L, M, N], k, 0)
977977         if ((fZ > eR[af]))
978978             then throw(((("Only " + ax(eR[af], 8)) + " WLGOLD left on contract, can't burn ") + ax(fZ, 8)))
979979             else {
980980                 let gh = (eR[ae] - fZ)
981981                 $Tuple2([Burn(R, fZ), IntegerEntry(bt, gh)], gh)
982982                 }
983983         }
984984 
985985 
986986 
987987 @Callable(fG)
988988 func betForTicket (gi) = {
989989     let fO = eA()
990990     if ((fO == fO))
991991         then if ((size(fG.payments) != 0))
992992             then throw("No payments required")
993993             else {
994994                 let P = toString(fG.caller)
995995                 let fl = ((height / i) - 1)
996996                 let fo = valueOrElse(getInteger(T(P, fl)), 0)
997997                 let fp = valueOrElse(getInteger(V(fl)), 0)
998998                 if (if ((fo > 0))
999999                     then (fp > 0)
10001000                     else false)
10011001                     then throw("Please open the chest first")
10021002                     else if (((gi / 4) != 0))
10031003                         then throw("Invalid bet: should be 0..3")
10041004                         else {
10051005                             let gj = (height % g)
10061006                             if ((gj > (g - 3)))
10071007                                 then throw((("Cannot bet: the day is almost ended, please wait " + toString((g - gj))) + " blocks"))
10081008                                 else {
10091009                                     let gk = valueOrElse(getInteger(K, dB(P)), 0)
10101010                                     if ((dK > gk))
10111011                                         then throw((("You need to stake at least " + ax(dK, 8)) + " ACRES to bet"))
10121012                                         else {
10131013                                             let gl = ((height / g) + 1)
10141014                                             let gm = S(P)
10151015                                             let gn = getString(gm)
10161016                                             let go = StringEntry(gm, ((toString(gl) + "_") + toString(gi)))
10171017                                             if (isDefined(gn))
10181018                                                 then {
10191019                                                     let gp = value(gn)
10201020                                                     if ((split(gp, "_")[0] == toString(gl)))
10211021                                                         then throw("You already bet for tomorrow")
10221022                                                         else {
10231023                                                             let gq = fz(P, gp)
10241024                                                             $Tuple2((gq._1 :+ go), gq._2)
10251025                                                             }
10261026                                                     }
10271027                                                 else $Tuple2([go], 0)
10281028                                             }
10291029                                     }
10301030                             }
10311031                 }
10321032         else throw("Strict value is not equal to itself.")
10331033     }
10341034 
10351035 
10361036 
10371037 @Callable(fG)
10381038 func takeWlgXp (P) = if ((fG.caller != H))
10391039     then throw("Permission denied")
10401040     else {
10411041         let gr = fe(P, 0)
10421042         let gd = gr._1
10431043         let aR = gr._2
10441044         $Tuple2(gd, aR)
10451045         }
10461046 
10471047 
10481048 
10491049 @Callable(fG)
10501050 func checkWlgXpREADONLY (P) = {
10511051     let gs = fe(P, 0)
10521052     let gt = gs._1
10531053     let gu = gs._2
10541054     let aU = (valueOrElse(getInteger(H, aN(P)), 0) + gu)
10551055     let gv = aS(valueOrElse(getInteger(H, aO(P)), 0), aU)
10561056     $Tuple2(nil, (gv :+ aU))
10571057     }
10581058 
10591059 
10601060 
10611061 @Callable(fG)
10621062 func setNumPrizes (fm) = if ((fG.caller != this))
10631063     then throw("Permission denied")
10641064     else {
10651065         let U = (height / i)
10661066         $Tuple2([IntegerEntry(X(U), fm)], fm)
10671067         }
10681068 
10691069 
10701070 
10711071 @Callable(fG)
10721072 func openChest () = {
10731073     let fO = eA()
10741074     if ((fO == fO))
10751075         then if ((size(fG.payments) != 0))
10761076             then throw("No payments required")
10771077             else {
10781078                 let fl = ((height / i) - 1)
10791079                 let P = toString(fG.caller)
10801080                 let fo = valueOrElse(getInteger(T(P, fl)), 0)
10811081                 if ((0 >= fo))
10821082                     then throw("No gems to open the chest")
10831083                     else fk(P)
10841084                 }
10851085         else throw("Strict value is not equal to itself.")
10861086     }
10871087 
10881088 
10891089 
10901090 @Callable(fG)
10911091 func addGemsFor (P,fD) = if ((fG.caller != this))
10921092     then throw("Permission denied")
10931093     else {
10941094         let U = (height / i)
10951095         let fw = T(P, U)
10961096         let fC = valueOrElse(getInteger(V(U)), 0)
10971097         let fx = valueOrElse(getInteger(fw), 0)
10981098         let fE = valueOrElse(getInteger(W(U)), 0)
10991099         let fF = if (if ((fx == 0))
11001100             then (fD == 1)
11011101             else false)
11021102             then [IntegerEntry(W(U), (fE + 1))]
11031103             else nil
11041104         $Tuple2(((fF :+ IntegerEntry(fw, (fx + fD))) :+ IntegerEntry(V(U), (fC + fD))), fD)
11051105         }
11061106 
11071107 
github/deemru/w8io/169f3d6 
583.00 ms ◑