2021.12.23 20:34 [2912221] smart account 3PJL8Hn8LACaSBWLQ3UVhctA5cTQLBFwBAP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EE9hFNaapjZKsBuPXt19nqvnNNyDF5w35ZrNfXevnXpX",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1640280887931,
    "version": 1,
    "sender": "3PJL8Hn8LACaSBWLQ3UVhctA5cTQLBFwBAP",
    "senderPublicKey": "6PdA345SW1zresPEKuWiLPsh9Ku14mFDW6cZtpCQrp3E",
    "proofs": [
        "4wrpyPuwHCZLJX8tmz9VruPXg5stVz243kj784r34FGK668DXNfhDZCggWMr5piGvPbfMeQERqLb9A7oJjm3p92x"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2912221,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 3gawpmPFn49PyHSDWNw9f4qTfR8Ra5NgnubwCbQEDshs
Next: 4k2VdBTjAwYUDn2cUoYdjLXk93C1JTx3tzGuqjX9MD93

Diff: 

OldNewDifferences
604604 
605605 
606606 @Callable(i)
607-func normalizeBeforeUnlockAndBurn () = if ((i.caller != this))
608-    then throw("permissions denied")
609-    else {
610-        let tot = getIntOrFail(this, keyNextUserNum())
611-        let lps = split(getStringOrFail(factoryContract, keyFactoryLpList()), SEP)
612-        let nextK = "%s__nextUser2Normalaize"
613-        let uN = valueOrElse(getInteger(this, nextK), 0)
614-        if ((uN == tot))
615-            then throw("normalization is finished")
616-            else {
617-                let uS = toString(uN)
618-                let u = getStringOrFail(this, keyNum2UserMapping(uS))
619-                let lp0 = lps[0]
620-                let $t02916129215 = internalClaimWxBoost(lp0, u, true)
621-                let b0 = $t02916129215._1
622-                let ds0 = $t02916129215._2
623-                let d0 = $t02916129215._3
624-                let bK0 = keyUserBoostAvalaibleToClaimCached(uS, lp0)
625-                let lp1 = lps[1]
626-                let $t02929329347 = internalClaimWxBoost(lp1, u, true)
627-                let b1 = $t02929329347._1
628-                let ds1 = $t02929329347._2
629-                let d1 = $t02929329347._3
630-                let bK1 = keyUserBoostAvalaibleToClaimCached(uS, lp1)
631-                let lp2 = lps[2]
632-                let $t02942529479 = internalClaimWxBoost(lp2, u, true)
633-                let b2 = $t02942529479._1
634-                let ds2 = $t02942529479._2
635-                let d2 = $t02942529479._3
636-                let bK2 = keyUserBoostAvalaibleToClaimCached(uS, lp2)
637-                let lp3 = lps[3]
638-                let $t02955729611 = internalClaimWxBoost(lp3, u, true)
639-                let b3 = $t02955729611._1
640-                let ds3 = $t02955729611._2
641-                let d3 = $t02955729611._3
642-                let bK3 = keyUserBoostAvalaibleToClaimCached(uS, lp3)
643-                let lp4 = lps[4]
644-                let $t02968929743 = internalClaimWxBoost(lp4, u, true)
645-                let b4 = $t02968929743._1
646-                let ds4 = $t02968929743._2
647-                let d4 = $t02968929743._3
648-                let bK4 = keyUserBoostAvalaibleToClaimCached(uS, lp4)
649-[IntegerEntry(nextK, (uN + 1)), IntegerEntry(bK0, b0), IntegerEntry(bK1, b1), IntegerEntry(bK2, b2), IntegerEntry(bK3, b3), IntegerEntry(bK4, b4), ds0[0], ds1[0], ds2[0], ds3[0], ds4[0]]
650-                }
651-        }
607+func unlockEarlyAndBurn () = {
608+    let cfgArray = readConfigArrayOrFail()
609+    let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
610+    let mathContract = addressFromStringValue(cfgArray[IdxCfgMathContract])
611+    let userAddress = toString(i.caller)
612+    let userRecordArray = readLockParamsRecordOrFail(userAddress)
613+    let userNumStr = userRecordArray[IdxLockUserNum]
614+    let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
615+    let lockStart = parseIntValue(userRecordArray[IdxLockStart])
616+    let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
617+    let lockEnd = (lockStart + lockDuration)
618+    let remainingDuration = max([(lockEnd - height), 0])
619+    let totalCachedGwxKEY = keyTotalCachedGwx()
620+    let totalCachedGwx = valueOrElse(getInteger(this, totalCachedGwxKEY), 0)
621+    if ((0 >= userAmount))
622+        then throw("nothing to unlock")
623+        else {
624+            let period = valueOrElse(getInteger(mathContract, keyNextPeriod()), 0)
625+            let currUserGwx = calcCurrentGwxAmount(userAddress)
626+            let burn = invoke(emissionContract, "burn", nil, [AttachedPayment(assetId, userAmount)])
627+            if ((burn == burn))
628+                then (((LockParamsEntry(userAddress, userNumStr, 0, 0, 0, 0, 0, toString(period)) ++ StatsEntry(-(userAmount), 0, 0, -1)) :+ HistoryEntry("unlock", userAddress, userAmount, lockStart, lockDuration, 0, 0, i)) :+ IntegerEntry(totalCachedGwxKEY, (totalCachedGwx - currUserGwx)))
629+                else throw("Strict value is not equal to itself.")
630+            }
631+    }
652632 
653633 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "__"
55 
66 let SCALE8 = 8
77 
88 let MULT8 = 100000000
99 
1010 let POOLWEIGHTMULT = MULT8
1111 
1212 func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
1313 
1414 
1515 func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
1616 
1717 
1818 func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
1919 
2020 
2121 func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
2222 
2323 
2424 func abs (val) = if ((0 > val))
2525     then -(val)
2626     else val
2727 
2828 
2929 func asAnyList (val) = match val {
3030     case valAnyLyst: List[Any] => 
3131         valAnyLyst
3232     case _ => 
3333         throw("fail to cast into List[Any]")
3434 }
3535 
3636 
3737 func asInt (val) = match val {
3838     case valInt: Int => 
3939         valInt
4040     case _ => 
4141         throw("fail to cast into Int")
4242 }
4343 
4444 
4545 func keyFactoryAddress () = "%s%s__config__factoryAddress"
4646 
4747 
4848 let IdxFactoryCfgStakingDapp = 1
4949 
5050 let IdxFactoryCfgBoostingDapp = 2
5151 
5252 let IdxFactoryCfgIdoDapp = 3
5353 
5454 let IdxFactoryCfgTeamDapp = 4
5555 
5656 let IdxFactoryCfgEmissionDapp = 5
5757 
5858 let IdxFactoryCfgRestDapp = 6
5959 
6060 let IdxFactoryCfgSlippageDapp = 7
6161 
6262 let IdxFactoryCfgDaoDapp = 8
6363 
6464 let IdxFactoryCfgMarketingDapp = 9
6565 
6666 let IdxFactoryCfgGwxRewardDapp = 10
6767 
6868 let IdxFactoryCfgBirdsDapp = 11
6969 
7070 func keyFactoryCfg () = "%s__factoryConfig"
7171 
7272 
7373 func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
7474 
7575 
7676 func keyFactoryLpList () = "%s__lpTokensList"
7777 
7878 
7979 func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
8080 
8181 
8282 func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
8383 
8484 
8585 func keyFactoryPoolWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
8686 
8787 
8888 func readFactoryAddressOrFail () = addressFromStringValue(getStringOrFail(this, keyFactoryAddress()))
8989 
9090 
9191 func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
9292 
9393 
9494 func readFactoryCfgOrFail (factory) = split(getStringOrFail(factory, keyFactoryCfg()), SEP)
9595 
9696 
9797 func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
9898 
9999 
100100 func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
101101 
102102 
103103 func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
104104 
105105 
106106 func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
107107 
108108 
109109 func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
110110 
111111 
112112 func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
113113 
114114 
115115 func keyEmissionStartBlock () = "%s%s__emission__startBlock"
116116 
117117 
118118 func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
119119 
120120 
121121 func keyEmissionEndBlock () = "%s%s__emission__endBlock"
122122 
123123 
124124 func keyNextPeriod () = "%s__nextPeriod"
125125 
126126 
127127 func keyGwxRewardEmissionStartHeight () = "%s%s__gwxRewardEmissionPart__startHeight"
128128 
129129 
130130 let IdxCfgAssetId = 1
131131 
132132 let IdxCfgMinLockAmount = 2
133133 
134134 let IdxCfgMinLockDuration = 3
135135 
136136 let IdxCfgMaxLockDuration = 4
137137 
138138 let IdxCfgMathContract = 5
139139 
140140 func keyConfig () = "%s__config"
141141 
142142 
143143 func readConfigArrayOrFail () = split(getStringOrFail(this, keyConfig()), SEP)
144144 
145145 
146146 func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
147147 
148148 
149149 func formatConfig (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = formatConfigS(assetId, toString(minLockAmount), toString(minLockDuration), toString(maxLockDuration), mathContract)
150150 
151151 
152152 let IdxLockUserNum = 1
153153 
154154 let IdxLockAmount = 2
155155 
156156 let IdxLockStart = 3
157157 
158158 let IdxLockDuration = 4
159159 
160160 let IdxLockParamK = 5
161161 
162162 let IdxLockParamB = 6
163163 
164164 func keyLockParamsRecord (userAddress) = makeString(["%s%s__lock", userAddress], SEP)
165165 
166166 
167167 func readLockParamsRecordOrFail (userAddress) = split(getStringOrFail(this, keyLockParamsRecord(userAddress)), SEP)
168168 
169169 
170170 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)
171171 
172172 
173173 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))
174174 
175175 
176176 func keyNextUserNum () = "%s__nextUserNum"
177177 
178178 
179179 func keyUser2NumMapping (userAddress) = makeString(["%s%s%s__mapping__user2num", userAddress], SEP)
180180 
181181 
182182 func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
183183 
184184 
185185 func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
186186 
187187 
188188 func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
189189 
190190 
191191 func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
192192 
193193 
194194 func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
195195 
196196 
197197 func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
198198 
199199 
200200 func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
201201 
202202 
203203 func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
204204 
205205 
206206 func keyLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"
207207 
208208 
209209 func keyStatsLocksDurationSumInBlocks () = "%s%s__stats__locksDurationSumInBlocks"
210210 
211211 
212212 func keyStatsLocksCount () = "%s%s__stats__locksCount"
213213 
214214 
215215 func keyStatsUsersCount () = "%s%s__stats__activeUsersCount"
216216 
217217 
218218 func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastInt", userNum], SEP)
219219 
220220 
221221 func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastInt", userNum, lpAssetId], SEP)
222222 
223223 
224224 func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
225225 
226226 
227227 func keyTotalMaxBoostINTEGRAL () = "%s%s__maxBoostInt__total"
228228 
229229 
230230 func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", userNum], SEP)
231231 
232232 
233233 func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", userNum], SEP)
234234 
235235 
236236 func keyUserBoostAvalaibleToClaimCached (userNum,lpAssetId) = makeString(["%s%d%s__userBoostAvaliableToClaim", userNum, lpAssetId], SEP)
237237 
238238 
239239 func keyTotalCachedGwx () = "%s%s__gwxCached__total"
240240 
241241 
242242 let factoryContract = readFactoryAddressOrFail()
243243 
244244 let factoryCfg = readFactoryCfgOrFail(factoryContract)
245245 
246246 let emissionContract = getEmissionAddressOrFail(factoryCfg)
247247 
248248 let stakingContract = getStakingAddressOrFail(factoryCfg)
249249 
250250 let gwxRewardContract = getGwxRewardAddressOrFail(factoryCfg)
251251 
252252 func HistoryEntry (type,user,amount,lockStart,duration,k,b,i) = {
253253     let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], SEP)
254254     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)
255255     StringEntry(historyKEY, historyDATA)
256256     }
257257 
258258 
259259 func StatsEntry (totalLockedInc,durationInc,lockCountInc,usersCountInc) = {
260260     let locksDurationSumInBlocksKEY = keyStatsLocksDurationSumInBlocks()
261261     let locksCountKEY = keyStatsLocksCount()
262262     let usersCountKEY = keyStatsUsersCount()
263263     let totalAmountKEY = keyLockParamTotalAmount()
264264     let locksDurationSumInBlocks = getIntOrZero(this, locksDurationSumInBlocksKEY)
265265     let locksCount = getIntOrZero(this, locksCountKEY)
266266     let usersCount = getIntOrZero(this, usersCountKEY)
267267     let totalAmount = getIntOrZero(this, totalAmountKEY)
268268 [IntegerEntry(locksDurationSumInBlocksKEY, (locksDurationSumInBlocks + durationInc)), IntegerEntry(locksCountKEY, (locksCount + lockCountInc)), IntegerEntry(usersCountKEY, (usersCount + usersCountInc)), IntegerEntry(totalAmountKEY, (totalAmount + totalLockedInc))]
269269     }
270270 
271271 
272272 func calcGwxAmount (kRaw,bRaw,h) = {
273273     let SCALE = 1000
274274     (((kRaw * h) + bRaw) / SCALE)
275275     }
276276 
277277 
278278 func LockParamsEntry (userAddress,userNum,amount,start,duration,k,b,period) = {
279279     let userAmountKEY = keyLockParamUserAmount(userNum)
280280     let startBlockKEY = keyLockParamStartBlock(userNum)
281281     let durationKEY = keyLockParamDuration(userNum)
282282     let kKEY = keyLockParamK(userNum)
283283     let bKEY = keyLockParamB(userNum)
284284     let kByPerioKEY = keyLockParamByPeriodK(userNum, period)
285285     let bByPeriodKEY = keyLockParamByPeriodB(userNum, period)
286286     let gwxAmount = calcGwxAmount(k, b, height)
287287 [IntegerEntry(userAmountKEY, amount), IntegerEntry(startBlockKEY, start), IntegerEntry(durationKEY, duration), IntegerEntry(kKEY, k), IntegerEntry(bKEY, b), IntegerEntry(kByPerioKEY, k), IntegerEntry(bByPeriodKEY, b), StringEntry(keyLockParamsRecord(userAddress), formatLockParamsRecord(userNum, amount, start, duration, k, b, gwxAmount))]
288288     }
289289 
290290 
291291 func extractOptionalPaymentAmountOrFail (i,expectedAssetId) = if ((size(i.payments) > 1))
292292     then throw("only one payment is allowed")
293293     else if ((size(i.payments) == 0))
294294         then 0
295295         else {
296296             let pmt = i.payments[0]
297297             if ((value(pmt.assetId) != expectedAssetId))
298298                 then throw("invalid asset id in payment")
299299                 else pmt.amount
300300             }
301301 
302302 
303303 func calcCurrentGwxAmount (userAddress) = {
304304     let EMPTY = "empty"
305305     let user2NumMappingKEY = keyUser2NumMapping(userAddress)
306306     let userNum = valueOrElse(getString(user2NumMappingKEY), EMPTY)
307307     let k = valueOrElse(getInteger(keyLockParamK(userNum)), 0)
308308     let b = valueOrElse(getInteger(keyLockParamB(userNum)), 0)
309309     let gwxAmountCalc = calcGwxAmount(k, b, height)
310310     let gwxAmount = if ((0 > gwxAmountCalc))
311311         then 0
312312         else gwxAmountCalc
313313     gwxAmount
314314     }
315315 
316316 
317317 func internalClaimWxBoost (lpAssetIdStr,userAddressStr,readOnly) = {
318318     let EMPTY = "EMPTY"
319319     let userRecordOrEmpty = valueOrElse(getString(this, keyLockParamsRecord(userAddressStr)), EMPTY)
320320     if ((userRecordOrEmpty == EMPTY))
321321         then $Tuple3(0, nil, "userRecord::is::empty")
322322         else {
323323             let userRecordArray = split(userRecordOrEmpty, SEP)
324324             let userNumStr = userRecordArray[IdxLockUserNum]
325325             let gwxRewardEmissionStartHeight = valueOrElse(getInteger(gwxRewardContract, keyGwxRewardEmissionStartHeight()), 0)
326326             let EMPTYSTR = "empty"
327327             let $t01252513093 = if ((lpAssetIdStr != EMPTYSTR))
328328                 then {
329329                     let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
330330                     let pw1 = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
331331                     let pw0 = valueOrElse(getInteger(factoryContract, keyFactoryPoolWeightHistory(poolAddressStr, 0)), pw1)
332332                     $Tuple2(pw0, pw1)
333333                     }
334334                 else if (readOnly)
335335                     then $Tuple2(0, 0)
336336                     else throw(("not readonly mode: unsupported lp asset " + lpAssetIdStr))
337337             let poolWeight0 = $t01252513093._1
338338             let poolWeight1 = $t01252513093._2
339339             let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
340340             let emissionStart = getIntOrFail(emissionContract, keyEmissionStartBlock())
341341             let emissionEnd = getIntOrFail(emissionContract, keyEmissionEndBlock())
342342             let h = if ((height > emissionEnd))
343343                 then emissionEnd
344344                 else height
345345             let dh = max([(h - emissionStart), 0])
346346             let userLpBoostEmissionLastIntegralKEY = keyUserLpBoostEmissionLastINTEGRAL(userNumStr, lpAssetIdStr)
347347             let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
348348             let userBoostEmissionLastIntegral = valueOrElse(getInteger(this, userLpBoostEmissionLastIntegralKEY), getIntOrZero(this, userBoostEmissionLastIntegralKEY))
349349             let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
350350             let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
351351             let udh = fraction(userBoostEmissionIntegral, 3, (2 * wxEmissionPerBlock))
352352             let uLastH = (h - udh)
353353             let udh0 = max([(gwxRewardEmissionStartHeight - uLastH), 0])
354354             let udh1 = ((h - uLastH) - udh0)
355355             if (if (if ((0 > uLastH))
356356                 then true
357357                 else (0 > udh1))
358358                 then true
359359                 else (abs(((udh0 + udh1) - udh)) >= 1))
360360                 then throw(((((((("invalid udh calc: udh=" + toString(udh)) + " uLastH=") + toString(uLastH)) + " udh0=") + toString(udh0)) + " udh1=") + toString(udh1)))
361361                 else if ((0 > userBoostEmissionIntegral))
362362                     then throw("wrong calculations")
363363                     else {
364364                         let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
365365                         let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
366366                         let userMaxBoostInt = getIntOrZero(this, userMaxBoostIntegralKEY)
367367                         let totalMaxBoostInt = getIntOrZero(this, totalMaxBoostIntegralKEY)
368368                         let totalCachedGwxKEY = keyTotalCachedGwx()
369369                         let totalCachedGwx = valueOrElse(getInteger(this, totalCachedGwxKEY), 0)
370370                         let userCurrGwx = calcCurrentGwxAmount(userAddressStr)
371371                         let userBoostAvalaibleToClaimTotalKEY = keyUserBoostAvalaibleToClaimTotal(userNumStr)
372372                         let userBoostEmissionIntg0 = if ((udh == 0))
373373                             then 0
374374                             else fraction(userBoostEmissionIntegral, udh0, udh)
375375                         let userBoostEmissionIntg1 = if ((udh == 0))
376376                             then 0
377377                             else fraction(userBoostEmissionIntegral, udh1, udh)
378378                         let poolUserBoostEmissionIntg0 = fraction(userBoostEmissionIntg0, poolWeight0, POOLWEIGHTMULT)
379379                         let poolUserBoostEmissionIntg1 = fraction(userBoostEmissionIntg1, poolWeight1, POOLWEIGHTMULT)
380380                         let userBoostAvaliableToClaimTotalNew0 = if ((totalCachedGwx == 0))
381381                             then 0
382382                             else fraction(poolUserBoostEmissionIntg0, userCurrGwx, totalCachedGwx)
383383                         let userBoostAvaliableToClaimTotalNew1 = if ((totalCachedGwx == 0))
384384                             then 0
385385                             else fraction(poolUserBoostEmissionIntg1, userCurrGwx, totalCachedGwx)
386386                         let userBoostAvalaibleToClaimCachedKEY = keyUserBoostAvalaibleToClaimCached(userNumStr, lpAssetIdStr)
387387                         let userBoostAvalaibleToClaimCached = valueOrElse(getInteger(this, userBoostAvalaibleToClaimCachedKEY), 0)
388388                         let userBoostAvaliableToClaimTotalNew = ((userBoostAvaliableToClaimTotalNew0 + userBoostAvaliableToClaimTotalNew1) + userBoostAvalaibleToClaimCached)
389389                         let dataState = [IntegerEntry(userLpBoostEmissionLastIntegralKEY, boostEmissionIntegral), IntegerEntry(userBoostAvalaibleToClaimCachedKEY, 0)]
390390                         let debug = makeString([("userBoostEmissionLastIntegral=" + toString(userBoostEmissionLastIntegral)), ("userBoostEmissionIntegral=" + toString(userBoostEmissionIntegral)), ("userBoostAvalaibleToClaimCached=" + toString(userBoostAvalaibleToClaimCached)), ("userBoostAvaliableToClaimTotalNew=" + toString(userBoostAvaliableToClaimTotalNew)), ("userBoostEmissionIntg0=" + toString(userBoostEmissionIntg0)), ("userBoostEmissionIntg1=" + toString(userBoostEmissionIntg1)), ("poolUserBoostEmissionIntg0=" + toString(poolUserBoostEmissionIntg0)), ("poolUserBoostEmissionIntg1=" + toString(poolUserBoostEmissionIntg1)), ("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))], "::")
391391                         $Tuple3(userBoostAvaliableToClaimTotalNew, dataState, debug)
392392                         }
393393             }
394394     }
395395 
396396 
397397 @Callable(i)
398398 func constructor (factoryAddressStr,lockAssetIdStr,minLockAmount,minDuration,maxDuration,mathContract) = if ((this != i.caller))
399399     then throw("not authorized")
400400     else ([IntegerEntry(keyNextUserNum(), 0), StringEntry(keyConfig(), formatConfig(lockAssetIdStr, minLockAmount, minDuration, maxDuration, mathContract)), StringEntry(keyFactoryAddress(), factoryAddressStr)] ++ StatsEntry(0, 0, 0, 0))
401401 
402402 
403403 
404404 @Callable(i)
405405 func lock (duration) = {
406406     let cfgArray = readConfigArrayOrFail()
407407     let assetIdStr = cfgArray[IdxCfgAssetId]
408408     let assetId = fromBase58String(assetIdStr)
409409     let minLockAmount = parseIntValue(cfgArray[IdxCfgMinLockAmount])
410410     let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
411411     let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
412412     let mathContract = addressFromStringValue(cfgArray[IdxCfgMathContract])
413413     if ((size(i.payments) != 1))
414414         then throw("invalid payment - exact one payment must be attached")
415415         else {
416416             let pmt = i.payments[0]
417417             let pmtAmount = pmt.amount
418418             if ((assetId != value(pmt.assetId)))
419419                 then throw((("invalid asset is in payment - " + assetIdStr) + " is expected"))
420420                 else {
421421                     let nextUserNumKEY = keyNextUserNum()
422422                     let userAddressStr = toString(i.caller)
423423                     let userIsExisting = isDefined(getString(keyUser2NumMapping(userAddressStr)))
424424                     let userNumStr = if (userIsExisting)
425425                         then value(getString(keyUser2NumMapping(userAddressStr)))
426426                         else toString(getIntOrFail(this, nextUserNumKEY))
427427                     let userNum = parseIntValue(userNumStr)
428428                     let lockStart = height
429429                     let startBlockKEY = keyLockParamStartBlock(userNumStr)
430430                     let durationKEY = keyLockParamDuration(userNumStr)
431431                     let userAmountKEY = keyLockParamUserAmount(userNumStr)
432432                     if ((minLockAmount > pmtAmount))
433433                         then throw(("amount is less then minLockAmount=" + toString(minLockAmount)))
434434                         else if ((minLockDuration > duration))
435435                             then throw(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
436436                             else if ((duration > maxLockDuration))
437437                                 then throw(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
438438                                 else if (if (userIsExisting)
439439                                     then ((getIntOrFail(this, startBlockKEY) + getIntOrFail(this, durationKEY)) >= lockStart)
440440                                     else false)
441441                                     then throw("there is an active lock - consider to use increaseLock")
442442                                     else if ((getIntOrZero(this, userAmountKEY) > 0))
443443                                         then throw(("there are locked WXs - consider to use increaseLock " + userAmountKEY))
444444                                         else {
445445                                             let coeffX8 = fraction(duration, MULT8, maxLockDuration)
446446                                             let gWxAmountStart = fraction(pmtAmount, coeffX8, MULT8)
447447                                             let gWxParamsResultList = asAnyList(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStart, duration], nil))
448448                                             let k = asInt(gWxParamsResultList[0])
449449                                             let b = asInt(gWxParamsResultList[1])
450450                                             let period = toString(asInt(gWxParamsResultList[2]))
451451                                             let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
452452                                             let emissionStart = getIntOrFail(emissionContract, keyEmissionStartBlock())
453453                                             let emissionEnd = getIntOrFail(emissionContract, keyEmissionEndBlock())
454454                                             let h = if ((height > emissionEnd))
455455                                                 then emissionEnd
456456                                                 else height
457457                                             let dh = max([(h - emissionStart), 0])
458458                                             let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
459459                                             let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
460460                                             let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
461461                                             let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
462462                                             let userMaxBoostInt = ((gWxAmountStart * duration) / 2)
463463                                             let totalMaxBoostInt = getIntOrZero(this, totalMaxBoostIntegralKEY)
464464                                             let totalCachedGwxKEY = keyTotalCachedGwx()
465465                                             let totalCachedGwx = valueOrElse(getInteger(this, totalCachedGwxKEY), 0)
466466                                             let arr = if (userIsExisting)
467467                                                 then nil
468468                                                 else [IntegerEntry(nextUserNumKEY, (userNum + 1)), StringEntry(keyUser2NumMapping(userAddressStr), userNumStr), StringEntry(keyNum2UserMapping(userNumStr), userAddressStr)]
469469                                             ((((arr ++ LockParamsEntry(userAddressStr, userNumStr, pmtAmount, lockStart, duration, k, b, period)) ++ StatsEntry(pmtAmount, duration, 1, if (userIsExisting)
470470                                                 then 0
471471                                                 else 1)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, duration, k, b, i)) ++ [IntegerEntry(userBoostEmissionLastIntegralKEY, boostEmissionIntegral), IntegerEntry(totalCachedGwxKEY, (totalCachedGwx + gWxAmountStart))])
472472                                             }
473473                     }
474474             }
475475     }
476476 
477477 
478478 
479479 @Callable(i)
480480 func increaseLock (deltaDuration) = {
481481     let cfgArray = readConfigArrayOrFail()
482482     let assetIdStr = cfgArray[IdxCfgAssetId]
483483     let assetId = fromBase58String(assetIdStr)
484484     let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
485485     let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
486486     let mathContract = addressFromStringValue(cfgArray[IdxCfgMathContract])
487487     let pmtAmount = extractOptionalPaymentAmountOrFail(i, assetId)
488488     let userAddressStr = toString(i.caller)
489489     let userRecordArray = readLockParamsRecordOrFail(userAddressStr)
490490     let userNumStr = userRecordArray[IdxLockUserNum]
491491     let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
492492     let lockStart = parseIntValue(userRecordArray[IdxLockStart])
493493     let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
494494     let lockEnd = (lockStart + lockDuration)
495495     let remainingDuration = max([(lockEnd - height), 0])
496496     let userAmountNew = (userAmount + pmtAmount)
497497     let lockDurationNew = (remainingDuration + deltaDuration)
498498     if ((0 > deltaDuration))
499499         then throw("duration is less then zero")
500500         else if ((minLockDuration > lockDurationNew))
501501             then throw(("lockDurationNew is less then minLockDuration=" + toString(minLockDuration)))
502502             else if ((lockDurationNew > maxLockDuration))
503503                 then throw(("deltaDuration + existedLockDuration is greater then maxLockDuration=" + toString(maxLockDuration)))
504504                 else {
505505                     let coeffX8 = fraction(lockDurationNew, MULT8, maxLockDuration)
506506                     let gWxAmountStart = fraction(userAmountNew, coeffX8, MULT8)
507507                     let lockStartNew = height
508508                     let gWxParamsResultList = asAnyList(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStartNew, lockDurationNew], nil))
509509                     let k = asInt(gWxParamsResultList[0])
510510                     let b = asInt(gWxParamsResultList[1])
511511                     let period = toString(asInt(gWxParamsResultList[2]))
512512                     let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
513513                     let emissionStart = getIntOrFail(emissionContract, keyEmissionStartBlock())
514514                     let emissionEnd = getIntOrFail(emissionContract, keyEmissionEndBlock())
515515                     let h = if ((height > emissionEnd))
516516                         then emissionEnd
517517                         else height
518518                     let dh = max([(h - emissionStart), 0])
519519                     let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
520520                     let userBoostEmissionLastIntegral = getIntOrZero(this, userBoostEmissionLastIntegralKEY)
521521                     let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
522522                     let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
523523                     if ((0 > userBoostEmissionIntegral))
524524                         then throw("wrong calculations")
525525                         else {
526526                             let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
527527                             let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
528528                             let userMaxBoostInt = getIntOrZero(this, userMaxBoostIntegralKEY)
529529                             let totalMaxBoostInt = getIntOrZero(this, totalMaxBoostIntegralKEY)
530530                             let currUserGwx = calcCurrentGwxAmount(userAddressStr)
531531                             let gwxDiff = (gWxAmountStart - currUserGwx)
532532                             if ((0 > gwxDiff))
533533                                 then throw(("gwxDiff is less then 0: " + toString(gwxDiff)))
534534                                 else {
535535                                     let totalCachedGwxKEY = keyTotalCachedGwx()
536536                                     let totalCachedGwx = valueOrElse(getInteger(this, totalCachedGwxKEY), 0)
537537                                     let userBoostAvalaibleToClaimTotalKEY = keyUserBoostAvalaibleToClaimTotal(userNumStr)
538538                                     let userBoostAvaliableToClaimTotal = getIntOrZero(this, userBoostAvalaibleToClaimTotalKEY)
539539                                     let userBoostAvaliableToClaimTotalNew = fraction(userBoostEmissionIntegral, currUserGwx, totalCachedGwx)
540540                                     let userMaxBoostIntNew = ((gWxAmountStart * lockDurationNew) / 2)
541541                                     let remainingUserMaxBoostInt = ((currUserGwx * remainingDuration) / 2)
542542                                     let userMaxBoostIntDiff = (userMaxBoostIntNew - remainingUserMaxBoostInt)
543543                                     (((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))])
544544                                     }
545545                             }
546546                     }
547547     }
548548 
549549 
550550 
551551 @Callable(i)
552552 func claimWxBoost (lpAssetIdStr,userAddressStr) = if ((stakingContract != i.caller))
553553     then throw("permissions denied")
554554     else {
555555         let $t02691127013 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, false)
556556         let userBoostAvailable = $t02691127013._1
557557         let dataState = $t02691127013._2
558558         let debug = $t02691127013._3
559559         $Tuple2(dataState, [userBoostAvailable])
560560         }
561561 
562562 
563563 
564564 @Callable(i)
565565 func claimWxBoostREADONLY (lpAssetIdStr,userAddressStr) = {
566566     let $t02714527246 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, true)
567567     let userBoostAvailable = $t02714527246._1
568568     let dataState = $t02714527246._2
569569     let debug = $t02714527246._3
570570     $Tuple2(nil, [userBoostAvailable, debug])
571571     }
572572 
573573 
574574 
575575 @Callable(i)
576576 func unlock (userAddress) = {
577577     let userRecordArray = readLockParamsRecordOrFail(userAddress)
578578     let userNumStr = userRecordArray[IdxLockUserNum]
579579     let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
580580     let lockStart = parseIntValue(userRecordArray[IdxLockStart])
581581     let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
582582     let lockEnd = (lockStart + lockDuration)
583583     let cfgArray = readConfigArrayOrFail()
584584     let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
585585     let mathContract = addressFromStringValue(cfgArray[IdxCfgMathContract])
586586     if ((lockEnd >= height))
587587         then throw((("wait " + toString(lockEnd)) + " to unlock"))
588588         else if ((0 >= userAmount))
589589             then throw("nothing to unlock")
590590             else {
591591                 let period = valueOrElse(getInteger(mathContract, keyNextPeriod()), 0)
592592                 (((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))
593593                 }
594594     }
595595 
596596 
597597 
598598 @Callable(i)
599599 func gwxUserInfoREADONLY (userAddress) = {
600600     let gwxAmount = calcCurrentGwxAmount(userAddress)
601601     $Tuple2(nil, [gwxAmount])
602602     }
603603 
604604 
605605 
606606 @Callable(i)
607-func normalizeBeforeUnlockAndBurn () = if ((i.caller != this))
608-    then throw("permissions denied")
609-    else {
610-        let tot = getIntOrFail(this, keyNextUserNum())
611-        let lps = split(getStringOrFail(factoryContract, keyFactoryLpList()), SEP)
612-        let nextK = "%s__nextUser2Normalaize"
613-        let uN = valueOrElse(getInteger(this, nextK), 0)
614-        if ((uN == tot))
615-            then throw("normalization is finished")
616-            else {
617-                let uS = toString(uN)
618-                let u = getStringOrFail(this, keyNum2UserMapping(uS))
619-                let lp0 = lps[0]
620-                let $t02916129215 = internalClaimWxBoost(lp0, u, true)
621-                let b0 = $t02916129215._1
622-                let ds0 = $t02916129215._2
623-                let d0 = $t02916129215._3
624-                let bK0 = keyUserBoostAvalaibleToClaimCached(uS, lp0)
625-                let lp1 = lps[1]
626-                let $t02929329347 = internalClaimWxBoost(lp1, u, true)
627-                let b1 = $t02929329347._1
628-                let ds1 = $t02929329347._2
629-                let d1 = $t02929329347._3
630-                let bK1 = keyUserBoostAvalaibleToClaimCached(uS, lp1)
631-                let lp2 = lps[2]
632-                let $t02942529479 = internalClaimWxBoost(lp2, u, true)
633-                let b2 = $t02942529479._1
634-                let ds2 = $t02942529479._2
635-                let d2 = $t02942529479._3
636-                let bK2 = keyUserBoostAvalaibleToClaimCached(uS, lp2)
637-                let lp3 = lps[3]
638-                let $t02955729611 = internalClaimWxBoost(lp3, u, true)
639-                let b3 = $t02955729611._1
640-                let ds3 = $t02955729611._2
641-                let d3 = $t02955729611._3
642-                let bK3 = keyUserBoostAvalaibleToClaimCached(uS, lp3)
643-                let lp4 = lps[4]
644-                let $t02968929743 = internalClaimWxBoost(lp4, u, true)
645-                let b4 = $t02968929743._1
646-                let ds4 = $t02968929743._2
647-                let d4 = $t02968929743._3
648-                let bK4 = keyUserBoostAvalaibleToClaimCached(uS, lp4)
649-[IntegerEntry(nextK, (uN + 1)), IntegerEntry(bK0, b0), IntegerEntry(bK1, b1), IntegerEntry(bK2, b2), IntegerEntry(bK3, b3), IntegerEntry(bK4, b4), ds0[0], ds1[0], ds2[0], ds3[0], ds4[0]]
650-                }
651-        }
607+func unlockEarlyAndBurn () = {
608+    let cfgArray = readConfigArrayOrFail()
609+    let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
610+    let mathContract = addressFromStringValue(cfgArray[IdxCfgMathContract])
611+    let userAddress = toString(i.caller)
612+    let userRecordArray = readLockParamsRecordOrFail(userAddress)
613+    let userNumStr = userRecordArray[IdxLockUserNum]
614+    let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
615+    let lockStart = parseIntValue(userRecordArray[IdxLockStart])
616+    let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
617+    let lockEnd = (lockStart + lockDuration)
618+    let remainingDuration = max([(lockEnd - height), 0])
619+    let totalCachedGwxKEY = keyTotalCachedGwx()
620+    let totalCachedGwx = valueOrElse(getInteger(this, totalCachedGwxKEY), 0)
621+    if ((0 >= userAmount))
622+        then throw("nothing to unlock")
623+        else {
624+            let period = valueOrElse(getInteger(mathContract, keyNextPeriod()), 0)
625+            let currUserGwx = calcCurrentGwxAmount(userAddress)
626+            let burn = invoke(emissionContract, "burn", nil, [AttachedPayment(assetId, userAmount)])
627+            if ((burn == burn))
628+                then (((LockParamsEntry(userAddress, userNumStr, 0, 0, 0, 0, 0, toString(period)) ++ StatsEntry(-(userAmount), 0, 0, -1)) :+ HistoryEntry("unlock", userAddress, userAmount, lockStart, lockDuration, 0, 0, i)) :+ IntegerEntry(totalCachedGwxKEY, (totalCachedGwx - currUserGwx)))
629+                else throw("Strict value is not equal to itself.")
630+            }
631+    }
652632 
653633 
github/deemru/w8io/786bc32 
80.19 ms ◑