tx · AEYNTcUg1EZJ79e6TuAcyFWUR8urVoyBAjHFWkC2Fk9L

3N8rrevEexBvCrG6ZG6wtLRDGE6EMQ7ps1Q:  -0.01000000 Waves

2022.02.14 19:48 [1923555] smart account 3N8rrevEexBvCrG6ZG6wtLRDGE6EMQ7ps1Q > SELF 0.00000000 Waves

{ "type": 13, "id": "AEYNTcUg1EZJ79e6TuAcyFWUR8urVoyBAjHFWkC2Fk9L", "fee": 1000000, "feeAssetId": null, "timestamp": 1644857302622, "version": 1, "sender": "3N8rrevEexBvCrG6ZG6wtLRDGE6EMQ7ps1Q", "senderPublicKey": "6KHmVgyQxm4DWBaXF9XdDuuv8o68pcGebqKMjhEzx5xU", "proofs": [ "3DSouUm5XnHwDW4EJ4Cz9ro1goAhJEkyNpsJosVjW6GdCy5gZ2Pg7PQe5QiwfvhFv6UUozbLSqvVPo78McP5okj5" ], "script": "base64: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", "chainId": 84, "height": 1923555, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: none Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "__"
5+
6+let SCALE8 = 8
7+
8+let MULT8 = 100000000
9+
10+let POOLWEIGHTMULT = MULT8
11+
12+func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
13+
14+
15+func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
16+
17+
18+func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
19+
20+
21+func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
22+
23+
24+func abs (val) = if ((0 > val))
25+ then -(val)
26+ else val
27+
28+
29+func asAnyList (val) = match val {
30+ case valAnyLyst: List[Any] =>
31+ valAnyLyst
32+ case _ =>
33+ throw("fail to cast into List[Any]")
34+}
35+
36+
37+func asInt (val) = match val {
38+ case valInt: Int =>
39+ valInt
40+ case _ =>
41+ throw("fail to cast into Int")
42+}
43+
44+
45+func keyFactoryAddress () = "%s%s__config__factoryAddress"
46+
47+
48+let IdxFactoryCfgStakingDapp = 1
49+
50+let IdxFactoryCfgBoostingDapp = 2
51+
52+let IdxFactoryCfgIdoDapp = 3
53+
54+let IdxFactoryCfgTeamDapp = 4
55+
56+let IdxFactoryCfgEmissionDapp = 5
57+
58+let IdxFactoryCfgRestDapp = 6
59+
60+let IdxFactoryCfgSlippageDapp = 7
61+
62+let IdxFactoryCfgDaoDapp = 8
63+
64+let IdxFactoryCfgMarketingDapp = 9
65+
66+let IdxFactoryCfgGwxRewardDapp = 10
67+
68+let IdxFactoryCfgBirdsDapp = 11
69+
70+func keyFactoryCfg () = "%s__factoryConfig"
71+
72+
73+func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
74+
75+
76+func keyFactoryLpList () = "%s__lpTokensList"
77+
78+
79+func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
80+
81+
82+func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
83+
84+
85+func keyFactoryPoolWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
86+
87+
88+func readFactoryAddressOrFail () = addressFromStringValue(getStringOrFail(this, keyFactoryAddress()))
89+
90+
91+func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
92+
93+
94+func readFactoryCfgOrFail (factory) = split(getStringOrFail(factory, keyFactoryCfg()), SEP)
95+
96+
97+func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
98+
99+
100+func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
101+
102+
103+func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
104+
105+
106+func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
107+
108+
109+func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
110+
111+
112+func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
113+
114+
115+func keyEmissionStartBlock () = "%s%s__emission__startBlock"
116+
117+
118+func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
119+
120+
121+func keyEmissionEndBlock () = "%s%s__emission__endBlock"
122+
123+
124+func keyNextPeriod () = "%s__nextPeriod"
125+
126+
127+func keyGwxRewardEmissionStartHeight () = "%s%s__gwxRewardEmissionPart__startHeight"
128+
129+
130+let IdxCfgAssetId = 1
131+
132+let IdxCfgMinLockAmount = 2
133+
134+let IdxCfgMinLockDuration = 3
135+
136+let IdxCfgMaxLockDuration = 4
137+
138+let IdxCfgMathContract = 5
139+
140+func keyConfig () = "%s__config"
141+
142+
143+func readConfigArrayOrFail () = split(getStringOrFail(this, keyConfig()), SEP)
144+
145+
146+func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
147+
148+
149+func formatConfig (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = formatConfigS(assetId, toString(minLockAmount), toString(minLockDuration), toString(maxLockDuration), mathContract)
150+
151+
152+let IdxLockUserNum = 1
153+
154+let IdxLockAmount = 2
155+
156+let IdxLockStart = 3
157+
158+let IdxLockDuration = 4
159+
160+let IdxLockParamK = 5
161+
162+let IdxLockParamB = 6
163+
164+func keyLockParamsRecord (userAddress) = makeString(["%s%s__lock", userAddress], SEP)
165+
166+
167+func readLockParamsRecordOrFail (userAddress) = split(getStringOrFail(this, keyLockParamsRecord(userAddress)), SEP)
168+
169+
170+func formatLockParamsRecordS (userNum,amount,start,duration,paramK,paramB,lastUpdTimestamp,gwxAmount) = makeString(["%d%d%d%d%d%d%d%d", userNum, amount, start, duration, paramK, paramB, lastUpdTimestamp, gwxAmount], SEP)
171+
172+
173+func formatLockParamsRecord (userNum,amount,start,duration,paramK,paramB,gwxAmount) = formatLockParamsRecordS(userNum, toString(amount), toString(start), toString(duration), toString(paramK), toString(paramB), toString(lastBlock.timestamp), toString(gwxAmount))
174+
175+
176+func keyNextUserNum () = "%s__nextUserNum"
177+
178+
179+func keyUser2NumMapping (userAddress) = makeString(["%s%s%s__mapping__user2num", userAddress], SEP)
180+
181+
182+func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
183+
184+
185+func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
186+
187+
188+func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
189+
190+
191+func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
192+
193+
194+func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
195+
196+
197+func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
198+
199+
200+func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
201+
202+
203+func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
204+
205+
206+func keyLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"
207+
208+
209+func keyStatsLocksDurationSumInBlocks () = "%s%s__stats__locksDurationSumInBlocks"
210+
211+
212+func keyStatsLocksCount () = "%s%s__stats__locksCount"
213+
214+
215+func keyStatsUsersCount () = "%s%s__stats__activeUsersCount"
216+
217+
218+func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastInt", userNum], SEP)
219+
220+
221+func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastInt", userNum, lpAssetId], SEP)
222+
223+
224+func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
225+
226+
227+func keyTotalMaxBoostINTEGRAL () = "%s%s__maxBoostInt__total"
228+
229+
230+func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", userNum], SEP)
231+
232+
233+func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", userNum], SEP)
234+
235+
236+func keyTotalCachedGwx () = "%s%s__gwxCached__total"
237+
238+
239+let factoryContract = readFactoryAddressOrFail()
240+
241+let factoryCfg = readFactoryCfgOrFail(factoryContract)
242+
243+let emissionContract = getEmissionAddressOrFail(factoryCfg)
244+
245+let stakingContract = getStakingAddressOrFail(factoryCfg)
246+
247+let gwxRewardContract = getGwxRewardAddressOrFail(factoryCfg)
248+
249+func HistoryEntry (type,user,amount,lockStart,duration,k,b,i) = {
250+ let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], SEP)
251+ let historyDATA = makeString(["%d%d%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount), toString(lockStart), toString(duration), toString(k), toString(b)], SEP)
252+ StringEntry(historyKEY, historyDATA)
253+ }
254+
255+
256+func StatsEntry (totalLockedInc,durationInc,lockCountInc,usersCountInc) = {
257+ let locksDurationSumInBlocksKEY = keyStatsLocksDurationSumInBlocks()
258+ let locksCountKEY = keyStatsLocksCount()
259+ let usersCountKEY = keyStatsUsersCount()
260+ let totalAmountKEY = keyLockParamTotalAmount()
261+ let locksDurationSumInBlocks = getIntOrZero(this, locksDurationSumInBlocksKEY)
262+ let locksCount = getIntOrZero(this, locksCountKEY)
263+ let usersCount = getIntOrZero(this, usersCountKEY)
264+ let totalAmount = getIntOrZero(this, totalAmountKEY)
265+[IntegerEntry(locksDurationSumInBlocksKEY, (locksDurationSumInBlocks + durationInc)), IntegerEntry(locksCountKEY, (locksCount + lockCountInc)), IntegerEntry(usersCountKEY, (usersCount + usersCountInc)), IntegerEntry(totalAmountKEY, (totalAmount + totalLockedInc))]
266+ }
267+
268+
269+func calcGwxAmount (kRaw,bRaw,h) = {
270+ let SCALE = 1000
271+ (((kRaw * h) + bRaw) / SCALE)
272+ }
273+
274+
275+func LockParamsEntry (userAddress,userNum,amount,start,duration,k,b,period) = {
276+ let userAmountKEY = keyLockParamUserAmount(userNum)
277+ let startBlockKEY = keyLockParamStartBlock(userNum)
278+ let durationKEY = keyLockParamDuration(userNum)
279+ let kKEY = keyLockParamK(userNum)
280+ let bKEY = keyLockParamB(userNum)
281+ let kByPeriodKEY = keyLockParamByPeriodK(userNum, period)
282+ let bByPeriodKEY = keyLockParamByPeriodB(userNum, period)
283+ let gwxAmount = calcGwxAmount(k, b, height)
284+[IntegerEntry(userAmountKEY, amount), IntegerEntry(startBlockKEY, start), IntegerEntry(durationKEY, duration), IntegerEntry(kKEY, k), IntegerEntry(bKEY, b), IntegerEntry(kByPeriodKEY, k), IntegerEntry(bByPeriodKEY, b), StringEntry(keyLockParamsRecord(userAddress), formatLockParamsRecord(userNum, amount, start, duration, k, b, gwxAmount))]
285+ }
286+
287+
288+func extractOptionalPaymentAmountOrFail (i,expectedAssetId) = if ((size(i.payments) > 1))
289+ then throw("only one payment is allowed")
290+ else if ((size(i.payments) == 0))
291+ then 0
292+ else {
293+ let pmt = i.payments[0]
294+ if ((value(pmt.assetId) != expectedAssetId))
295+ then throw("invalid asset id in payment")
296+ else pmt.amount
297+ }
298+
299+
300+func calcCurrentGwxAmount (userAddress) = {
301+ let EMPTY = "empty"
302+ let user2NumMappingKEY = keyUser2NumMapping(userAddress)
303+ let userNum = valueOrElse(getString(user2NumMappingKEY), EMPTY)
304+ let k = valueOrElse(getInteger(keyLockParamK(userNum)), 0)
305+ let b = valueOrElse(getInteger(keyLockParamB(userNum)), 0)
306+ let gwxAmountCalc = calcGwxAmount(k, b, height)
307+ let gwxAmount = if ((0 > gwxAmountCalc))
308+ then 0
309+ else gwxAmountCalc
310+ gwxAmount
311+ }
312+
313+
314+func internalClaimWxBoost (lpAssetIdStr,userAddressStr,readOnly) = {
315+ let EMPTY = "EMPTY"
316+ let userRecordOrEmpty = valueOrElse(getString(this, keyLockParamsRecord(userAddressStr)), EMPTY)
317+ if ((userRecordOrEmpty == EMPTY))
318+ then $Tuple3(0, nil, "userRecord::is::empty")
319+ else {
320+ let userRecordArray = split(userRecordOrEmpty, SEP)
321+ let userNumStr = userRecordArray[IdxLockUserNum]
322+ let gwxRewardEmissionStartHeight = valueOrElse(getInteger(gwxRewardContract, keyGwxRewardEmissionStartHeight()), 0)
323+ let EMPTYSTR = "empty"
324+ let $t01244413012 = if ((lpAssetIdStr != EMPTYSTR))
325+ then {
326+ let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
327+ let pw1 = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
328+ let pw0 = valueOrElse(getInteger(factoryContract, keyFactoryPoolWeightHistory(poolAddressStr, 0)), pw1)
329+ $Tuple2(pw0, pw1)
330+ }
331+ else if (readOnly)
332+ then $Tuple2(0, 0)
333+ else throw(("not readonly mode: unsupported lp asset " + lpAssetIdStr))
334+ let poolWeight0 = $t01244413012._1
335+ let poolWeight1 = $t01244413012._2
336+ let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
337+ let emissionStart = getIntOrFail(emissionContract, keyEmissionStartBlock())
338+ let emissionEnd = getIntOrFail(emissionContract, keyEmissionEndBlock())
339+ let h = if ((height > emissionEnd))
340+ then emissionEnd
341+ else height
342+ let dh = max([(h - emissionStart), 0])
343+ let userLpBoostEmissionLastIntegralKEY = keyUserLpBoostEmissionLastINTEGRAL(userNumStr, lpAssetIdStr)
344+ let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
345+ let userBoostEmissionLastIntegral = valueOrElse(getInteger(this, userLpBoostEmissionLastIntegralKEY), getIntOrZero(this, userBoostEmissionLastIntegralKEY))
346+ let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
347+ let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
348+ let udh = fraction(userBoostEmissionIntegral, 3, (2 * wxEmissionPerBlock))
349+ let uLastH = (h - udh)
350+ let udh0 = max([(gwxRewardEmissionStartHeight - uLastH), 0])
351+ let udh1 = ((h - uLastH) - udh0)
352+ if (if (if ((0 > uLastH))
353+ then true
354+ else (0 > udh1))
355+ then true
356+ else (abs(((udh0 + udh1) - udh)) >= 1))
357+ then throw(((((((("invalid udh calc: udh=" + toString(udh)) + " uLastH=") + toString(uLastH)) + " udh0=") + toString(udh0)) + " udh1=") + toString(udh1)))
358+ else if ((0 > userBoostEmissionIntegral))
359+ then throw("wrong calculations")
360+ else {
361+ let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
362+ let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
363+ let userMaxBoostInt = getIntOrZero(this, userMaxBoostIntegralKEY)
364+ let totalMaxBoostInt = getIntOrZero(this, totalMaxBoostIntegralKEY)
365+ let totalCachedGwxKEY = keyTotalCachedGwx()
366+ let totalCachedGwx = valueOrElse(getInteger(this, totalCachedGwxKEY), 0)
367+ let userCurrGwx = calcCurrentGwxAmount(userAddressStr)
368+ let userBoostAvalaibleToClaimTotalKEY = keyUserBoostAvalaibleToClaimTotal(userNumStr)
369+ let userBoostAvaliableToClaimTotal = getIntOrZero(this, userBoostAvalaibleToClaimTotalKEY)
370+ let userBoostEmissionIntegral0 = fraction(userBoostEmissionIntegral, udh0, udh)
371+ let userBoostEmissionIntegral1 = fraction(userBoostEmissionIntegral, udh1, udh)
372+ let poolUserBoostEmissionIntegral0 = fraction(userBoostEmissionIntegral0, poolWeight0, POOLWEIGHTMULT)
373+ let poolUserBoostEmissionIntegral1 = fraction(userBoostEmissionIntegral1, poolWeight1, POOLWEIGHTMULT)
374+ let userBoostAvaliableToClaimTotalNew0 = if ((totalCachedGwx == 0))
375+ then 0
376+ else fraction(poolUserBoostEmissionIntegral0, userCurrGwx, totalCachedGwx)
377+ let userBoostAvaliableToClaimTotalNew1 = if ((totalCachedGwx == 0))
378+ then 0
379+ else fraction(poolUserBoostEmissionIntegral1, userCurrGwx, totalCachedGwx)
380+ let userBoostAvaliableToClaimTotalNew = (userBoostAvaliableToClaimTotalNew0 + userBoostAvaliableToClaimTotalNew1)
381+ let userBoostClaimedKEY = keyUserBoostClaimed(userNumStr)
382+ let userBoostClaimed = getIntOrZero(this, userBoostClaimedKEY)
383+ let userBoostAvailable = (userBoostAvaliableToClaimTotalNew - userBoostClaimed)
384+ let dataState = [IntegerEntry(userLpBoostEmissionLastIntegralKEY, boostEmissionIntegral)]
385+ let debug = makeString([("userBoostEmissionLastIntegral=" + toString(userBoostEmissionLastIntegral)), ("userBoostEmissionIntegral=" + toString(userBoostEmissionIntegral)), ("userMaxBoostInt=" + toString(userMaxBoostInt)), ("totalMaxBoostInt=" + toString(totalMaxBoostInt)), ("userBoostAvaliableToClaimTotal=" + toString(userBoostAvaliableToClaimTotal)), ("userBoostAvaliableToClaimTotalNew=" + toString(userBoostAvaliableToClaimTotalNew)), ("userBoostClaimed=" + toString(userBoostClaimed)), ("userBoostAvailable=" + toString(userBoostAvailable)), ("userBoostEmissionIntegral0=" + toString(userBoostEmissionIntegral0)), ("userBoostEmissionIntegral1=" + toString(userBoostEmissionIntegral1)), ("poolUserBoostEmissionIntegral0=" + toString(poolUserBoostEmissionIntegral0)), ("poolUserBoostEmissionIntegral1=" + toString(poolUserBoostEmissionIntegral1)), ("poolWeight0=" + toString(poolWeight0)), ("poolWeight1=" + toString(poolWeight1)), ("h=" + toString(h)), ("udh=" + toString(udh)), ("uLastH=" + toString(uLastH)), ("udh0=" + toString(udh0)), ("udh1=" + toString(udh1)), ("userCurrGwx=" + toString(userCurrGwx)), ("totalCachedGwx=" + toString(totalCachedGwx))], "::")
386+ $Tuple3(userBoostAvaliableToClaimTotalNew, dataState, debug)
387+ }
388+ }
389+ }
390+
391+
392+@Callable(i)
393+func constructor (factoryAddressStr,lockAssetIdStr,minLockAmount,minDuration,maxDuration,mathContract) = if ((this != i.caller))
394+ then throw("not authorized")
395+ else ([IntegerEntry(keyNextUserNum(), 0), StringEntry(keyConfig(), formatConfig(lockAssetIdStr, minLockAmount, minDuration, maxDuration, mathContract)), StringEntry(keyFactoryAddress(), factoryAddressStr)] ++ StatsEntry(0, 0, 0, 0))
396+
397+
398+
399+@Callable(i)
400+func lock (duration) = {
401+ let cfgArray = readConfigArrayOrFail()
402+ let assetIdStr = cfgArray[IdxCfgAssetId]
403+ let assetId = fromBase58String(assetIdStr)
404+ let minLockAmount = parseIntValue(cfgArray[IdxCfgMinLockAmount])
405+ let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
406+ let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
407+ let mathContract = addressFromStringValue(cfgArray[IdxCfgMathContract])
408+ if ((size(i.payments) != 1))
409+ then throw("invalid payment - exact one payment must be attached")
410+ else {
411+ let pmt = i.payments[0]
412+ let pmtAmount = pmt.amount
413+ if ((assetId != value(pmt.assetId)))
414+ then throw((("invalid asset is in payment - " + assetIdStr) + " is expected"))
415+ else {
416+ let nextUserNumKEY = keyNextUserNum()
417+ let userAddressStr = toString(i.caller)
418+ let userIsExisting = isDefined(getString(keyUser2NumMapping(userAddressStr)))
419+ let userNumStr = if (userIsExisting)
420+ then value(getString(keyUser2NumMapping(userAddressStr)))
421+ else toString(getIntOrFail(this, nextUserNumKEY))
422+ let userNum = parseIntValue(userNumStr)
423+ let lockStart = height
424+ let startBlockKEY = keyLockParamStartBlock(userNumStr)
425+ let durationKEY = keyLockParamDuration(userNumStr)
426+ let userAmountKEY = keyLockParamUserAmount(userNumStr)
427+ if ((minLockAmount > pmtAmount))
428+ then throw(("amount is less then minLockAmount=" + toString(minLockAmount)))
429+ else if ((minLockDuration > duration))
430+ then throw(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
431+ else if ((duration > maxLockDuration))
432+ then throw(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
433+ else if (if (userIsExisting)
434+ then ((getIntOrFail(this, startBlockKEY) + getIntOrFail(this, durationKEY)) >= lockStart)
435+ else false)
436+ then throw("there is an active lock - consider to use increaseLock")
437+ else if ((getIntOrZero(this, userAmountKEY) > 0))
438+ then throw(("there are locked WXs - consider to use increaseLock " + userAmountKEY))
439+ else {
440+ let coeffX8 = fraction(duration, MULT8, maxLockDuration)
441+ let gWxAmountStart = fraction(pmtAmount, coeffX8, MULT8)
442+ let gWxParamsResultList = asAnyList(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStart, duration], nil))
443+ let k = asInt(gWxParamsResultList[0])
444+ let b = asInt(gWxParamsResultList[1])
445+ let period = toString(asInt(gWxParamsResultList[2]))
446+ let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
447+ let emissionStart = getIntOrFail(emissionContract, keyEmissionStartBlock())
448+ let emissionEnd = getIntOrFail(emissionContract, keyEmissionEndBlock())
449+ let h = if ((height > emissionEnd))
450+ then emissionEnd
451+ else height
452+ let dh = max([(h - emissionStart), 0])
453+ let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
454+ let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
455+ let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
456+ let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
457+ let userMaxBoostInt = ((gWxAmountStart * duration) / 2)
458+ let totalMaxBoostInt = getIntOrZero(this, totalMaxBoostIntegralKEY)
459+ let totalCachedGwxKEY = keyTotalCachedGwx()
460+ let totalCachedGwx = valueOrElse(getInteger(this, totalCachedGwxKEY), 0)
461+ let arr = if (userIsExisting)
462+ then nil
463+ else [IntegerEntry(nextUserNumKEY, (userNum + 1)), StringEntry(keyUser2NumMapping(userAddressStr), userNumStr), StringEntry(keyNum2UserMapping(userNumStr), userAddressStr)]
464+ ((((arr ++ LockParamsEntry(userAddressStr, userNumStr, pmtAmount, lockStart, duration, k, b, period)) ++ StatsEntry(pmtAmount, duration, 1, if (userIsExisting)
465+ then 0
466+ else 1)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, duration, k, b, i)) ++ [IntegerEntry(userBoostEmissionLastIntegralKEY, boostEmissionIntegral), IntegerEntry(totalCachedGwxKEY, (totalCachedGwx + gWxAmountStart))])
467+ }
468+ }
469+ }
470+ }
471+
472+
473+
474+@Callable(i)
475+func increaseLock (deltaDuration) = {
476+ let cfgArray = readConfigArrayOrFail()
477+ let assetIdStr = cfgArray[IdxCfgAssetId]
478+ let assetId = fromBase58String(assetIdStr)
479+ let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
480+ let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
481+ let mathContract = addressFromStringValue(cfgArray[IdxCfgMathContract])
482+ let pmtAmount = extractOptionalPaymentAmountOrFail(i, assetId)
483+ let userAddressStr = toString(i.caller)
484+ let userRecordArray = readLockParamsRecordOrFail(userAddressStr)
485+ let userNumStr = userRecordArray[IdxLockUserNum]
486+ let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
487+ let lockStart = parseIntValue(userRecordArray[IdxLockStart])
488+ let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
489+ let lockEnd = (lockStart + lockDuration)
490+ let remainingDuration = max([(lockEnd - height), 0])
491+ let userAmountNew = (userAmount + pmtAmount)
492+ let lockDurationNew = (remainingDuration + deltaDuration)
493+ if ((0 > deltaDuration))
494+ then throw("duration is less then zero")
495+ else if ((minLockDuration > lockDurationNew))
496+ then throw(("lockDurationNew is less then minLockDuration=" + toString(minLockDuration)))
497+ else if ((lockDurationNew > maxLockDuration))
498+ then throw(("deltaDuration + existedLockDuration is greater then maxLockDuration=" + toString(maxLockDuration)))
499+ else {
500+ let coeffX8 = fraction(lockDurationNew, MULT8, maxLockDuration)
501+ let gWxAmountStart = fraction(userAmountNew, coeffX8, MULT8)
502+ let lockStartNew = height
503+ let gWxParamsResultList = asAnyList(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStartNew, lockDurationNew], nil))
504+ let k = asInt(gWxParamsResultList[0])
505+ let b = asInt(gWxParamsResultList[1])
506+ let period = toString(asInt(gWxParamsResultList[2]))
507+ let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
508+ let emissionStart = getIntOrFail(emissionContract, keyEmissionStartBlock())
509+ let emissionEnd = getIntOrFail(emissionContract, keyEmissionEndBlock())
510+ let h = if ((height > emissionEnd))
511+ then emissionEnd
512+ else height
513+ let dh = max([(h - emissionStart), 0])
514+ let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
515+ let userBoostEmissionLastIntegral = getIntOrZero(this, userBoostEmissionLastIntegralKEY)
516+ let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
517+ let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
518+ if ((0 > userBoostEmissionIntegral))
519+ then throw("wrong calculations")
520+ else {
521+ let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
522+ let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
523+ let userMaxBoostInt = getIntOrZero(this, userMaxBoostIntegralKEY)
524+ let totalMaxBoostInt = getIntOrZero(this, totalMaxBoostIntegralKEY)
525+ let currUserGwx = calcCurrentGwxAmount(userAddressStr)
526+ let gwxDiff = (gWxAmountStart - currUserGwx)
527+ if ((0 > gwxDiff))
528+ then throw(("gwxDiff is less then 0: " + toString(gwxDiff)))
529+ else {
530+ let totalCachedGwxKEY = keyTotalCachedGwx()
531+ let totalCachedGwx = valueOrElse(getInteger(this, totalCachedGwxKEY), 0)
532+ let userBoostAvalaibleToClaimTotalKEY = keyUserBoostAvalaibleToClaimTotal(userNumStr)
533+ let userBoostAvaliableToClaimTotal = getIntOrZero(this, userBoostAvalaibleToClaimTotalKEY)
534+ let userBoostAvaliableToClaimTotalNew = fraction(userBoostEmissionIntegral, currUserGwx, totalCachedGwx)
535+ let userMaxBoostIntNew = ((gWxAmountStart * lockDurationNew) / 2)
536+ let remainingUserMaxBoostInt = ((currUserGwx * remainingDuration) / 2)
537+ let userMaxBoostIntDiff = (userMaxBoostIntNew - remainingUserMaxBoostInt)
538+ (((LockParamsEntry(userAddressStr, userNumStr, userAmountNew, lockStartNew, lockDurationNew, k, b, period) ++ StatsEntry(pmtAmount, deltaDuration, 0, 0)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, lockDurationNew, k, b, i)) ++ [IntegerEntry(totalCachedGwxKEY, (totalCachedGwx + gwxDiff))])
539+ }
540+ }
541+ }
542+ }
543+
544+
545+
546+@Callable(i)
547+func claimWxBoost (lpAssetIdStr,userAddressStr) = if ((stakingContract != i.caller))
548+ then throw("permissions denied")
549+ else {
550+ let $t02723127333 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, false)
551+ let userBoostAvailable = $t02723127333._1
552+ let dataState = $t02723127333._2
553+ let debug = $t02723127333._3
554+ $Tuple2(dataState, [userBoostAvailable])
555+ }
556+
557+
558+
559+@Callable(i)
560+func claimWxBoostREADONLY (lpAssetIdStr,userAddressStr) = {
561+ let $t02746527566 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, true)
562+ let userBoostAvailable = $t02746527566._1
563+ let dataState = $t02746527566._2
564+ let debug = $t02746527566._3
565+ $Tuple2(nil, [userBoostAvailable, debug])
566+ }
567+
568+
569+
570+@Callable(i)
571+func unlock (userAddress) = {
572+ let userRecordArray = readLockParamsRecordOrFail(userAddress)
573+ let userNumStr = userRecordArray[IdxLockUserNum]
574+ let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
575+ let lockStart = parseIntValue(userRecordArray[IdxLockStart])
576+ let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
577+ let lockEnd = (lockStart + lockDuration)
578+ let cfgArray = readConfigArrayOrFail()
579+ let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
580+ let mathContract = addressFromStringValue(cfgArray[IdxCfgMathContract])
581+ if ((lockEnd >= height))
582+ then throw((("wait " + toString(lockEnd)) + " to unlock"))
583+ else if ((0 >= userAmount))
584+ then throw("nothing to unlock")
585+ else {
586+ let period = valueOrElse(getInteger(mathContract, keyNextPeriod()), 0)
587+ (((LockParamsEntry(userAddress, userNumStr, 0, lockStart, lockDuration, 0, 0, toString(period)) ++ StatsEntry(-(userAmount), 0, 0, -1)) :+ HistoryEntry("unlock", userAddress, userAmount, lockStart, lockDuration, 0, 0, i)) :+ ScriptTransfer(addressFromStringValue(userAddress), userAmount, assetId))
588+ }
589+ }
590+
591+
592+
593+@Callable(i)
594+func gwxUserInfoREADONLY (userAddress) = {
595+ let gwxAmount = calcCurrentGwxAmount(userAddress)
596+ $Tuple2(nil, [gwxAmount])
597+ }
598+
599+

github/deemru/w8io/3ef1775 
295.08 ms