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
365365 
366366 let idxUserAcres = 3
367367 
368-let OLD_STAKING_DEADL = 1733335200000
368+let OLD_STAKING_DEADL = 1733346000000
369369 
370370 func getWlgStats (userAddrOpt,contracts,usdtId,usdtBalanceCorrection,userProportion6) = {
371371     let issuedAmount = valueOrErrorMessage(getInteger(contracts[dappWlg], wlgIssuedAmountKey), "WLGOLD is not issued yet")

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "__"
55 
66 let MULT6 = 1000000
77 
88 let MULT8 = 100000000
99 
1010 let MINSHOPPAYMENT = 100000
1111 
1212 let DAY_MILLIS = 86400000
1313 
1414 let chain = take(drop(this.bytes, 1), 1)
1515 
1616 let DAY_BLOCKS = match chain {
1717     case _ => 
1818         if ((base58'2W' == $match0))
1919             then 1440
2020             else if ((base58'2T' == $match0))
2121                 then 60
2222                 else throw("Unknown chain")
2323 }
2424 
2525 let WEEK_BLOCKS = match chain {
2626     case _ => 
2727         if ((base58'2W' == $match0))
2828             then 10080
2929             else if ((base58'2T' == $match0))
3030                 then 180
3131                 else throw("Unknown chain")
3232 }
3333 
3434 let VRF_OFFSET = match chain {
3535     case _ => 
3636         if ((base58'2W' == $match0))
3737             then 0
3838             else if ((base58'2T' == $match0))
3939                 then 1146000
4040                 else throw("Unknown chain")
4141 }
4242 
4343 let usdtAssetId = match chain {
4444     case _ => 
4545         if ((base58'2W' == $match0))
4646             then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
4747             else if ((base58'2T' == $match0))
4848                 then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
4949                 else throw("Unknown chain")
5050 }
5151 
5252 let defaultRest2AddressStr = match chain {
5353     case _ => 
5454         if ((base58'2W' == $match0))
5555             then "3PFwYta8biEz31zpeFe5DJK8wE5trSpQVF8"
5656             else if ((base58'2T' == $match0))
5757                 then "3N7UuYar6264P58FBhVWKPQAh4Yua2hgngv"
5858                 else throw("Unknown chain")
5959 }
6060 
6161 let defaultRestAddressStr = match chain {
6262     case _ => 
6363         if ((base58'2W' == $match0))
6464             then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
6565             else if ((base58'2T' == $match0))
6666                 then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
6767                 else throw("Unknown chain")
6868 }
6969 
7070 let economyContractStr = match chain {
7171     case _ => 
7272         if ((base58'2W' == $match0))
7373             then "3P2sk1KncSxRaZs8b4CWGPw2jkvvav74u4D"
7474             else if ((base58'2T' == $match0))
7575                 then "3N8y4wxX3JC4TdrCJBXX16SjWf6X256hrep"
7676                 else throw("Unknown chain")
7777 }
7878 
7979 func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
8080 
8181 
8282 let IdxCfgAcres2Dapp = 1
8383 
8484 let IdxCfgWlgDapp = 2
8585 
8686 let IdxCfgPuzzlePoolDapp = 4
8787 
8888 let IdxCfgInvestFundDapp = 5
8989 
9090 func keyRestCfg () = "%s__restConfig"
9191 
9292 
9393 func keyRest2Address () = "%s__rest2Addr"
9494 
9595 
9696 func keyRestAddress () = "%s__restAddr"
9797 
9898 
9999 let restContract = addressFromStringValue(valueOrElse(getString(this, keyRestAddress()), defaultRestAddressStr))
100100 
101101 func readRestCfgOrFail (rest) = split_4C(getStringOrFail(rest, keyRestCfg()), SEP)
102102 
103103 
104104 func getContractAddressOrFail (rest2Cfg,idx) = valueOrErrorMessage(addressFromString(rest2Cfg[idx]), ("Rest cfg doesn't contain address at index " + toString(idx)))
105105 
106106 
107107 let IdxCfgStakingDapp = 1
108108 
109109 let IdxCfgAcresDapp = 8
110110 
111111 let restCfg = readRestCfgOrFail(restContract)
112112 
113113 let stakingContract = getContractAddressOrFail(restCfg, IdxCfgStakingDapp)
114114 
115115 let acresContract = getContractAddressOrFail(restCfg, IdxCfgAcresDapp)
116116 
117117 let rest2Contract = addressFromStringValue(valueOrElse(getString(this, keyRest2Address()), defaultRest2AddressStr))
118118 
119119 let rest2Cfg = readRestCfgOrFail(rest2Contract)
120120 
121121 let acres2Contract = getContractAddressOrFail(rest2Cfg, IdxCfgAcres2Dapp)
122122 
123123 let wlgContract = getContractAddressOrFail(rest2Cfg, IdxCfgWlgDapp)
124124 
125125 let puzzlePoolContract = getContractAddressOrFail(rest2Cfg, IdxCfgPuzzlePoolDapp)
126126 
127127 let investFundContract = getContractAddressOrFail(rest2Cfg, IdxCfgInvestFundDapp)
128128 
129129 func keyLastWeekTxIdByUser (addr) = ("lastWeekTxIdByUser_" + addr)
130130 
131131 
132132 let wlgAssetIdKey = "wlg_assetId"
133133 
134134 let wlgAssetId = valueOrErrorMessage(getBinary(wlgContract, wlgAssetIdKey), "WLGOLD is not issued yet")
135135 
136136 func keyUserBet (addr) = ("userBet_" + addr)
137137 
138138 
139139 func keyUserWeekTickets (addr,week) = ((("userWeekTickets_" + addr) + "_") + toString(week))
140140 
141141 
142142 func keyTotalWeekTickets (week) = ("totalWeekTickets_" + toString(week))
143143 
144144 
145145 func keyTotalWeekParticipants (week) = ("totalWeekParticipants_" + toString(week))
146146 
147147 
148148 func keyNumNFT2Draw (week) = ("numNFT2Draw_" + toString(week))
149149 
150150 
151151 func keyNumNFTDrawn (week) = ("numNFTDrawn_" + toString(week))
152152 
153153 
154154 func keyWeekWinners (week) = ("weekWinners_" + toString(week))
155155 
156156 
157157 func winningBet (day) = {
158158     let b = (day * DAY_BLOCKS)
159159     let h = if ((b > VRF_OFFSET))
160160         then b
161161         else (b + VRF_OFFSET)
162162     (toInt(value(value(blockInfoByHeight(h)).vrf)) % 4)
163163     }
164164 
165165 
166166 let ixWlgAmount = 0
167167 
168168 let ixWlgWlg = 1
169169 
170170 let ixWlgPrice = 2
171171 
172172 let ixWlgIssueTime = 8
173173 
174174 let ixWlgTeamAmLeft = 11
175175 
176176 let ixWlgTeamAmAvailNow = 12
177177 
178178 let ixWlgActAmLeft = 15
179179 
180180 let ixWlgActAmAvailNow = 16
181181 
182182 let ixWlgAmLeftTotal = 19
183183 
184184 let ixWlgUserAmAvailNow = 23
185185 
186186 let ixWlgEffUserTime = 24
187187 
188188 let ixWlgIssue10Amount = 25
189189 
190190 let ixWlgMarketingIssue10Amount = 26
191191 
192192 let ixWlgTeamIssue10Amount = 27
193193 
194194 let ixWlgUser10part = 28
195195 
196196 let ixWlgIssue10Time = 29
197197 
198198 func asInt (v) = match v {
199199     case n: Int => 
200200         n
201201     case _ => 
202202         throw("fail to cast into Int")
203203 }
204204 
205205 
206206 func fixedPoint (val,decimals) = {
207207     let tenPow = pow(10, 0, decimals, 0, 0, DOWN)
208208     let lowPart = toString((val % tenPow))
209209     let zeroes = drop(toString(tenPow), (1 + size(lowPart)))
210210     (((toString((val / tenPow)) + ".") + zeroes) + lowPart)
211211     }
212212 
213213 
214214 func getRandomNumber (maxValue,salt,entropy) = if ((0 >= maxValue))
215215     then throw("maxValue should be > 0")
216216     else {
217217         let randomHash = sha256_16Kb((salt + entropy))
218218         (toInt(randomHash) % maxValue)
219219         }
220220 
221221 
222222 let SCALE8 = 100000000
223223 
224224 let xpLevelScale = 3200
225225 
226226 let xpLevelRecipPow = 4000
227227 
228228 let numPointsOnLevelUp = 3
229229 
230230 let wlgBaseAmountXp = 100000000000
231231 
232232 func keyUserXP (addr) = ("userXP_" + addr)
233233 
234234 
235235 func keyUserLevel (addr) = ("userLevel_" + addr)
236236 
237237 
238238 let xpWlg = 10000
239239 
240240 func levelByXP (xp) = fraction(xpLevelScale, pow(xp, 4, xpLevelRecipPow, 4, 4, DOWN), SCALE8)
241241 
242242 
243243 func levelUp (currLevel,newXP) = {
244244     let newLevel = levelByXP(newXP)
245245 [newLevel, (numPointsOnLevelUp * (newLevel - currLevel))]
246246     }
247247 
248248 
249249 let M6 = 1000000
250250 
251251 let M8 = 100000000
252252 
253253 let MILLION6 = 100000000000000
254254 
255255 let TEAMSHARE = 200000
256256 
257257 let ACTIVITYSHARE = 100000
258258 
259259 let PLAYERSHARE = 400000
260260 
261261 let YEARMILLIS = 31557600000
262262 
263263 let DAYMILLIS = 86400000
264264 
265265 let BANK_FEE = 50000
266266 
267267 let ch = take(drop(this.bytes, 1), 1)
268268 
269269 let USDT_TVL_CORRECTION = match ch {
270270     case _ => 
271271         if ((base58'2W' == $match0))
272272             then 1208630000
273273             else if ((base58'2T' == $match0))
274274                 then 0
275275                 else throw("Unknown chain")
276276 }
277277 
278278 let teamAddrKey = "teamAddr"
279279 
280280 let lastTeamTimeKey = "lastClaimedTime_team"
281281 
282282 let teamAmountLeftKey = "teamAmountLeft"
283283 
284284 let lastActivitiesTimeKey = "lastClaimedTime_activities"
285285 
286286 let actAmountLeftKey = "activitiesAmountLeft"
287287 
288288 let stakersAmountLeftKey = "stakersAmountLeft"
289289 
290290 func keyLastClaimedTimeByUserOld (addr) = ("lastClaimedTimeUserOld_" + addr)
291291 
292292 
293293 func keyLastWlgTradeTimeByUser (addr) = ("lastArbTimeUser_" + addr)
294294 
295295 
296296 func keyLastWlgTradeLimitByUser (addr) = ("lastWlgLimitUser_" + addr)
297297 
298298 
299299 func distributionByPeriod (period) = fraction(MILLION6, (PLAYERSHARE * (period + 1)), (6 * M6))
300300 
301301 
302302 let wlgIssueTimeKey = "wlg_issueTime"
303303 
304304 let wlgIssuedAmountKey = "wlg_issuedAmount"
305305 
306306 let zbIssuedAmountKey = "zbill_issuedAmount"
307307 
308308 func keyAcresStakedAmountByUser (addr) = ("acresStakedAmountByUser_" + addr)
309309 
310310 
311311 let acresStakedTotalKey = "acresStakedAmountTotal"
312312 
313313 func keyWlgStakedAmountByUser (addr) = ("wlgStakedAmountByUser_" + addr)
314314 
315315 
316316 let wlgStakedTotalKey = "wlgStakedAmountTotal"
317317 
318318 func keyWlgStakedTimeByUser (addr) = ("wlgStakedTimeByUser_" + addr)
319319 
320320 
321321 let dappRest = 0
322322 
323323 let dappStaking = 1
324324 
325325 let dappEconomy = 2
326326 
327327 let dappWlg = 3
328328 
329329 let dappPuzzle = 4
330330 
331331 let dappInvestFund = 5
332332 
333333 let dappAcres = 6
334334 
335335 func getLands (userAddrStrOrEmpty,stakingContract,acresContract) = {
336336     let props = split(valueOrElse(getString(stakingContract, "resTypesProportions"), "0_0_0_0_0_0"), "_")
337337     func adder (acc,item) =     (acc + parseIntValue(item))
338338 
339339     let totalPieces = {
340340         let $l = props
341341         let $s = size($l)
342342         let $acc0 = 0
343343         func $f0_1 ($a,$i) =         if (($i >= $s))
344344             then $a
345345             else adder($a, $l[$i])
346346 
347347         func $f0_2 ($a,$i) =         if (($i >= $s))
348348             then $a
349349             else throw("List size exceeds 6")
350350 
351351         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
352352         }
353353     let userPieces = valueOrElse(getInteger(stakingContract, ("stakedPiecesByOwner_" + userAddrStrOrEmpty)), 0)
354354     let totalAcres = valueOrElse(getInteger(acresContract, acresStakedTotalKey), 0)
355355     let userAcres = valueOrElse(getInteger(acresContract, keyAcresStakedAmountByUser(userAddrStrOrEmpty)), 0)
356356 [totalPieces, userPieces, totalAcres, userAcres]
357357     }
358358 
359359 
360360 let idxTotalPieces = 0
361361 
362362 let idxUserPieces = 1
363363 
364364 let idxTotalAcres = 2
365365 
366366 let idxUserAcres = 3
367367 
368-let OLD_STAKING_DEADL = 1733335200000
368+let OLD_STAKING_DEADL = 1733346000000
369369 
370370 func getWlgStats (userAddrOpt,contracts,usdtId,usdtBalanceCorrection,userProportion6) = {
371371     let issuedAmount = valueOrErrorMessage(getInteger(contracts[dappWlg], wlgIssuedAmountKey), "WLGOLD is not issued yet")
372372     let economyUsd = assetBalance(contracts[dappEconomy], usdtId)
373373     let restUsd = assetBalance(contracts[dappRest], usdtId)
374374     let wlgUsd = (assetBalance(contracts[dappWlg], usdtId) - usdtBalanceCorrection)
375375     let puzzleUsd = assetBalance(contracts[dappPuzzle], usdtId)
376376     let investFndContract = contracts[dappInvestFund]
377377     let investFundTotal = (assetBalance(investFndContract, usdtId) + valueOrElse(getInteger(investFndContract, zbIssuedAmountKey), 0))
378378     let totalFundsUsd = ((economyUsd + wlgUsd) + investFundTotal)
379379     let wlgId = valueOrErrorMessage(getBinary(contracts[dappWlg], "wlg_assetId"), "Not initialized yet")
380380     let now = lastBlock.timestamp
381381     let issueTime = valueOrErrorMessage(getInteger(contracts[dappWlg], wlgIssueTimeKey), "Not initialized")
382382     let bankWlgold = assetBalance(contracts[dappStaking], wlgId)
383383     let teamTotal = fraction(MILLION6, TEAMSHARE, M6)
384384     let teamAmountLeft = valueOrElse(getInteger(contracts[dappWlg], teamAmountLeftKey), teamTotal)
385385     let lastTeamTime = valueOrElse(getInteger(contracts[dappWlg], lastTeamTimeKey), issueTime)
386386     let teamAddr = addressFromStringValue(value(getString(contracts[dappWlg], teamAddrKey)))
387387     let teamAmountAvailableNow = min([fraction(teamTotal, (now - lastTeamTime), (3 * YEARMILLIS)), teamAmountLeft])
388388     let teamWlgold = assetBalance(teamAddr, wlgId)
389389     let actTotal = fraction(MILLION6, ACTIVITYSHARE, M6)
390390     let actAmountLeft = valueOrElse(getInteger(contracts[dappWlg], actAmountLeftKey), actTotal)
391391     let lastActivitiesTime = valueOrElse(getInteger(contracts[dappWlg], lastActivitiesTimeKey), issueTime)
392392     let actAmountAvailableNow = min([fraction(actTotal, (now - lastActivitiesTime), (3 * YEARMILLIS)), actAmountLeft])
393393     let actWlgold = assetBalance(contracts[dappRest], wlgId)
394394     let lastUserTime = valueOrElse(getInteger(contracts[dappWlg], keyLastClaimedTimeByUserOld(userAddrOpt)), issueTime)
395395     let lastUserPeriod = ((lastUserTime - issueTime) / YEARMILLIS)
396396     let nowLimited = min([min([now, (issueTime + (3 * YEARMILLIS))]), OLD_STAKING_DEADL])
397397     let curPeriod = min([((now - issueTime) / YEARMILLIS), 2])
398398     let eff = getLands(userAddrOpt, contracts[dappStaking], contracts[dappAcres])
399399     let curPeriodDistribution = distributionByPeriod(curPeriod)
400400     let $t079143 = if ((lastUserPeriod == curPeriod))
401401         then {
402402             let a0 = fraction(curPeriodDistribution, (nowLimited - lastUserTime), YEARMILLIS)
403403             let userPart = fraction(a0, userProportion6, M6)
404404             let effTime = (lastUserTime + fraction((nowLimited - lastUserTime), userProportion6, M6))
405405             $Tuple3(userPart, a0, effTime)
406406             }
407407         else if ((lastUserPeriod == (curPeriod - 1)))
408408             then {
409409                 let a1 = fraction(distributionByPeriod((curPeriod - 1)), ((issueTime + (YEARMILLIS * curPeriod)) - lastUserTime), YEARMILLIS)
410410                 let a0 = fraction(curPeriodDistribution, (nowLimited - (issueTime + (YEARMILLIS * curPeriod))), YEARMILLIS)
411411                 let avail = (a1 + a0)
412412                 let userPart = fraction(avail, userProportion6, M6)
413413                 let effTime = if ((a1 >= userPart))
414414                     then (lastUserTime + fraction(YEARMILLIS, userPart, distributionByPeriod((curPeriod - 1))))
415415                     else ((issueTime + (YEARMILLIS * curPeriod)) + fraction(YEARMILLIS, (userPart - a1), curPeriodDistribution))
416416                 $Tuple3(userPart, avail, effTime)
417417                 }
418418             else {
419419                 let a2 = fraction(distributionByPeriod((curPeriod - 2)), ((issueTime + (YEARMILLIS * (curPeriod - 1))) - lastUserTime), YEARMILLIS)
420420                 let a1 = distributionByPeriod((curPeriod - 1))
421421                 let a0 = fraction(curPeriodDistribution, (nowLimited - (issueTime + (YEARMILLIS * curPeriod))), YEARMILLIS)
422422                 let avail = ((a2 + a1) + a0)
423423                 let userPart = fraction(avail, userProportion6, M6)
424424                 let effTime = if ((a2 >= userPart))
425425                     then (lastUserTime + fraction(YEARMILLIS, userPart, distributionByPeriod((curPeriod - 2))))
426426                     else if (((a2 + a1) >= userPart))
427427                         then ((issueTime + (YEARMILLIS * (curPeriod - 1))) + fraction(YEARMILLIS, (userPart - a2), distributionByPeriod((curPeriod - 1))))
428428                         else ((issueTime + (YEARMILLIS * curPeriod)) + fraction(YEARMILLIS, ((userPart - a2) - a1), curPeriodDistribution))
429429                 $Tuple3(userPart, avail, effTime)
430430                 }
431431     let userAmount = $t079143._1
432432     let userAvailable = $t079143._2
433433     let effLastTime = $t079143._3
434434     let sLandDailyAmount = fraction(fraction(curPeriodDistribution, DAYMILLIS, YEARMILLIS), 25, eff[idxTotalPieces])
435435     let amountLeftTotal = valueOrElse(getInteger(contracts[dappWlg], stakersAmountLeftKey), 0)
436436     let userTemp = fraction(userAmount, ((eff[idxUserPieces] * M8) + eff[idxUserAcres]), ((eff[idxTotalPieces] * M8) + eff[idxTotalAcres]))
437437     let bankFromUser = fraction(userTemp, BANK_FEE, M6)
438438     let robbedUser = (userTemp - bankFromUser)
439439     let unrobbedUser = fraction(userAvailable, ((eff[idxUserPieces] * M8) + eff[idxUserAcres]), ((eff[idxTotalPieces] * M8) + eff[idxTotalAcres]))
440440 [issuedAmount, fraction((totalFundsUsd - USDT_TVL_CORRECTION), M8, issuedAmount), totalFundsUsd, economyUsd, restUsd, wlgUsd, puzzleUsd, issueTime, lastTeamTime, teamTotal, teamAmountLeft, teamAmountAvailableNow, teamWlgold, actTotal, actAmountLeft, actAmountAvailableNow, actWlgold, curPeriod, amountLeftTotal, curPeriodDistribution, lastUserTime, robbedUser, sLandDailyAmount, investFundTotal, unrobbedUser, effLastTime, bankWlgold]
441441     }
442442 
443443 
444444 let M6_ = 1000000
445445 
446446 let M8_ = 100000000
447447 
448448 let TEAM_SHARE = 200000
449449 
450450 let ACTIVITY_SHARE = 100000
451451 
452452 let PLAYER_SHARE = 400000
453453 
454454 let YEAR_MILLIS = 31557600000
455455 
456456 let DAY_MS = 86400000
457457 
458458 let ISSUE10 = 1000000000
459459 
460460 let PLAYERS10_SHARE = 800000
461461 
462462 let MARKETING10_SHARE = 100000
463463 
464464 let TEAM10_SHARE = 100000
465465 
466466 let NEW_STAKING_START = 1731279600000
467467 
468468 let marketingAddrKey = "marketingAddr"
469469 
470470 let teamAdrKey = "teamAddr"
471471 
472472 let lastTeamTimKey = "lastClaimedTime_team"
473473 
474474 let teamAmtLeftKey = "teamAmountLeft"
475475 
476476 let lastActivitiesTimKey = "lastClaimedTime_activities"
477477 
478478 let actAmtLeftKey = "activitiesAmountLeft"
479479 
480480 let stakersAmtLeftKey = "stakersAmountLeft"
481481 
482482 func keyLastClaimTimeByUser (addr) = ("lastClaimedTimeUser_" + addr)
483483 
484484 
485485 func distrByPeriod (issuedAmount,period) = fraction(issuedAmount, (PLAYER_SHARE * (period + 1)), (6 * M6_))
486486 
487487 
488488 let wlgIssue10TimeKey = "wlg_issue10Time"
489489 
490490 let wlgIssueTimKey = "wlg_issueTime"
491491 
492492 let wlgIssuedAmtKey = "wlg_issuedAmount"
493493 
494494 let zbIssuedAmtKey = "zbill_issuedAmount"
495495 
496496 func keyAcresStakedAmtByUser (addr) = ("acresStakedAmountByUser_" + addr)
497497 
498498 
499499 let acresStakdTotalKey = "acresStakedAmountTotal"
500500 
501501 let totalFarmingPowerKey = "totalFarmingPower"
502502 
503503 let dapp2Rest = 0
504504 
505505 let dapp2Staking = 1
506506 
507507 let dapp2Wlg = 2
508508 
509509 let dapp2Puzzle = 3
510510 
511511 let dapp2InvestFund = 4
512512 
513513 let DEFAULT_WEEKLY_PRIZES = 5
514514 
515515 let ACRES_FOR_BET = 100000000
516516 
517517 let keyNftTotalIssued = "nftTotalIssued"
518518 
519519 let keyNftTotalBurned = "nftTotalBurned"
520520 
521521 let keyWlNftTotalStaked = "WlNftTotalStaked"
522522 
523523 func keyUserWlNftNumber (addr) = ("userWlNftNumber_" + addr)
524524 
525525 
526526 func keyUserFullBonus (addr) = ("userFullBonus_" + addr)
527527 
528528 
529529 let levelAcres = [0, 10, 20, 40, 80, 150, 250, 400, 700, 1000]
530530 
531531 func getLevelByAcres (acres) = {
532532     let acr = ((acres + 99999999) / M8_)
533533     func checker (acc,item) =     if ((item >= acr))
534534         then acc
535535         else (acc + 1)
536536 
537537     let $l = levelAcres
538538     let $s = size($l)
539539     let $acc0 = 0
540540     func $f0_1 ($a,$i) =     if (($i >= $s))
541541         then $a
542542         else checker($a, $l[$i])
543543 
544544     func $f0_2 ($a,$i) =     if (($i >= $s))
545545         then $a
546546         else throw("List size exceeds 10")
547547 
548548     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
549549     }
550550 
551551 
552552 func getFarmingPowerByAcres (acres) = ((acres * 20) * (getLevelByAcres(acres) + 4))
553553 
554554 
555555 func getFarmingPowerByAcresAndBonus (acres,bonus6) = {
556556     let notBonused = getFarmingPowerByAcres(acres)
557557     $Tuple2(fraction(notBonused, (M6_ + bonus6), M6_), notBonused)
558558     }
559559 
560560 
561561 func getFarmingPowers (userAddrStrOrEmpty,acres2Contract) = {
562562     let totalFP = valueOrElse(getInteger(acres2Contract, totalFarmingPowerKey), 0)
563563     let userAcres = valueOrElse(getInteger(acres2Contract, keyAcresStakedAmtByUser(userAddrStrOrEmpty)), 0)
564564     let userBonus = valueOrElse(getInteger(acres2Contract, keyUserFullBonus(userAddrStrOrEmpty)), 0)
565565     let $t079143 = getFarmingPowerByAcresAndBonus(userAcres, userBonus)
566566     let userFPbonused = $t079143._1
567567     let userFPnotBonused = $t079143._2
568568 [totalFP, userFPbonused, userFPnotBonused, userBonus]
569569     }
570570 
571571 
572572 let idxTotalFP = 0
573573 
574574 let idxUserFPbonused = 1
575575 
576576 func getWlgStats2 (userAddrOpt,contracts,usdtId,usdtBalanceCorrection) = {
577577     let issuedAmount = valueOrErrorMessage(getInteger(contracts[dapp2Wlg], wlgIssuedAmtKey), "WLGOLD is not issued yet")
578578     let restUsd = assetBalance(contracts[dapp2Rest], usdtId)
579579     let wlgUsd = (assetBalance(contracts[dapp2Wlg], usdtId) - usdtBalanceCorrection)
580580     let puzzleUsd = assetBalance(contracts[dapp2Puzzle], usdtId)
581581     let acres2Usd = assetBalance(contracts[dapp2Staking], usdtId)
582582     let investFndContract = contracts[dapp2InvestFund]
583583     let investFundTotal = (assetBalance(investFndContract, usdtId) + valueOrElse(getInteger(investFndContract, zbIssuedAmtKey), 0))
584584     let totalFundsUsd = ((acres2Usd + wlgUsd) + investFundTotal)
585585     let wlgId = valueOrErrorMessage(getBinary(contracts[dapp2Wlg], "wlg_assetId"), "Not initialized yet")
586586     let now = lastBlock.timestamp
587587     let issueTime = valueOrErrorMessage(getInteger(contracts[dapp2Wlg], wlgIssueTimKey), "Not initialized")
588588     let wlgWlg = assetBalance(contracts[dapp2Wlg], wlgId)
589589     let teamTotal = fraction(issuedAmount, TEAM_SHARE, M6_)
590590     let teamAmountLeft = valueOrElse(getInteger(contracts[dapp2Wlg], teamAmtLeftKey), teamTotal)
591591     let lastTeamTime = valueOrElse(getInteger(contracts[dapp2Wlg], lastTeamTimKey), issueTime)
592592     let teamAddr = addressFromStringValue(value(getString(contracts[dapp2Wlg], teamAdrKey)))
593593     let teamAmountAvailableNow = min([fraction(teamTotal, (now - lastTeamTime), (3 * YEAR_MILLIS)), teamAmountLeft])
594594     let teamWlgold = assetBalance(teamAddr, wlgId)
595595     let actTotal = fraction(issuedAmount, ACTIVITY_SHARE, M6_)
596596     let actAmountLeft = valueOrElse(getInteger(contracts[dapp2Wlg], actAmtLeftKey), actTotal)
597597     let lastActivitiesTime = valueOrElse(getInteger(contracts[dapp2Wlg], lastActivitiesTimKey), issueTime)
598598     let actAmountAvailableNow = min([fraction(actTotal, (now - lastActivitiesTime), (3 * YEAR_MILLIS)), actAmountLeft])
599599     let actWlgold = assetBalance(contracts[dapp2Rest], wlgId)
600600     let lastUserTime = valueOrElse(getInteger(contracts[dapp2Wlg], keyLastClaimTimeByUser(userAddrOpt)), issueTime)
601601     let lastUserPeriod = ((lastUserTime - issueTime) / YEAR_MILLIS)
602602     let nowLimited = min([now, (issueTime + (3 * YEAR_MILLIS))])
603603     let curPeriod = min([((now - issueTime) / YEAR_MILLIS), 2])
604604     let eff = getFarmingPowers(userAddrOpt, contracts[dapp2Staking])
605605     let curPeriodDistribution = distrByPeriod(issuedAmount, curPeriod)
606606     let prevPeriodEnd = (issueTime + (YEAR_MILLIS * curPeriod))
607607     let prevPrevPeriodEnd = (issueTime + (YEAR_MILLIS * (curPeriod - 1)))
608608     let a0 = fraction(curPeriodDistribution, (nowLimited - lastUserTime), YEAR_MILLIS)
609609     let userAvailable = if ((lastUserPeriod == curPeriod))
610610         then a0
611611         else if ((lastUserPeriod == (curPeriod - 1)))
612612             then {
613613                 let a1 = fraction(distrByPeriod(issuedAmount, (curPeriod - 1)), (prevPeriodEnd - lastUserTime), YEAR_MILLIS)
614614                 (a1 + a0)
615615                 }
616616             else {
617617                 let a2 = fraction(distrByPeriod(issuedAmount, (curPeriod - 2)), (prevPrevPeriodEnd - lastUserTime), YEAR_MILLIS)
618618                 let a1 = distrByPeriod(issuedAmount, (curPeriod - 1))
619619                 ((a2 + a1) + a0)
620620                 }
621621     let amountLeftTotal = valueOrElse(getInteger(contracts[dapp2Wlg], stakersAmtLeftKey), 0)
622622     let userAmount = if ((eff[idxTotalFP] != 0))
623623         then fraction(userAvailable, eff[idxUserFPbonused], eff[idxTotalFP])
624624         else 0
625625     let lastIssue10Time = valueOrElse(getInteger(contracts[dapp2Wlg], wlgIssue10TimeKey), NEW_STAKING_START)
626626     let issue10Amount = fraction(ISSUE10, max([(now - lastIssue10Time), 0]), DAY_MS)
627627     let marketingIssue10Amount = fraction(issue10Amount, MARKETING10_SHARE, M6_)
628628     let teamIssue10Amount = fraction(issue10Amount, TEAM10_SHARE, M6_)
629629     let user10Interval = max([(now - max([NEW_STAKING_START, lastUserTime])), 0])
630630     let user10part = if ((eff[idxTotalFP] != 0))
631631         then fraction(fraction(fraction(ISSUE10, user10Interval, DAY_MS), eff[idxUserFPbonused], eff[idxTotalFP]), PLAYERS10_SHARE, M6_)
632632         else 0
633633     let newIssue10Time = max([NEW_STAKING_START, now])
634634     let acresStakedTotal = valueOrElse(getInteger(contracts[dapp2Staking], acresStakdTotalKey), 0)
635635     let nftTotalIssued = valueOrElse(getInteger(contracts[dapp2Staking], keyNftTotalIssued), 0)
636636     let nftTotalBurned = valueOrElse(getInteger(contracts[dapp2Staking], keyNftTotalBurned), 0)
637637     let wlNftTotalStaked = valueOrElse(getInteger(contracts[dapp2Staking], keyWlNftTotalStaked), 0)
638638     let wlNftUserStaked = valueOrElse(getInteger(contracts[dapp2Staking], keyUserWlNftNumber(valueOrElse(userAddrOpt, ""))), 0)
639639 [issuedAmount, wlgWlg, fraction(totalFundsUsd, M8_, issuedAmount), totalFundsUsd, restUsd, acres2Usd, wlgUsd, puzzleUsd, issueTime, lastTeamTime, teamTotal, teamAmountLeft, teamAmountAvailableNow, teamWlgold, actTotal, actAmountLeft, actAmountAvailableNow, actWlgold, curPeriod, amountLeftTotal, curPeriodDistribution, lastUserTime, investFundTotal, userAmount, nowLimited, issue10Amount, marketingIssue10Amount, teamIssue10Amount, user10part, newIssue10Time, eff[idxTotalFP], acresStakedTotal, nftTotalIssued, nftTotalBurned, wlNftTotalStaked, wlNftUserStaked]
640640     }
641641 
642642 
643643 let profitAddrKey = "profitAddr"
644644 
645645 let stakersAmountPaidTotalKey = "stakersAmountPaidTotal"
646646 
647647 func keyStakersAmountPaidUser (addr) = ("stakersAmountPaidUser_" + addr)
648648 
649649 
650650 func prolog2 () = asInt(reentrantInvoke(acres2Contract, "saveLastTx", nil, nil))
651651 
652652 
653653 func getSwapLimitWlgold (addr) = {
654654     let lastTime = valueOrElse(getInteger(keyLastWlgTradeTimeByUser(addr)), 0)
655655     let defaultLimit = valueOrElse(getInteger(acres2Contract, keyAcresStakedAmountByUser(addr)), 0)
656656     let lastLimitLeft = valueOrElse(getInteger(keyLastWlgTradeLimitByUser(addr)), defaultLimit)
657657     let currentLimit = (lastLimitLeft + fraction(defaultLimit, (lastBlock.timestamp - lastTime), DAY_MILLIS))
658658     min([currentLimit, defaultLimit])
659659     }
660660 
661661 
662662 let idxWlgTeamAmLeft = 10
663663 
664664 let idxWlgTeamAmAvailNow = 11
665665 
666666 let idxWlgActAmLeft = 14
667667 
668668 let idxWlgActAmAvailNow = 15
669669 
670670 let idxWlgAmLeftTotal = 18
671671 
672672 let idxWlgUserAmAvailNow = 21
673673 
674674 let idxWlgUserTotalAvail = 24
675675 
676676 let idxWlgEffUserTime = 25
677677 
678678 func claimInternal (addr) = {
679679     let caller = addressFromStringValue(addr)
680680     let economyContract = addressFromStringValue(economyContractStr)
681681     let curStats = getWlgStats(addr, [restContract, stakingContract, economyContract, wlgContract, puzzlePoolContract, investFundContract, acresContract], usdtAssetId, 0, MULT6)
682682     let now = lastBlock.timestamp
683683     let teamAmountLeft = curStats[idxWlgTeamAmLeft]
684684     let teamAmount = curStats[idxWlgTeamAmAvailNow]
685685     let actAmountLeft = curStats[idxWlgActAmLeft]
686686     let actAmount = curStats[idxWlgActAmAvailNow]
687687     let userAmount = curStats[idxWlgUserAmAvailNow]
688688     let userKey = keyStakersAmountPaidUser(addr)
689689     let userTotal = curStats[idxWlgUserTotalAvail]
690690     let userEffTime = curStats[idxWlgEffUserTime]
691691     $Tuple2([ScriptTransfer(addressFromStringValue(value(getString(teamAddrKey))), teamAmount, wlgAssetId), ScriptTransfer(restContract, actAmount, wlgAssetId), IntegerEntry(userKey, (valueOrElse(getInteger(userKey), 0) + userAmount)), IntegerEntry(stakersAmountPaidTotalKey, (valueOrElse(getInteger(stakersAmountPaidTotalKey), 0) + userTotal)), IntegerEntry(stakersAmountLeftKey, (curStats[idxWlgAmLeftTotal] - userTotal)), IntegerEntry(teamAmountLeftKey, (teamAmountLeft - teamAmount)), IntegerEntry(lastTeamTimeKey, now), IntegerEntry(actAmountLeftKey, (actAmountLeft - actAmount)), IntegerEntry(lastActivitiesTimeKey, now), IntegerEntry(keyLastClaimedTimeByUserOld(addr), userEffTime)], userAmount)
692692     }
693693 
694694 
695695 func claimInternal2 (addr) = {
696696     let curStats = getWlgStats2(addr, [rest2Contract, acres2Contract, wlgContract, puzzlePoolContract, investFundContract], usdtAssetId, 0)
697697     let userTimeKey = keyLastClaimTimeByUser(addr)
698698     let lastUserTime = valueOrElse(getInteger(userTimeKey), 0)
699699     let userEffTime = curStats[ixWlgEffUserTime]
700700     if ((lastUserTime == userEffTime))
701701         then $Tuple2(nil, 0)
702702         else {
703703             let now = lastBlock.timestamp
704704             let issueTime = curStats[ixWlgIssueTime]
705705             let teamAmountLeft = curStats[ixWlgTeamAmLeft]
706706             let teamAmount = (curStats[ixWlgTeamAmAvailNow] + curStats[ixWlgTeamIssue10Amount])
707707             let teamTransfer = if ((teamAmount > 0))
708708                 then [ScriptTransfer(addressFromStringValue(value(getString(teamAddrKey))), teamAmount, wlgAssetId)]
709709                 else nil
710710             let actAmountLeft = curStats[ixWlgActAmLeft]
711711             let actAmount = curStats[ixWlgActAmAvailNow]
712712             let actTransfer = if ((actAmount > 0))
713713                 then [ScriptTransfer(restContract, actAmount, wlgAssetId)]
714714                 else nil
715715             let marketingAmount = curStats[ixWlgMarketingIssue10Amount]
716716             let marketingTransfer = if ((marketingAmount > 0))
717717                 then [ScriptTransfer(addressFromStringValue(value(getString(marketingAddrKey))), marketingAmount, wlgAssetId)]
718718                 else nil
719719             let userAmount = curStats[ixWlgUserAmAvailNow]
720720             let userKey = keyStakersAmountPaidUser(addr)
721721             let userTotal = (userAmount + curStats[ixWlgUser10part])
722722             let issued10Amount = curStats[ixWlgIssue10Amount]
723723             $Tuple2(((([Reissue(wlgAssetId, issued10Amount, true), IntegerEntry(wlgIssuedAmountKey, (curStats[ixWlgAmount] + issued10Amount)), IntegerEntry(wlgIssue10TimeKey, curStats[ixWlgIssue10Time]), IntegerEntry(userKey, (valueOrElse(getInteger(userKey), 0) + userAmount)), IntegerEntry(stakersAmountPaidTotalKey, (valueOrElse(getInteger(stakersAmountPaidTotalKey), 0) + userAmount)), IntegerEntry(stakersAmountLeftKey, (curStats[ixWlgAmLeftTotal] - userAmount)), IntegerEntry(teamAmountLeftKey, ((teamAmountLeft - teamAmount) + curStats[ixWlgTeamIssue10Amount])), IntegerEntry(lastTeamTimeKey, now), IntegerEntry(actAmountLeftKey, (actAmountLeft - actAmount)), IntegerEntry(lastActivitiesTimeKey, now), IntegerEntry(userTimeKey, userEffTime)] ++ teamTransfer) ++ actTransfer) ++ marketingTransfer), userTotal)
724724             }
725725     }
726726 
727727 
728728 func takeXpInternal (addr,delta) = {
729729     let now = lastBlock.timestamp
730730     let timeKey = keyWlgStakedTimeByUser(addr)
731731     let amountKey = keyWlgStakedAmountByUser(addr)
732732     let lastTime = valueOrElse(getInteger(timeKey), 0)
733733     let oldUser = valueOrElse(getInteger(amountKey), 0)
734734     let oldTotal = valueOrElse(getInteger(wlgStakedTotalKey), 0)
735735     let xp = fraction(fraction(xpWlg, oldUser, wlgBaseAmountXp), (lastTime - now), DAYMILLIS)
736736     $Tuple3([IntegerEntry(timeKey, now), IntegerEntry(amountKey, (oldUser + delta)), IntegerEntry(wlgStakedTotalKey, (oldTotal + delta))], xp, oldUser)
737737     }
738738 
739739 
740740 func openChestInternal (addr) = {
741741     let week = (height / WEEK_BLOCKS)
742742     let drawWeek = (week - 1)
743743     let numPrizes = valueOrElse(getInteger(keyNumNFT2Draw(drawWeek)), DEFAULT_WEEKLY_PRIZES)
744744     let prizesDrawn = valueOrElse(getInteger(keyNumNFTDrawn(drawWeek)), 0)
745745     let userTickets = valueOrElse(getInteger(keyUserWeekTickets(addr, drawWeek)), 0)
746746     if ((0 >= userTickets))
747747         then $Tuple2(nil, unit)
748748         else {
749749             let weekTickets = valueOrElse(getInteger(keyTotalWeekTickets(drawWeek)), 0)
750750             if ((0 >= weekTickets))
751751                 then $Tuple2([DeleteEntry(keyUserWeekTickets(addr, drawWeek))], unit)
752752                 else {
753753                     let entropy = value(value(blockInfoByHeight((week * WEEK_BLOCKS))).vrf)
754754                     let salt = fromBase58String(split(valueOrElse(getString(acres2Contract, keyLastWeekTxIdByUser(addr)), "42_DEFAULT"), "_")[1])
755755                     let random = getRandomNumber(weekTickets, salt, entropy)
756756                     if (((userTickets * numPrizes) > random))
757757                         then {
758758                             let issueResult = invoke(acres2Contract, "issuePickC1", [addr], nil)
759759                             let winners = getString(keyWeekWinners(drawWeek))
760760                             let newWinners = if (isDefined(winners))
761761                                 then ((value(winners) + "_") + addr)
762762                                 else addr
763763                             $Tuple2([IntegerEntry(keyNumNFTDrawn(drawWeek), (prizesDrawn + 1)), DeleteEntry(keyUserWeekTickets(addr, drawWeek)), StringEntry(keyWeekWinners(drawWeek), newWinners)], issueResult)
764764                             }
765765                         else {
766766                             let random1 = (getRandomNumber(9, (base58'29' + salt), entropy) + 1)
767767                             let consTickets = fraction(userTickets, random1, 10)
768768                             let ticketsKey = keyUserWeekTickets(addr, week)
769769                             let oldTickets = valueOrElse(getInteger(ticketsKey), 0)
770770                             $Tuple2(((if ((consTickets == 0))
771771                                 then nil
772772                                 else {
773773                                     let commonActions = [IntegerEntry(keyTotalWeekTickets(week), (valueOrElse(getInteger(keyTotalWeekTickets(week)), 0) + consTickets)), IntegerEntry(ticketsKey, (oldTickets + consTickets))]
774774                                     if ((oldTickets > 0))
775775                                         then commonActions
776776                                         else (commonActions :+ IntegerEntry(keyTotalWeekParticipants(week), (valueOrElse(getInteger(keyTotalWeekParticipants(week)), 0) + 1)))
777777                                     }) :+ DeleteEntry(keyUserWeekTickets(addr, drawWeek))), consTickets)
778778                             }
779779                     }
780780             }
781781     }
782782 
783783 
784784 func claimTicketsInternal (addr,userBetStr) = {
785785     let week = (height / WEEK_BLOCKS)
786786     let ticketsKey = keyUserWeekTickets(addr, week)
787787     let dayBet = split(userBetStr, "_")
788788     let oldTotalTickets = valueOrElse(getInteger(keyTotalWeekTickets(week)), 0)
789789     let oldTickets = valueOrElse(getInteger(ticketsKey), 0)
790790     let deltaTickets = if ((winningBet(parseIntValue(dayBet[0])) == parseIntValue(dayBet[1])))
791791         then 1
792792         else 0
793793     let oldParticipants = valueOrElse(getInteger(keyTotalWeekParticipants(week)), 0)
794794     let updateParticipants = if (if ((oldTickets == 0))
795795         then (deltaTickets == 1)
796796         else false)
797797         then [IntegerEntry(keyTotalWeekParticipants(week), (oldParticipants + 1))]
798798         else nil
799799     $Tuple2(if ((deltaTickets == 0))
800800         then nil
801801         else ((updateParticipants :+ IntegerEntry(ticketsKey, (oldTickets + deltaTickets))) :+ IntegerEntry(keyTotalWeekTickets(week), (oldTotalTickets + deltaTickets))), deltaTickets)
802802     }
803803 
804804 
805805 @Callable(i)
806806 func constructorV1 (restAddr,marketingAddr,teamAddr,profitAddr) = if ((i.caller != this))
807807     then throw("Permission denied")
808808     else if (isDefined(getBinary(wlgAssetIdKey)))
809809         then throw("Already initialized")
810810         else {
811811             let issuedAmount = MILLION6
812812             let issue = Issue("WLGOLD", "WavesLands Gold investment token", issuedAmount, 8, true, unit, 0)
813813             let assetId = calculateAssetId(issue)
814814 [issue, IntegerEntry(wlgIssueTimeKey, lastBlock.timestamp), IntegerEntry(wlgIssuedAmountKey, issuedAmount), IntegerEntry(stakersAmountPaidTotalKey, 0), IntegerEntry(stakersAmountLeftKey, fraction(MILLION6, PLAYERSHARE, MULT6)), BinaryEntry(wlgAssetIdKey, assetId), StringEntry(keyRestAddress(), restAddr), StringEntry(marketingAddrKey, marketingAddr), StringEntry(teamAddrKey, teamAddr), StringEntry(profitAddrKey, profitAddr)]
815815             }
816816 
817817 
818818 
819819 @Callable(i)
820820 func constructorV2 (rest2Addr) = if ((i.caller != this))
821821     then throw("Permission denied")
822822     else [StringEntry(keyRest2Address(), rest2Addr)]
823823 
824824 
825825 
826826 @Callable(i)
827827 func buyWlg (minToReceive) = {
828828     let prologResult = prolog2()
829829     if ((prologResult == prologResult))
830830         then if ((size(i.payments) != 1))
831831             then throw("exactly 1 payment must be attached")
832832             else {
833833                 let pmt = i.payments[0]
834834                 let usdtAmt = pmt.amount
835835                 if (if (!(isDefined(pmt.assetId)))
836836                     then true
837837                     else (value(pmt.assetId) != usdtAssetId))
838838                     then throw("USDT payments only!")
839839                     else {
840840                         let caller = i.caller
841841                         let addr = toString(caller)
842842                         if ((MINSHOPPAYMENT > usdtAmt))
843843                             then throw((("You can trade min " + fixedPoint(MINSHOPPAYMENT, 6)) + " USDT"))
844844                             else {
845845                                 let curStats = getWlgStats2("", [rest2Contract, acres2Contract, wlgContract, puzzlePoolContract, investFundContract], usdtAssetId, usdtAmt)
846846                                 let curWlgAmount = curStats[ixWlgAmount]
847847                                 let wlgPrice = curStats[ixWlgPrice]
848848                                 let buyPrice = fraction(wlgPrice, 6, 5, CEILING)
849849                                 let wlgAmount = fraction(usdtAmt, MULT8, buyPrice)
850850                                 let maxWlg = getSwapLimitWlgold(addr)
851851                                 if ((wlgAmount > maxWlg))
852852                                     then throw((("You can get max " + fixedPoint(maxWlg, 8)) + " WLGOLD at the moment"))
853853                                     else if ((minToReceive > wlgAmount))
854854                                         then throw("Price changed during operation, please try again")
855855                                         else {
856856                                             let profitAmount = (usdtAmt / 6)
857857                                             $Tuple2([Reissue(wlgAssetId, wlgAmount, true), IntegerEntry(wlgIssuedAmountKey, (curWlgAmount + wlgAmount)), IntegerEntry(keyLastWlgTradeTimeByUser(addr), lastBlock.timestamp), IntegerEntry(keyLastWlgTradeLimitByUser(addr), (maxWlg - wlgAmount)), ScriptTransfer(addressFromStringValue(value(getString(profitAddrKey))), profitAmount, usdtAssetId), ScriptTransfer(caller, wlgAmount, wlgAssetId)], prologResult)
858858                                             }
859859                                 }
860860                         }
861861                 }
862862         else throw("Strict value is not equal to itself.")
863863     }
864864 
865865 
866866 
867867 @Callable(i)
868868 func buyWlgREADONLY (address,usdtAmt) = {
869869     let curStats = getWlgStats2("", [rest2Contract, acres2Contract, wlgContract, puzzlePoolContract, investFundContract], usdtAssetId, usdtAmt)
870870     let wlgPrice = curStats[ixWlgPrice]
871871     let buyPrice = fraction(wlgPrice, 6, 5, CEILING)
872872     let wlgAmount = fraction(usdtAmt, MULT8, buyPrice)
873873     let maxWlg = getSwapLimitWlgold(address)
874874     let maxUsdt = fraction(maxWlg, buyPrice, MULT8)
875875     let profitAmount = (usdtAmt / 6)
876876     $Tuple2(nil, [wlgAmount, MINSHOPPAYMENT, maxUsdt, profitAmount])
877877     }
878878 
879879 
880880 
881881 @Callable(i)
882882 func sellWlg (minAmount) = {
883883     let prologResult = prolog2()
884884     if ((prologResult == prologResult))
885885         then if ((size(i.payments) != 1))
886886             then throw("exactly 1 payment must be attached")
887887             else {
888888                 let pmt = i.payments[0]
889889                 let wlgAmt = pmt.amount
890890                 let caller = i.caller
891891                 let addr = toString(caller)
892892                 let maxWlg = getSwapLimitWlgold(addr)
893893                 if ((wlgAmt > maxWlg))
894894                     then throw((("You can spend max " + fixedPoint(maxWlg, 8)) + " WLGOLD at the moment"))
895895                     else if (if (!(isDefined(pmt.assetId)))
896896                         then true
897897                         else (value(pmt.assetId) != wlgAssetId))
898898                         then throw("WLGOLD payments only!")
899899                         else {
900900                             let curStats = getWlgStats2("", [rest2Contract, acres2Contract, wlgContract, puzzlePoolContract, investFundContract], usdtAssetId, 0)
901901                             let curWlgAmount = curStats[ixWlgAmount]
902902                             let sellPrice = (curStats[ixWlgPrice] / 2)
903903                             let usdtAmt = fraction(wlgAmt, sellPrice, MULT8)
904904                             if ((MINSHOPPAYMENT > usdtAmt))
905905                                 then throw((("You can trade min " + fixedPoint(MINSHOPPAYMENT, 6)) + " USDT"))
906906                                 else if ((minAmount > usdtAmt))
907907                                     then throw("Price changed during operation, please try again")
908908                                     else {
909909                                         let profitAmount = (usdtAmt / 5)
910910                                         $Tuple2([Burn(wlgAssetId, wlgAmt), IntegerEntry(wlgIssuedAmountKey, (curWlgAmount - wlgAmt)), IntegerEntry(keyLastWlgTradeTimeByUser(addr), lastBlock.timestamp), IntegerEntry(keyLastWlgTradeLimitByUser(addr), (maxWlg - wlgAmt)), ScriptTransfer(addressFromStringValue(value(getString(profitAddrKey))), profitAmount, usdtAssetId), ScriptTransfer(caller, usdtAmt, usdtAssetId)], prologResult)
911911                                         }
912912                             }
913913                 }
914914         else throw("Strict value is not equal to itself.")
915915     }
916916 
917917 
918918 
919919 @Callable(i)
920920 func sellWlgREADONLY (address,wlgAmt) = {
921921     let maxWlg = getSwapLimitWlgold(address)
922922     let curStats = getWlgStats2("", [rest2Contract, acres2Contract, wlgContract, puzzlePoolContract, investFundContract], usdtAssetId, 0)
923923     let sellPrice = (curStats[ixWlgPrice] / 2)
924924     let usdtAmt = fraction(wlgAmt, sellPrice, MULT8)
925925     let minWlg = fraction(MINSHOPPAYMENT, MULT8, sellPrice)
926926     let profitAmount = (usdtAmt / 5)
927927     $Tuple2(nil, [usdtAmt, minWlg, maxWlg, profitAmount])
928928     }
929929 
930930 
931931 
932932 @Callable(i)
933933 func claim () = {
934934     let prologResult = prolog2()
935935     if ((prologResult == prologResult))
936936         then if ((size(i.payments) != 0))
937937             then throw("No payments required")
938938             else {
939939                 let $t01640016469 = claimInternal2(toString(i.caller))
940940                 let actions = $t01640016469._1
941941                 let wlgClaimedAmount = $t01640016469._2
942942                 $Tuple2((actions :+ ScriptTransfer(i.caller, wlgClaimedAmount, wlgAssetId)), prologResult)
943943                 }
944944         else throw("Strict value is not equal to itself.")
945945     }
946946 
947947 
948948 
949949 @Callable(i)
950950 func onStakeUnstakeLand (addr,isNew) = if (if (if ((i.caller != stakingContract))
951951     then (i.caller != acresContract)
952952     else false)
953953     then (i.caller != acres2Contract)
954954     else false)
955955     then throw("Permission denied")
956956     else {
957957         let $t01680516900 = if (isNew)
958958             then claimInternal2(addr)
959959             else claimInternal(addr)
960960         let actions = $t01680516900._1
961961         let wlgClaimedAmount = $t01680516900._2
962962         $Tuple2(if ((wlgClaimedAmount > 0))
963963             then (actions :+ ScriptTransfer(addressFromStringValue(addr), wlgClaimedAmount, wlgAssetId))
964964             else actions, wlgClaimedAmount)
965965         }
966966 
967967 
968968 
969969 @Callable(i)
970970 func burnWlgold (wlgAmt) = if ((i.caller != acres2Contract))
971971     then throw("Permission denied")
972972     else {
973973         let curStats = getWlgStats2("", [rest2Contract, acres2Contract, wlgContract, puzzlePoolContract, investFundContract], usdtAssetId, 0)
974974         if ((wlgAmt > curStats[ixWlgWlg]))
975975             then throw(((("Only " + fixedPoint(curStats[ixWlgWlg], 8)) + " WLGOLD left on contract, can't burn ") + fixedPoint(wlgAmt, 8)))
976976             else {
977977                 let wlgAmountLeft = (curStats[ixWlgAmount] - wlgAmt)
978978                 $Tuple2([Burn(wlgAssetId, wlgAmt), IntegerEntry(wlgIssuedAmountKey, wlgAmountLeft)], wlgAmountLeft)
979979                 }
980980         }
981981 
982982 
983983 
984984 @Callable(i)
985985 func betForTicket (bet) = {
986986     let prologResult = prolog2()
987987     if ((prologResult == prologResult))
988988         then if ((size(i.payments) != 0))
989989             then throw("No payments required")
990990             else {
991991                 let addr = toString(i.caller)
992992                 let drawWeek = ((height / WEEK_BLOCKS) - 1)
993993                 let userTickets = valueOrElse(getInteger(keyUserWeekTickets(addr, drawWeek)), 0)
994994                 let weekTickets = valueOrElse(getInteger(keyTotalWeekTickets(drawWeek)), 0)
995995                 if (if ((userTickets > 0))
996996                     then (weekTickets > 0)
997997                     else false)
998998                     then throw("Please open the chest first")
999999                     else if (((bet / 4) != 0))
10001000                         then throw("Invalid bet: should be 0..3")
10011001                         else {
10021002                             let moment = (height % DAY_BLOCKS)
10031003                             if ((moment > (DAY_BLOCKS - 3)))
10041004                                 then throw((("Cannot bet: the day is almost ended, please wait " + toString((DAY_BLOCKS - moment))) + " blocks"))
10051005                                 else {
10061006                                     let stakedAcres = valueOrElse(getInteger(acres2Contract, keyAcresStakedAmtByUser(addr)), 0)
10071007                                     if ((ACRES_FOR_BET > stakedAcres))
10081008                                         then throw((("You need to stake at least " + fixedPoint(ACRES_FOR_BET, 8)) + " ACRES to bet"))
10091009                                         else {
10101010                                             let tomorrow = ((height / DAY_BLOCKS) + 1)
10111011                                             let betKey = keyUserBet(addr)
10121012                                             let oldUserBetStr = getString(betKey)
10131013                                             let newBetEntry = StringEntry(betKey, ((toString(tomorrow) + "_") + toString(bet)))
10141014                                             if (isDefined(oldUserBetStr))
10151015                                                 then {
10161016                                                     let userBet = value(oldUserBetStr)
10171017                                                     if ((split(userBet, "_")[0] == toString(tomorrow)))
10181018                                                         then throw("You already bet for tomorrow")
10191019                                                         else {
10201020                                                             let r = claimTicketsInternal(addr, userBet)
10211021                                                             $Tuple2((r._1 :+ newBetEntry), r._2)
10221022                                                             }
10231023                                                     }
10241024                                                 else $Tuple2([newBetEntry], 0)
10251025                                             }
10261026                                     }
10271027                             }
10281028                 }
10291029         else throw("Strict value is not equal to itself.")
10301030     }
10311031 
10321032 
10331033 
10341034 @Callable(i)
10351035 func takeWlgXp (addr) = if ((i.caller != stakingContract))
10361036     then throw("Permission denied")
10371037     else {
10381038         let $t01951019553 = takeXpInternal(addr, 0)
10391039         let actions = $t01951019553._1
10401040         let xp = $t01951019553._2
10411041         $Tuple2(actions, xp)
10421042         }
10431043 
10441044 
10451045 
10461046 @Callable(i)
10471047 func checkWlgXpREADONLY (addr) = {
10481048     let $t01963019678 = takeXpInternal(addr, 0)
10491049     let ignored = $t01963019678._1
10501050     let deltaXP = $t01963019678._2
10511051     let newXP = (valueOrElse(getInteger(stakingContract, keyUserXP(addr)), 0) + deltaXP)
10521052     let lvlPoints = levelUp(valueOrElse(getInteger(stakingContract, keyUserLevel(addr)), 0), newXP)
10531053     $Tuple2(nil, (lvlPoints :+ newXP))
10541054     }
10551055 
10561056 
10571057 
10581058 @Callable(i)
10591059 func setNumPrizes (numPrizes) = if ((i.caller != this))
10601060     then throw("Permission denied")
10611061     else {
10621062         let week = (height / WEEK_BLOCKS)
10631063         $Tuple2([IntegerEntry(keyNumNFT2Draw(week), numPrizes)], numPrizes)
10641064         }
10651065 
10661066 
10671067 
10681068 @Callable(i)
10691069 func openChest () = {
10701070     let prologResult = prolog2()
10711071     if ((prologResult == prologResult))
10721072         then if ((size(i.payments) != 0))
10731073             then throw("No payments required")
10741074             else {
10751075                 let drawWeek = ((height / WEEK_BLOCKS) - 1)
10761076                 let addr = toString(i.caller)
10771077                 let userTickets = valueOrElse(getInteger(keyUserWeekTickets(addr, drawWeek)), 0)
10781078                 if ((0 >= userTickets))
10791079                     then throw("No gems to open the chest")
10801080                     else openChestInternal(addr)
10811081                 }
10821082         else throw("Strict value is not equal to itself.")
10831083     }
10841084 
10851085 
10861086 
10871087 @Callable(i)
10881088 func addGemsFor (addr,deltaTickets) = if ((i.caller != this))
10891089     then throw("Permission denied")
10901090     else {
10911091         let week = (height / WEEK_BLOCKS)
10921092         let ticketsKey = keyUserWeekTickets(addr, week)
10931093         let oldTotalTickets = valueOrElse(getInteger(keyTotalWeekTickets(week)), 0)
10941094         let oldTickets = valueOrElse(getInteger(ticketsKey), 0)
10951095         let oldParticipants = valueOrElse(getInteger(keyTotalWeekParticipants(week)), 0)
10961096         let updateParticipants = if (if ((oldTickets == 0))
10971097             then (deltaTickets == 1)
10981098             else false)
10991099             then [IntegerEntry(keyTotalWeekParticipants(week), (oldParticipants + 1))]
11001100             else nil
11011101         $Tuple2(((updateParticipants :+ IntegerEntry(ticketsKey, (oldTickets + deltaTickets))) :+ IntegerEntry(keyTotalWeekTickets(week), (oldTotalTickets + deltaTickets))), deltaTickets)
11021102         }
11031103 
11041104 
github/deemru/w8io/169f3d6 
107.40 ms ◑