tx · GVfqpGpr5Pas63M2J6AdHTuu5MMK9nmtK84RxRb5v4xb

3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz:  -0.03000000 Waves

2022.07.28 18:08 [2159833] smart account 3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "GVfqpGpr5Pas63M2J6AdHTuu5MMK9nmtK84RxRb5v4xb",
    "fee": 3000000,
    "feeAssetId": null,
    "timestamp": 1659020914584,
    "version": 1,
    "sender": "3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz",
    "senderPublicKey": "D28XoueZWsMfm8Y5pa6C5ZFuYoWgre2Wm8tzJANJgMnq",
    "proofs": [
        "4NDxR5Jmv3uo5GMci2TpT6DCH9u94sAJyrV23wWai7Lk73YeeHcf6bg98jxeUVWQ8JnxRFq5nxBYA4vfKViPqAwG"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2159833,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: Bk5h8zFgCABB9hXvyciKn5bmdScm19A2zfyTDU3mkLeo
Next: 861fPL9byvMuJb2nMZMC2Ty7re92WrN1HXvHjN1P9gQ3

Diff: 

OldNewDifferences
527527         else unit
528528     if ((r == r))
529529         then if ((amount > stakedByUser))
530-            then throw("passed amount is less then available")
530+            then throw(((("passed amount=" + toString(amount)) + " is less then available=") + toString(stakedByUser)))
531531             else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(i.caller, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
532532         else throw("Strict value is not equal to itself.")
533533     }
558558             let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
559559             let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
560560             let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
561-            let $t02259022702 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
562-            let wxToClaimUserNew = $t02259022702._1
563-            let integralSTATE = $t02259022702._2
564-            let debug = $t02259022702._3
561+            let $t02263722749 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
562+            let wxToClaimUserNew = $t02263722749._1
563+            let integralSTATE = $t02263722749._2
564+            let debug = $t02263722749._3
565565             let availableToClaim = max([(wxToClaimUserNew - claimedByUser), zeroBigInt])
566566             if ((zeroBigInt >= availableToClaim))
567567                 then throw("nothing to claim")
639639         else (height - emissionStartBlock)
640640     let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
641641     let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
642-    let $t02616026272 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
643-    let wxToClaimUserNew = $t02616026272._1
644-    let integralSTATE = $t02616026272._2
645-    let debug = $t02616026272._3
642+    let $t02620726319 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
643+    let wxToClaimUserNew = $t02620726319._1
644+    let integralSTATE = $t02620726319._2
645+    let debug = $t02620726319._3
646646     let availableToClaim = max([(wxToClaimUserNew - claimedByUser), zeroBigInt])
647647     let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
648648     let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
709709 func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
710710     then throw("permissions denied")
711711     else {
712-        let $t02857228682 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
713-        let wxPerLpIntegralNew = $t02857228682._1
714-        let poolIntegralSTATE = $t02857228682._2
715-        let poolDEBUG = $t02857228682._3
712+        let $t02861928729 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
713+        let wxPerLpIntegralNew = $t02861928729._1
714+        let poolIntegralSTATE = $t02861928729._2
715+        let poolDEBUG = $t02861928729._3
716716         poolIntegralSTATE
717717         }
718718 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SCALE8 = 8
55 
66 let MULT8 = 100000000
77 
88 let SCALE18 = 18
99 
1010 let MULT18 = toBigInt(1000000000000000000)
1111 
1212 let SEP = "__"
1313 
1414 let POOLWEIGHTMULT = MULT8
1515 
1616 let zeroBigInt = toBigInt(0)
1717 
1818 let oneBigInt = toBigInt(1)
1919 
2020 func asAnyList (val) = match val {
2121     case valAnyLyst: List[Any] => 
2222         valAnyLyst
2323     case _ => 
2424         throw("fail to cast into List[Any]")
2525 }
2626 
2727 
2828 func asInt (val) = match val {
2929     case valInt: Int => 
3030         valInt
3131     case _ => 
3232         throw("fail to cast into Int")
3333 }
3434 
3535 
3636 func asString (val) = match val {
3737     case valStr: String => 
3838         valStr
3939     case _ => 
4040         throw("fail to cast into Int")
4141 }
4242 
4343 
4444 func asByteVector (val) = match val {
4545     case valBin: ByteVector => 
4646         valBin
4747     case _ => 
4848         throw("fail to cast into Int")
4949 }
5050 
5151 
5252 func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
5353 
5454 
5555 func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), (((("mandatory " + toString(address)) + ".") + key) + " is not defined"))
5656 
5757 
5858 func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
5959 
6060 
6161 func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
6262 
6363 
6464 func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
6565 
6666 
6767 func getBigIntFromStringOrZero (address,key) = value(parseBigInt(valueOrElse(getString(address, key), "0")))
6868 
6969 
7070 func getBigIntFromStringOrDefault (address,key,defaultVal) = match getString(address, key) {
7171     case s: String => 
7272         value(parseBigInt(s))
7373     case _: Unit => 
7474         defaultVal
7575     case _ => 
7676         throw("Match error")
7777 }
7878 
7979 
8080 func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), MULT18, toBigInt(origScaleMult))
8181 
8282 
8383 func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), MULT18))
8484 
8585 
8686 func keyFactoryAddress () = "%s%s__config__factoryAddress"
8787 
8888 
8989 func keyVotingEmissionContract () = "%s__votingEmissionContract"
9090 
9191 
9292 let IdxFactoryCfgStakingDapp = 1
9393 
9494 let IdxFactoryCfgBoostingDapp = 2
9595 
9696 let IdxFactoryCfgIdoDapp = 3
9797 
9898 let IdxFactoryCfgTeamDapp = 4
9999 
100100 let IdxFactoryCfgEmissionDapp = 5
101101 
102102 let IdxFactoryCfgRestDapp = 6
103103 
104104 let IdxFactoryCfgSlippageDapp = 7
105105 
106106 func keyFactoryCfg () = "%s__factoryConfig"
107107 
108108 
109109 func keyManagerPublicKey () = "%s__managerPublicKey"
110110 
111111 
112112 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
113113 
114114 
115115 func keyStablePoolAddonAddr () = "%s__stablePoolAddonAddr"
116116 
117117 
118118 func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
119119 
120120 
121121 func keyFactoryLpList () = "%s__lpTokensList"
122122 
123123 
124124 func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
125125 
126126 
127127 func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
128128 
129129 
130130 func readLpList (factory) = split(valueOrElse(getString(factory, keyFactoryLpList()), ""), SEP)
131131 
132132 
133133 func readFactoryCfgOrFail (factory) = split(getStringByAddressOrFail(factory, keyFactoryCfg()), SEP)
134134 
135135 
136136 func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
137137 
138138 
139139 func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
140140 
141141 
142142 func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
143143 
144144 
145145 func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
146146 
147147 
148148 func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
149149 
150150 
151151 func keyEmissionStartBlock () = "%s%s__emission__startBlock"
152152 
153153 
154154 func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
155155 
156156 
157157 func keyEmissionEndBlock () = "%s%s__emission__endBlock"
158158 
159159 
160160 func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s__staked", userAddressStr, lpAssetIdStr], SEP)
161161 
162162 
163163 func keyStakedTotal (lpAssetIdStr) = ("%s%s%s__staked__total__" + lpAssetIdStr)
164164 
165165 
166166 func keyClaimedByUser (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimed", userAddressStr, lpAssetIdStr], SEP)
167167 
168168 
169169 func keyClaimedByUserMinReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedMinReward", userAddressStr, lpAssetIdStr], SEP)
170170 
171171 
172172 func keyClaimedByUserBoostReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedBoostReward", userAddressStr, lpAssetIdStr], SEP)
173173 
174174 
175175 func keyClaimedTotal (lpAssetIdStr) = makeString(["%s%s%s__claimed__total", lpAssetIdStr], SEP)
176176 
177177 
178178 func readStaked (key) = valueOrElse(getInteger(this, key), 0)
179179 
180180 
181181 func keyLastTotalLpBalance (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "bal"], SEP)
182182 
183183 
184184 func keyLastUserLpBalance (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "bal"], SEP)
185185 
186186 
187187 func keyTotalLpBalanceIntegral (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "balINT"], SEP)
188188 
189189 
190190 func keyUserLpBalanceIntegral (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "balINT"], SEP)
191191 
192192 
193193 func keyTotalLpBalanceIntegralLastUpdHeight (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "lastUpd"], SEP)
194194 
195195 
196196 func keyUserLpBalanceIntegralLastUpdHeight (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "lastUpd"], SEP)
197197 
198198 
199199 func keyWxPerLpIntegral (lpAssetId) = makeString(["%s%s%s%s", lpAssetId, "common", "lpInt"], SEP)
200200 
201201 
202202 func keyWxPerLpIntegralLastUpdHeight (lpAssetId) = makeString(["%s%s%s%s", lpAssetId, "common", "lpIntH"], SEP)
203203 
204204 
205205 func keyWxToClaimUser (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "lpInt"], SEP)
206206 
207207 
208208 func keyWxPerLpIntegralUserLastUpdHeight (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "lpIntH"], SEP)
209209 
210210 
211211 func keyWxPerLp (lpAssetId) = makeString(["%s", lpAssetId, "wxPerLp"], SEP)
212212 
213213 
214214 func keyWxPerLpX18 (lpAssetId) = makeString(["%s", lpAssetId, "wxPerLpX18"], SEP)
215215 
216216 
217217 func keyWxPerLpIntegralUserLast (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "uIntL"], SEP)
218218 
219219 
220220 func keyOperationHistoryRecord (type,userAddress,txId58) = makeString(["%s%s%s%s__history", type, userAddress, txId58], SEP)
221221 
222222 
223223 func formatHistoryRecord (userAddress,lpAssetId,type,amount) = makeString(["%s%s%s%d%d%d", userAddress, lpAssetId, type, toString(height), toString(lastBlock.timestamp), toString(amount)], SEP)
224224 
225225 
226226 func OperationHistoryEntry (type,userAddress,lpAssetId,amount,txId) = StringEntry(keyOperationHistoryRecord(type, userAddress, toBase58String(txId)), formatHistoryRecord(userAddress, lpAssetId, type, amount))
227227 
228228 
229229 let factoryAddress = getStringOrFail(this, keyFactoryAddress())
230230 
231231 let factoryContract = addressFromStringValue(factoryAddress)
232232 
233233 let factoryCfg = readFactoryCfgOrFail(factoryContract)
234234 
235235 let emissionContract = getEmissionAddressOrFail(factoryCfg)
236236 
237237 let boostingContract = getBoostingAddressOrFail(factoryCfg)
238238 
239239 func keyNextUser (lpAssetId) = makeString(["%s%s", lpAssetId, "nextUser"], SEP)
240240 
241241 
242242 func getUsersListName (lpAssetId) = makeString(["users", lpAssetId], SEP)
243243 
244244 
245245 func keyListHead (listName) = makeString(["%s%s%s", listName, "head"], SEP)
246246 
247247 
248248 func keyListSize (listName) = makeString(["%s%s%s", listName, "size"], SEP)
249249 
250250 
251251 func keyListPrev (listName,id) = makeString(["%s%s%s%s", listName, id, "prev"], SEP)
252252 
253253 
254254 func keyListNext (listName,id) = makeString(["%s%s%s%s", listName, id, "next"], SEP)
255255 
256256 
257257 func containsNode (listName,id) = {
258258     let headOrUnit = getString(this, keyListHead(listName))
259259     let prevOrUnit = getString(this, keyListPrev(listName, id))
260260     let nextOrUnit = getString(this, keyListNext(listName, id))
261261     if (if ((id == valueOrElse(headOrUnit, "")))
262262         then true
263263         else (prevOrUnit != unit))
264264         then true
265265         else (nextOrUnit != unit)
266266     }
267267 
268268 
269269 func insertNodeActions (listName,id) = {
270270     let headOrUnit = getString(this, keyListHead(listName))
271271     let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
272272     let checkNode = if (!(containsNode(listName, id)))
273273         then true
274274         else throw("Node exists")
275275     if ((checkNode == checkNode))
276276         then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
277277             then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]
278278             else nil)) ++ [StringEntry(keyListHead(listName), id)])
279279         else throw("Strict value is not equal to itself.")
280280     }
281281 
282282 
283283 func deleteNodeActions (listName,id) = {
284284     let headOrUnit = getString(this, keyListHead(listName))
285285     let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
286286     let prevOrUnit = getString(this, keyListPrev(listName, id))
287287     let nextOrUnit = getString(this, keyListNext(listName, id))
288288     ([IntegerEntry(keyListSize(listName), (listSize - 1))] ++ (if (if ((prevOrUnit != unit))
289289         then (nextOrUnit != unit)
290290         else false)
291291         then [StringEntry(keyListNext(listName, value(prevOrUnit)), value(nextOrUnit)), StringEntry(keyListPrev(listName, value(nextOrUnit)), value(prevOrUnit)), DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, id))]
292292         else if ((nextOrUnit != unit))
293293             then [StringEntry(keyListHead(listName), value(nextOrUnit)), DeleteEntry(keyListNext(listName, id)), DeleteEntry(keyListPrev(listName, value(nextOrUnit)))]
294294             else if ((prevOrUnit != unit))
295295                 then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
296296                 else if ((id == valueOrElse(headOrUnit, "")))
297297                     then [DeleteEntry(keyListHead(listName))]
298298                     else throw(((("invalid node: " + listName) + ".") + id))))
299299     }
300300 
301301 
302302 func calcWxPerLpIntegralUserLast (stakedByUser,wxPerLpIntegralUserLastUpdHeightOrZero,wxPerLpIntegralNew,wxPerLpIntegralUserLastKEY) = if (if ((wxPerLpIntegralUserLastUpdHeightOrZero == zeroBigInt))
303303     then (stakedByUser > zeroBigInt)
304304     else false)
305305     then zeroBigInt
306306     else if ((stakedByUser == zeroBigInt))
307307         then wxPerLpIntegralNew
308308         else if (if ((wxPerLpIntegralUserLastUpdHeightOrZero > zeroBigInt))
309309             then (stakedByUser > zeroBigInt)
310310             else false)
311311             then value(parseBigInt(getStringOrFail(this, wxPerLpIntegralUserLastKEY)))
312312             else throw("calcWxPerLpIntegralUserLast: unexpected state")
313313 
314314 
315315 func refreshPoolINTEGRALS (lpAssetIdStr,poolAddressStr,lpDeltaAmount) = {
316316     let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
317317     let stakedTotal = toBigInt(readStaked(stakedTotalKEY))
318318     let nonZeroStakedTotal = if ((stakedTotal == zeroBigInt))
319319         then oneBigInt
320320         else stakedTotal
321321     let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
322322     let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
323323     let MULT3 = 1000
324324     let wxEmissionPerBlockX3 = (getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent()) * MULT3)
325325     let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * 3))
326326     let wxPerLpIntegralKEY = keyWxPerLpIntegral(lpAssetIdStr)
327327     let wxPerLpIntegralLastUpdHeightKEY = keyWxPerLpIntegralLastUpdHeight(lpAssetIdStr)
328328     let wxPerLpKEY = keyWxPerLp(lpAssetIdStr)
329329     let wxPerLpIntegralLastUpdHeight = getIntOrDefault(this, wxPerLpIntegralLastUpdHeightKEY, emissionStartBlock)
330330     let wxPerLpIntegral = getBigIntFromStringOrZero(this, wxPerLpIntegralKEY)
331331     let wxPerLpOrZeroX3 = 0
332332     let dh = max([(height - wxPerLpIntegralLastUpdHeight), 0])
333333     let wxPerLpX3 = if ((wxPerLpOrZeroX3 != 0))
334334         then toBigInt(wxPerLpOrZeroX3)
335335         else fraction(toBigInt(poolWxEmissionPerBlockX3), toBigInt(MULT8), nonZeroStakedTotal)
336336     let stakedTotalNew = (stakedTotal + toBigInt(lpDeltaAmount))
337337     let nonZeroStakedTotalNew = if ((stakedTotalNew == zeroBigInt))
338338         then oneBigInt
339339         else stakedTotalNew
340340     let wxPerLpIntegralNew = (wxPerLpIntegral + (wxPerLpX3 * toBigInt(dh)))
341341     let wxPerLpX3New = (toBigInt(poolWxEmissionPerBlockX3) / nonZeroStakedTotalNew)
342342     let wxPerLpIntegralLastUpdHeightNew = height
343343     let debug = makeString([toString(wxPerLpIntegralNew), toString(dh), toString(wxPerLpX3), toString(stakedTotal), toString(poolWxEmissionPerBlockX3), toString(wxEmissionPerBlockX3), toString(poolWeight)], "::")
344344     $Tuple3(wxPerLpIntegralNew, [StringEntry(wxPerLpIntegralKEY, toString(wxPerLpIntegralNew)), IntegerEntry(wxPerLpIntegralLastUpdHeightKEY, wxPerLpIntegralLastUpdHeightNew), StringEntry(wxPerLpKEY, toString(wxPerLpX3New))], debug)
345345     }
346346 
347347 
348348 func refreshINTEGRALS (lpAssetIdStr,userAddressStr,poolAddressStr,lpDeltaAmount) = {
349349     let $t01421714339 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
350350     let wxPerLpIntegralNew = $t01421714339._1
351351     let poolIntegralSTATE = $t01421714339._2
352352     let poolDEBUG = $t01421714339._3
353353     let MULT3 = 1000
354354     let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
355355     let stakedByUser = readStaked(stakedByUserKEY)
356356     let wxToClaimUserKEY = keyWxToClaimUser(lpAssetIdStr, userAddressStr)
357357     let wxPerLpIntegralUserLastUpdHeightKEY = keyWxPerLpIntegralUserLastUpdHeight(lpAssetIdStr, userAddressStr)
358358     let wxPerLpIntegralUserLastKEY = keyWxPerLpIntegralUserLast(lpAssetIdStr, userAddressStr)
359359     let wxToClaimUser = getBigIntFromStringOrZero(this, wxToClaimUserKEY)
360360     let wxPerLpIntegralUserLastUpdHeightOrZero = getIntOrZero(this, wxPerLpIntegralUserLastUpdHeightKEY)
361361     let wxPerLpIntegralUserLast = calcWxPerLpIntegralUserLast(toBigInt(stakedByUser), toBigInt(wxPerLpIntegralUserLastUpdHeightOrZero), wxPerLpIntegralNew, wxPerLpIntegralUserLastKEY)
362362     let MULT11 = (MULT8 * MULT3)
363363     let wxToClaimUserNew = max([(wxToClaimUser + fraction((wxPerLpIntegralNew - wxPerLpIntegralUserLast), toBigInt(stakedByUser), toBigInt(MULT11))), zeroBigInt])
364364     let wxPerLpIntegralUserLastNew = wxPerLpIntegralNew
365365     let wxPerLpIntegralUserLastUpdHeightNew = height
366366     let debug = makeString([toString(wxToClaimUser), toString(wxPerLpIntegralUserLast), toString(stakedByUser), poolDEBUG, toString(height)], "::")
367367     $Tuple3(wxToClaimUserNew, (poolIntegralSTATE ++ [StringEntry(wxToClaimUserKEY, toString(wxToClaimUserNew)), IntegerEntry(wxPerLpIntegralUserLastUpdHeightKEY, wxPerLpIntegralUserLastUpdHeightNew), StringEntry(wxPerLpIntegralUserLastKEY, toString(wxPerLpIntegralUserLastNew))]), debug)
368368     }
369369 
370370 
371371 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
372372     case s: String => 
373373         fromBase58String(s)
374374     case _: Unit => 
375375         unit
376376     case _ => 
377377         throw("Match error")
378378 }
379379 
380380 
381381 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
382382     case s: String => 
383383         fromBase58String(s)
384384     case _: Unit => 
385385         unit
386386     case _ => 
387387         throw("Match error")
388388 }
389389 
390390 
391391 let permissionDeniedError = throw("Permission denied")
392392 
393393 func mustThis (i) = if ((i.caller == this))
394394     then true
395395     else permissionDeniedError
396396 
397397 
398398 func mustManager (i) = match managerPublicKeyOrUnit() {
399399     case pk: ByteVector => 
400400         if ((i.callerPublicKey == pk))
401401             then true
402402             else permissionDeniedError
403403     case _: Unit => 
404404         if ((i.caller == this))
405405             then true
406406             else permissionDeniedError
407407     case _ => 
408408         throw("Match error")
409409 }
410410 
411411 
412412 @Callable(i)
413413 func constructor (factoryAddressStr) = {
414414     let checkCaller = mustManager(i)
415415     if ((checkCaller == checkCaller))
416416         then [StringEntry(keyFactoryAddress(), factoryAddressStr)]
417417         else throw("Strict value is not equal to itself.")
418418     }
419419 
420420 
421421 
422422 @Callable(i)
423423 func constructorV2 (votingEmissionContract) = {
424424     let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
425425         then true
426426         else "invalid voting emission contract address"]
427427     if ((cheks == cheks))
428428         then [StringEntry(keyVotingEmissionContract(), votingEmissionContract)]
429429         else throw("Strict value is not equal to itself.")
430430     }
431431 
432432 
433433 
434434 @Callable(i)
435435 func setManager (pendingManagerPublicKey) = {
436436     let checkCaller = mustManager(i)
437437     if ((checkCaller == checkCaller))
438438         then {
439439             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
440440             if ((checkManagerPublicKey == checkManagerPublicKey))
441441                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
442442                 else throw("Strict value is not equal to itself.")
443443             }
444444         else throw("Strict value is not equal to itself.")
445445     }
446446 
447447 
448448 
449449 @Callable(i)
450450 func confirmManager () = {
451451     let pm = pendingManagerPublicKeyOrUnit()
452452     let hasPM = if (isDefined(pm))
453453         then true
454454         else throw("No pending manager")
455455     if ((hasPM == hasPM))
456456         then {
457457             let checkPM = if ((i.callerPublicKey == value(pm)))
458458                 then true
459459                 else throw("You are not pending manager")
460460             if ((checkPM == checkPM))
461461                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
462462                 else throw("Strict value is not equal to itself.")
463463             }
464464         else throw("Strict value is not equal to itself.")
465465     }
466466 
467467 
468468 
469469 @Callable(i)
470470 func stake () = if ((size(i.payments) != 1))
471471     then throw("invalid payment - exact one payment must be attached")
472472     else {
473473         let pmt = i.payments[0]
474474         let lpAssetId = value(pmt.assetId)
475475         let lpAssetIdStr = toBase58String(lpAssetId)
476476         let amount = pmt.amount
477477         let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
478478         let callerStr = toString(i.caller)
479479         let userAddressStr = if ((callerStr == poolAddressStr))
480480             then toString(i.originCaller)
481481             else callerStr
482482         let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
483483         let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
484484         let stakedByUser = readStaked(stakedByUserKEY)
485485         let stakedTotal = readStaked(stakedTotalKEY)
486486         let $t01877518892 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
487487         let wxToClaimUserNew = $t01877518892._1
488488         let integralSTATE = $t01877518892._2
489489         let debug = $t01877518892._3
490490         let listName = getUsersListName(lpAssetIdStr)
491491         let listActions = if (containsNode(listName, userAddressStr))
492492             then nil
493493             else insertNodeActions(listName, userAddressStr)
494494         (([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
495495         }
496496 
497497 
498498 
499499 @Callable(i)
500500 func unstake (lpAssetIdStr,amount) = {
501501     let lpAssetId = fromBase58String(lpAssetIdStr)
502502     let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
503503     let poolAddon = valueOrElse(getString(this, keyStablePoolAddonAddr()), poolAddressStr)
504504     let callerStr = toString(i.caller)
505505     let userAddressStr = if (if ((callerStr == poolAddressStr))
506506         then true
507507         else (callerStr == poolAddon))
508508         then toString(i.originCaller)
509509         else callerStr
510510     let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
511511     let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
512512     let stakedByUser = readStaked(stakedByUserKEY)
513513     let stakedTotal = readStaked(stakedTotalKEY)
514514     let integralSTATE = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, -(amount))._2
515515     let listName = getUsersListName(lpAssetIdStr)
516516     let listActions = if (if (containsNode(listName, userAddressStr))
517517         then (amount == stakedByUser)
518518         else false)
519519         then deleteNodeActions(listName, userAddressStr)
520520         else nil
521521     let claimedByUser = getBigIntFromStringOrZero(this, keyClaimedByUser(lpAssetIdStr, userAddressStr))
522522     let poolAddress = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
523523     let wxToClaimUserNew = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddress, 0)._1
524524     let availableToClaim = (wxToClaimUserNew - claimedByUser)
525525     let r = if ((availableToClaim > zeroBigInt))
526526         then invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr], nil)
527527         else unit
528528     if ((r == r))
529529         then if ((amount > stakedByUser))
530-            then throw("passed amount is less then available")
530+            then throw(((("passed amount=" + toString(amount)) + " is less then available=") + toString(stakedByUser)))
531531             else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(i.caller, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
532532         else throw("Strict value is not equal to itself.")
533533     }
534534 
535535 
536536 
537537 @Callable(i)
538538 func claimWx (lpAssetIdStr) = {
539539     let userAddressStr = toString(i.caller)
540540     let result = invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr], nil)
541541     $Tuple2(nil, result)
542542     }
543543 
544544 
545545 
546546 @Callable(i)
547547 func claimWxINTERNAL (lpAssetIdStr,userAddressStr) = {
548548     let checkCaller = mustThis(i)
549549     if ((checkCaller == checkCaller))
550550         then {
551551             let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), "claimWxINTERNAL: invalid user address")
552552             let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
553553             let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
554554             let claimedTotalKEY = keyClaimedTotal(lpAssetIdStr)
555555             let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
556556             let claimedByUserBoostRewardKEY = keyClaimedByUserBoostReward(lpAssetIdStr, userAddressStr)
557557             let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
558558             let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
559559             let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
560560             let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
561-            let $t02259022702 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
562-            let wxToClaimUserNew = $t02259022702._1
563-            let integralSTATE = $t02259022702._2
564-            let debug = $t02259022702._3
561+            let $t02263722749 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
562+            let wxToClaimUserNew = $t02263722749._1
563+            let integralSTATE = $t02263722749._2
564+            let debug = $t02263722749._3
565565             let availableToClaim = max([(wxToClaimUserNew - claimedByUser), zeroBigInt])
566566             if ((zeroBigInt >= availableToClaim))
567567                 then throw("nothing to claim")
568568                 else {
569569                     let wxAmountBoostTotal = max([asInt(asAnyList(invoke(boostingContract, "claimWxBoost", [lpAssetIdStr, userAddressStr], nil))[0]), 0])
570570                     let minRewardPart = availableToClaim
571571                     let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
572572                     let wxAssetId = asByteVector(asAnyList(invoke(emissionContract, "emit", [toInt(minRewardPart)], nil))[0])
573573                     let emitBoost = asAnyList(invoke(emissionContract, "emit", [toInt(boostRewardPart)], nil))
574574                     if ((emitBoost == emitBoost))
575575                         then {
576576                             let claimedByUserValue = (claimedByUser + availableToClaim)
577577                             let claimedByUserMinRewardPlusPart = (claimedByUserMinReward + minRewardPart)
578578                             let claimedByUserBoostRewardPlusBoostRewardPart = (claimedByUserMinReward + minRewardPart)
579579                             let claimedTotalPlusAvailableToClaim = (claimedByUserMinReward + minRewardPart)
580580 [StringEntry(claimedByUserKEY, toString(claimedByUserValue)), StringEntry(claimedByUserMinRewardKEY, toString(claimedByUserMinRewardPlusPart)), StringEntry(claimedByUserBoostRewardKEY, toString(claimedByUserBoostRewardPlusBoostRewardPart)), StringEntry(claimedTotalKEY, toString(claimedTotalPlusAvailableToClaim)), ScriptTransfer(userAddress, toInt(minRewardPart), wxAssetId), ScriptTransfer(userAddress, toInt(boostRewardPart), wxAssetId), OperationHistoryEntry("claim", userAddressStr, lpAssetIdStr, toInt(availableToClaim), i.transactionId)]
581581                             }
582582                         else throw("Strict value is not equal to itself.")
583583                     }
584584             }
585585         else throw("Strict value is not equal to itself.")
586586     }
587587 
588588 
589589 
590590 @Callable(i)
591591 func claimWxBulkInternalREADONLY (currentIter,lpAssetIds,userAddressStr,resAcc) = if ((currentIter == size(lpAssetIds)))
592592     then $Tuple2(nil, resAcc)
593593     else {
594594         let lpAssetId = lpAssetIds[currentIter]
595595         let info = split({
596596             let @ = invoke(this, "claimWxREADONLY", [lpAssetId, userAddressStr], nil)
597597             if ($isInstanceOf(@, "String"))
598598                 then @
599599                 else throw(($getType(invoke(this, "claimWxREADONLY", [lpAssetId, userAddressStr], nil)) + " couldn't be cast to String"))
600600             }, SEP)
601601         let unclaimed = info[3]
602602         let claimed = info[4]
603603         let res = (resAcc :+ makeString(["%d%d", unclaimed, claimed], SEP))
604604         let inv = {
605605             let @ = invoke(this, "claimWxBulkInternalREADONLY", [(currentIter + 1), lpAssetIds, userAddressStr, res], nil)
606606             if ($isInstanceOf(@, "List[Any]"))
607607                 then @
608608                 else throw(($getType(invoke(this, "claimWxBulkInternalREADONLY", [(currentIter + 1), lpAssetIds, userAddressStr, res], nil)) + " couldn't be cast to List[Any]"))
609609             }
610610         if ((inv == inv))
611611             then $Tuple2(nil, inv)
612612             else throw("Strict value is not equal to itself.")
613613         }
614614 
615615 
616616 
617617 @Callable(i)
618618 func claimWxBulkREADONLY (lpAssetIds,userAddressStr) = {
619619     let res = invoke(this, "claimWxBulkInternalREADONLY", [0, lpAssetIds, userAddressStr, nil], nil)
620620     $Tuple2(nil, res)
621621     }
622622 
623623 
624624 
625625 @Callable(i)
626626 func claimWxREADONLY (lpAssetIdStr,userAddressStr) = {
627627     let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
628628     let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
629629     let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
630630     let stakedByUser = readStaked(stakedByUserKEY)
631631     let stakedTotal = readStaked(stakedTotalKEY)
632632     let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
633633     let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
634634     let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
635635     let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
636636     let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
637637     let passedBlocks = if ((emissionStartBlock > height))
638638         then 0
639639         else (height - emissionStartBlock)
640640     let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
641641     let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
642-    let $t02616026272 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
643-    let wxToClaimUserNew = $t02616026272._1
644-    let integralSTATE = $t02616026272._2
645-    let debug = $t02616026272._3
642+    let $t02620726319 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
643+    let wxToClaimUserNew = $t02620726319._1
644+    let integralSTATE = $t02620726319._2
645+    let debug = $t02620726319._3
646646     let availableToClaim = max([(wxToClaimUserNew - claimedByUser), zeroBigInt])
647647     let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
648648     let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
649649     let boostDebug = asString(boostInvResult[1])
650650     let minRewardPart = availableToClaim
651651     let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
652652     let totalReward = (minRewardPart + boostRewardPart)
653653     $Tuple2(nil, makeString(["%s%s%d%d%d%d%s", lpAssetIdStr, userAddressStr, toString(totalReward), toString(claimedByUser), toString(minRewardPart), toString(boostRewardPart), "soon"], SEP))
654654     }
655655 
656656 
657657 
658658 @Callable(i)
659659 func usersListTraversal (lpAssetId) = {
660660     let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionContract()), "")))
661661         then true
662662         else mustManager(i)
663663     if ((checkCaller == checkCaller))
664664         then {
665665             let listName = getUsersListName(lpAssetId)
666666             let userOrUnit = getString(keyNextUser(lpAssetId))
667667             let headOrUnit = getString(keyListHead(listName))
668668             match userOrUnit {
669669                 case _: Unit => 
670670                     match headOrUnit {
671671                         case _: Unit => 
672672                             $Tuple2(nil, false)
673673                         case head: String => 
674674                             $Tuple2([StringEntry(keyNextUser(lpAssetId), head)], true)
675675                         case _ => 
676676                             throw("Match error")
677677                     }
678678                 case userAddress: String => 
679679                     let claimedByUser = getBigIntFromStringOrZero(this, keyClaimedByUser(lpAssetId, userAddress))
680680                     let poolAddress = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetId))
681681                     let wxToClaimUserNew = refreshINTEGRALS(lpAssetId, userAddress, poolAddress, 0)._1
682682                     let availableToClaim = (wxToClaimUserNew - claimedByUser)
683683                     let r = if ((availableToClaim > zeroBigInt))
684684                         then invoke(this, "claimWxINTERNAL", [lpAssetId, userAddress], nil)
685685                         else unit
686686                     if ((r == r))
687687                         then {
688688                             let nextUserOrUnit = getString(keyListNext(listName, userAddress))
689689                             match nextUserOrUnit {
690690                                 case _: Unit => 
691691                                     $Tuple2([DeleteEntry(keyNextUser(lpAssetId))], false)
692692                                 case nextUser: String => 
693693                                     $Tuple2([StringEntry(keyNextUser(lpAssetId), nextUser)], true)
694694                                 case _ => 
695695                                     throw("Match error")
696696                             }
697697                             }
698698                         else throw("Strict value is not equal to itself.")
699699                 case _ => 
700700                     throw("Match error")
701701             }
702702             }
703703         else throw("Strict value is not equal to itself.")
704704     }
705705 
706706 
707707 
708708 @Callable(i)
709709 func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
710710     then throw("permissions denied")
711711     else {
712-        let $t02857228682 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
713-        let wxPerLpIntegralNew = $t02857228682._1
714-        let poolIntegralSTATE = $t02857228682._2
715-        let poolDEBUG = $t02857228682._3
712+        let $t02861928729 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
713+        let wxPerLpIntegralNew = $t02861928729._1
714+        let poolIntegralSTATE = $t02861928729._2
715+        let poolDEBUG = $t02861928729._3
716716         poolIntegralSTATE
717717         }
718718 
719719 
720720 @Verifier(tx)
721721 func verify () = {
722722     let targetPublicKey =     match managerPublicKeyOrUnit() {
723723         case pk: ByteVector => 
724724             pk
725725         case _: Unit => 
726726             tx.senderPublicKey
727727         case _ => 
728728             throw("Match error")
729729     }
730730     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
731731     }
732732 
github/deemru/w8io/fabc49c 
72.01 ms ◑