tx · BzBj33aoRD9DGV1N1Uge5erkWcDvL4kBsJGhDykjvNu4

3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH:  -0.02600000 Waves

2023.03.21 14:54 [2499748] smart account 3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BzBj33aoRD9DGV1N1Uge5erkWcDvL4kBsJGhDykjvNu4",
    "fee": 2600000,
    "feeAssetId": null,
    "timestamp": 1679399723881,
    "version": 2,
    "chainId": 84,
    "sender": "3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH",
    "senderPublicKey": "5JqBVJpMCyD7dJLJttqYjL6CmJc4zahBHSFjFb7qQTga",
    "proofs": [
        "4u89DD334ZxqQCJq5kzpTAa3CGaceTHMaoY55TTGh3ZofTwovxqF2SECSCYknxUmZLab9y4uqGUsyAj6k2D7d82S"
    ],
    "script": "base64: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",
    "height": 2499748,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 3uL5zc2gvaWZHd9ja2NvViS1bK8Q79VFZzriKsAtWVKb
Next: 7rtbxYgbhN4YGr1Qx7SoXzSstDRQ2bJQSYnXHtpm9KJP

Diff: 

OldNewDifferences
305305                         else {
306306                             let newreductionFactor =                             match _getRegistryEntryValue(_percentageReductionFactor) {
307307                                 case t: Int => 
308-                                    t
308+                                    (t + 10)
309309                                 case _ => 
310310                                     throw("failed to get percentage reduction factor")
311311                             }
398398 
399399 func _stawMF (lockPeriod,collateralWaves) = {
400400     let _adjustedMr = _computeMr()
401-    let ret = fraction(collateralWaves, (_Dt * _adjustedMr._1), _Ppy(lockPeriod))
401+    let ret = (fraction(collateralWaves, (_Dt * _adjustedMr._1), _Ppy(lockPeriod)) / _unitDecimals)
402402     if ((size(_adjustedMr._2) == 0))
403403         then $Tuple2(ret, nil)
404404         else $Tuple2(ret, _adjustedMr._2)
407407 
408408 func _emissionRateWaves (lockPeriod,collateral) = {
409409     let extensionFactor = fraction(lockPeriod, 15, 10)
410-    fraction(collateral, ((lockPeriod * extensionFactor) - lockPeriod), _Dt)
410+    let emissionRate = (fraction(_unitDecimals, ((collateral / ((extensionFactor - lockPeriod) * _Dt)) / 2), 1) * _Dt)
411+    emissionRate
411412     }
412413 
413414 
716717                                                                                                                                 else (0 == stawLPAmount), "all claims exhausted for this trx")
717718                                                                                                                             if ((check2 == check2))
718719                                                                                                                                 then {
719-                                                                                                                                    let emissionValuePerDT = (_emissionRateWaves(lockPeriod, collateral) * _Dt)
720+                                                                                                                                    let emissionValuePerDT = _emissionRateWaves(lockPeriod, collateral)
720721                                                                                                                                     let claimAction = {
721722                                                                                                                                         let timeStampDiff = (currentTimeStamp - lockPeriodInMili)
722723                                                                                                                                         let xdays = (timeStampDiff / _Dt)

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "_"
55 
66 let _minLockperiod = 1
77 
88 let _unitDecimals = 100000000
99 
1010 let _minLockAmount = (1 * _unitDecimals)
1111 
1212 let _maxLockAmount = (1000 * _unitDecimals)
1313 
1414 let _Dt = 86400000
1515 
1616 func _Ppy (lockPeriod) = fraction(_unitDecimals, 365, lockPeriod)
1717 
1818 
1919 let _incrementRef = 1000000
2020 
2121 let _percentageFee = fraction(_unitDecimals, 10, 100)
2222 
2323 let _percentageReductionFactor = "Current_PercentageReduction_Factor_For_Mr"
2424 
2525 let _Mr = "Minting_Rate"
2626 
2727 let _stawAssetId = "Staw_AssetId"
2828 
2929 let _manager = "manager"
3030 
3131 let _Dfx = "Dfx"
3232 
3333 let _circulationIncrIndex = "CirculationIncrementIndex"
3434 
3535 let _lesseeAddress = "LeaseNode"
3636 
3737 let _userEmissionAmountClaimed = "EmissionAmountClaimed"
3838 
3939 let _userCanClaimEmissionAmount = "CanClaimEmissionAmount"
4040 
4141 let _userAddress = "WalletAddress"
4242 
4343 let _userLocalIndexCount = "TotalEntryIndexCount"
4444 
4545 let _userTotalLocked = "TotalLocked"
4646 
4747 let _lockDuration = "LockDuration"
4848 
4949 let _lockIndex = "GlobalLockIndex"
5050 
5151 let _lockId = "LockIdentifier"
5252 
5353 let _wavesAmount = "AmountInWaves"
5454 
5555 let _stawAmount = "AmountInStaw"
5656 
5757 let _stawLPAmount = "AmountInStawLP"
5858 
5959 let _txId = "TXID"
6060 
6161 let _lockAtHeight = "LockAtHeight"
6262 
6363 let _lockPeriodInMiliSec = "LocKPeriodInMilliSec"
6464 
6565 let _totalWavesClaimed = "TotalWavesClaimed"
6666 
6767 let _userLeaseState = "LeaseState"
6868 
6969 let _totalStaw = "TotalStawMinted"
7070 
7171 let _totalWavesRef = "TotalWavesLocked"
7272 
7373 let _totalStawLP = "TotalStawLP"
7474 
7575 let _globalIndexCount = "IndexCount"
7676 
7777 let _daysAfterLockPeriod = "DaysAfterLockPeriodElasped"
7878 
7979 func _getI (key) = getInteger(this, key)
8080 
8181 
8282 func _getS (key) = getString(this, key)
8383 
8484 
8585 func _getB (key) = getBoolean(this, key)
8686 
8787 
8888 func _getBV (key) = value(getBoolean(this, key))
8989 
9090 
9191 func _getIV (key) = value(getInteger(this, key))
9292 
9393 
9494 func _getSV (key) = value(getString(this, key))
9595 
9696 
9797 func _setParamVal (key,defaultVal) = match defaultVal {
9898     case defaultVal: String => 
9999         if (isDefined(_getS(key)))
100100             then _getSV(key)
101101             else defaultVal
102102     case defaultVal: Int => 
103103         if (isDefined(_getI(key)))
104104             then _getIV(key)
105105             else defaultVal
106106     case defaultVal: Boolean => 
107107         if (isDefined(_getB(key)))
108108             then _getBV(key)
109109             else defaultVal
110110     case _ => 
111111         throw(("value type not supported for " + key))
112112 }
113113 
114114 
115115 func _throwOrReturnS (val,error) = match val {
116116     case val: String => 
117117         val
118118     case _ => 
119119         throw(error)
120120 }
121121 
122122 
123123 func _throwOrReturnI (val,error) = match val {
124124     case val: Int => 
125125         val
126126     case _ => 
127127         throw(error)
128128 }
129129 
130130 
131131 func _throwOrReturnBool (val,error) = match val {
132132     case val: Boolean => 
133133         val
134134     case _ => 
135135         throw(error)
136136 }
137137 
138138 
139139 func _writeInt (key,value) = if ((0 > value))
140140     then throw(((("writing negative value " + toString(value)) + " for key ") + key))
141141     else IntegerEntry(key, value)
142142 
143143 
144144 func _writeStr (key,value) = if ((" " == value))
145145     then throw(("writing an empty string " + value))
146146     else StringEntry(key, value)
147147 
148148 
149149 func _throwIf (condition,error) = if (condition)
150150     then throw(error)
151151     else true
152152 
153153 
154154 func _writeGlobalParam (key,_value) = match _value {
155155     case _value: Int => 
156156         let entry = makeString(["%d", toString(_value)], SEP)
157157         _writeStr(key, entry)
158158     case _value: String => 
159159         let entry = makeString(["%s", _value], SEP)
160160         _writeStr(key, entry)
161161     case _value: Boolean => 
162162         let entry = makeString(["%b", toString(_value)], SEP)
163163         _writeStr(key, entry)
164164     case _ => 
165165         throw("type not supported")
166166 }
167167 
168168 
169169 func _getRegistryEntryValue (key) = {
170170     let _rawValue = _throwOrReturnS(_getS(key), ("entry not found for " + key))
171171     if ((_rawValue == _rawValue))
172172         then {
173173             let x = split(_rawValue, SEP)
174174             let formatSpecifier = takeRight(x[0], 1)
175175             let _valueString = x[(size(x) - 1)]
176176             let _value = if ((formatSpecifier == "s"))
177177                 then _valueString
178178                 else if ((formatSpecifier == "d"))
179179                     then parseIntValue(_valueString)
180180                     else if ((formatSpecifier == "b"))
181181                         then fromBase58String(_valueString)
182182                         else throw(("could not parse registry value for " + key))
183183             _value
184184             }
185185         else throw("Strict value is not equal to itself.")
186186     }
187187 
188188 
189189 func _daysToMiliSec (days) = {
190190     let check = _throwIf((0 >= days), "invalid locking days!")
191191     if ((check == check))
192192         then (days * _Dt)
193193         else throw("Strict value is not equal to itself.")
194194     }
195195 
196196 
197197 func _writeConstString (key,value) = if (!(isDefined(_getS(key))))
198198     then _writeStr(key, value)
199199     else throw(("entry already initialized: " + key))
200200 
201201 
202202 func _writeConstInteger (key,value) = if (!(isDefined(_getS(key))))
203203     then _writeInt(key, value)
204204     else throw((" entry already initialized: " + key))
205205 
206206 
207207 func _onlyManager (i) = {
208208     let manager =     match _getRegistryEntryValue(_manager) {
209209         case val: String => 
210210             val
211211         case _ => 
212212             "failed to get manager"
213213     }
214214     if ((manager == manager))
215215         then _throwIf((toBase58String(i.caller.bytes) != manager), "address not authorized")
216216         else throw("Strict value is not equal to itself.")
217217     }
218218 
219219 
220220 func _abs (val) = if ((0 > val))
221221     then -(val)
222222     else val
223223 
224224 
225225 func _validateAddress (address,errorMsg) = match address {
226226     case address: String => 
227227         let _address = addressFromString(address)
228228         match _address {
229229             case _address: Address => 
230230                 true
231231             case _ => 
232232                 match errorMsg {
233233                     case msg: String => 
234234                         throw(msg)
235235                     case _ => 
236236                         false
237237                 }
238238         }
239239     case address: ByteVector => 
240240         let _address = addressFromPublicKey(address)
241241         match _address {
242242             case _address: Address => 
243243                 true
244244             case _ => 
245245                 match errorMsg {
246246                     case msg: String => 
247247                         throw(msg)
248248                     case _ => 
249249                         false
250250                 }
251251         }
252252     case _ => 
253253         throw("invalid input type")
254254 }
255255 
256256 
257257 func _validateAsset (assetID,errorMsg) = match assetInfo(fromBase58String(assetID)) {
258258     case asset: Asset => 
259259         true
260260     case _ => 
261261         match errorMsg {
262262             case msg: String => 
263263                 throw(msg)
264264             case _ => 
265265                 false
266266         }
267267 }
268268 
269269 
270270 func _computeMr () = {
271271     let currentCircIndex =     match _getRegistryEntryValue(_circulationIncrIndex) {
272272         case t: Int => 
273273             t
274274         case _ => 
275275             throw("circulation index not previously defined")
276276     }
277277     if ((currentCircIndex == currentCircIndex))
278278         then {
279279             let stawAssetId =             match _getRegistryEntryValue(_stawAssetId) {
280280                 case t: String => 
281281                     t
282282                 case _ => 
283283                     throw("asset id not previously defined")
284284             }
285285             if ((stawAssetId == stawAssetId))
286286                 then {
287287                     let stawCirculatingSupply =                     match assetInfo(fromBase58String(stawAssetId)) {
288288                         case asset: Asset => 
289289                             (asset.quantity / _unitDecimals)
290290                         case _ => 
291291                             throw(("asset not found for " + stawAssetId))
292292                     }
293293                     let unitIncrement = (_abs((stawCirculatingSupply - _incrementRef)) / _incrementRef)
294294                     let newCirculationIncrIndex = if ((unitIncrement > currentCircIndex))
295295                         then (unitIncrement + currentCircIndex)
296296                         else currentCircIndex
297297                     let currentMr =                     match _getRegistryEntryValue(_Mr) {
298298                         case t: Int => 
299299                             t
300300                         case _ => 
301301                             throw("failed to get miniting rate")
302302                     }
303303                     if ((newCirculationIncrIndex == currentCircIndex))
304304                         then $Tuple2(currentMr, nil)
305305                         else {
306306                             let newreductionFactor =                             match _getRegistryEntryValue(_percentageReductionFactor) {
307307                                 case t: Int => 
308-                                    t
308+                                    (t + 10)
309309                                 case _ => 
310310                                     throw("failed to get percentage reduction factor")
311311                             }
312312                             let newCurrentMr = (currentMr - fraction(currentMr, newreductionFactor, 100))
313313                             let store1 = _writeGlobalParam(_Mr, newCurrentMr)
314314                             let store2 = _writeGlobalParam(_percentageReductionFactor, newreductionFactor)
315315                             let store3 = _writeGlobalParam(_circulationIncrIndex, newCirculationIncrIndex)
316316                             $Tuple2(newCurrentMr, [store1, store2, store3])
317317                             }
318318                     }
319319                 else throw("Strict value is not equal to itself.")
320320             }
321321         else throw("Strict value is not equal to itself.")
322322     }
323323 
324324 
325325 func _updateGlobalEntry (wavesAmount,stawAmount,stawPL,indexCount) = {
326326     let _newGlobalTotalWavesAmtRef =     match _getRegistryEntryValue(_totalWavesRef) {
327327         case t: Int => 
328328             (t + wavesAmount)
329329         case _ => 
330330             throw("failed to get global total waves")
331331     }
332332     if ((_newGlobalTotalWavesAmtRef == _newGlobalTotalWavesAmtRef))
333333         then {
334334             let _newGlobalTotalStawMinted =             match _getRegistryEntryValue(_totalStaw) {
335335                 case t: Int => 
336336                     (t + stawAmount)
337337                 case _ => 
338338                     throw("failed to get global total staw minted")
339339             }
340340             if ((_newGlobalTotalStawMinted == _newGlobalTotalStawMinted))
341341                 then {
342342                     let _newGlobalTotalStawPL =                     match _getRegistryEntryValue(_totalStawLP) {
343343                         case t: Int => 
344344                             (t + stawPL)
345345                         case _ => 
346346                             throw("failed to get global total stawpl")
347347                     }
348348                     if ((_newGlobalTotalStawPL == _newGlobalTotalStawPL))
349349                         then {
350350                             let _newGlobaIndexCount =                             match _getRegistryEntryValue(_globalIndexCount) {
351351                                 case t: Int => 
352352                                     (t + indexCount)
353353                                 case _ => 
354354                                     throw("failed to get global index count")
355355                             }
356356                             if ((_newGlobaIndexCount == _newGlobaIndexCount))
357357                                 then [_writeGlobalParam(_totalWavesRef, _newGlobalTotalWavesAmtRef), _writeGlobalParam(_totalStaw, _newGlobalTotalStawMinted), _writeGlobalParam(_totalStawLP, _newGlobalTotalStawPL), _writeGlobalParam(_globalIndexCount, _newGlobaIndexCount)]
358358                                 else throw("Strict value is not equal to itself.")
359359                             }
360360                         else throw("Strict value is not equal to itself.")
361361                     }
362362                 else throw("Strict value is not equal to itself.")
363363             }
364364         else throw("Strict value is not equal to itself.")
365365     }
366366 
367367 
368368 func _registerUserEntry (transactionID,userAddress,lockDuration,lockDurationInMili,lockIndex,wavesAmount,stawAmount,stawLPAmount,lockAtHeight,lockId,totalLocked,localIndexCount,leaseState) = {
369369     let _txIdKey = makeString([userAddress, transactionID, _txId], SEP)
370370     let _lockDurationKey = makeString([userAddress, transactionID, _lockDuration], SEP)
371371     let _lockIndexKey = makeString([userAddress, transactionID, _lockIndex], SEP)
372372     let _wavesAmountKey = makeString([userAddress, transactionID, _wavesAmount], SEP)
373373     let _stawAmountKey = makeString([userAddress, transactionID, _stawAmount], SEP)
374374     let _stawLPAmountKey = makeString([userAddress, transactionID, _stawLPAmount], SEP)
375375     let _lockAtHeightKey = makeString([userAddress, transactionID, _lockAtHeight], SEP)
376376     let _lockIdKey = makeString([userAddress, transactionID, _lockId], SEP)
377377     let _totalLockedKey = makeString([userAddress, _userTotalLocked], SEP)
378378     let _localLockIndexKey = makeString([userAddress, _userLocalIndexCount], SEP)
379379     let _lockPeriodInMiliSecKey = makeString([userAddress, transactionID, _lockPeriodInMiliSec], SEP)
380380     let _totalWavesClaimedKey = makeString([userAddress, transactionID, _totalWavesClaimed], SEP)
381381     let _userLeaseStateKey = makeString([userAddress, transactionID, _userLeaseState], SEP)
382382     let trxIdEntry = makeString(["%s", transactionID], SEP)
383383     let lockDurationEntry = makeString(["%d", toString(lockDuration)], SEP)
384384     let lockIndexEntry = makeString(["%d", toString(lockIndex)], SEP)
385385     let wavesAmountEntry = makeString(["%d", toString(wavesAmount)], SEP)
386386     let stawAmountEntry = makeString(["%d", toString(stawAmount)], SEP)
387387     let stawLPAmountEntry = makeString(["%d", toString(stawLPAmount)], SEP)
388388     let lockAtHeightEntry = makeString(["%d", toString(lockAtHeight)], SEP)
389389     let lockIdEntry = makeString(["%b", lockId], SEP)
390390     let totalLockedEntry = makeString(["%d", toString(totalLocked)], SEP)
391391     let userLocalIndexEntry = makeString(["%d", toString(localIndexCount)], SEP)
392392     let lockPeriodInMiliSecEntry = makeString(["%d", toString(lockDurationInMili)], SEP)
393393     let totalWavesClaimedEntry = makeString(["%d", toString(0)], SEP)
394394     let userLeaseStateEntry = makeString(["%s", leaseState], SEP)
395395 [_writeConstString(_txIdKey, trxIdEntry), _writeConstString(_lockIndexKey, lockIndexEntry), _writeStr(_localLockIndexKey, userLocalIndexEntry), _writeStr(_totalLockedKey, totalLockedEntry), _writeConstString(_lockDurationKey, lockDurationEntry), _writeConstString(_lockPeriodInMiliSecKey, lockPeriodInMiliSecEntry), _writeConstString(_wavesAmountKey, wavesAmountEntry), _writeConstString(_stawAmountKey, stawAmountEntry), _writeStr(_stawLPAmountKey, stawLPAmountEntry), _writeStr(_totalWavesClaimedKey, totalWavesClaimedEntry), _writeConstString(_lockAtHeightKey, lockAtHeightEntry), _writeConstString(_lockIdKey, lockIdEntry), _writeStr(_userLeaseStateKey, userLeaseStateEntry)]
396396     }
397397 
398398 
399399 func _stawMF (lockPeriod,collateralWaves) = {
400400     let _adjustedMr = _computeMr()
401-    let ret = fraction(collateralWaves, (_Dt * _adjustedMr._1), _Ppy(lockPeriod))
401+    let ret = (fraction(collateralWaves, (_Dt * _adjustedMr._1), _Ppy(lockPeriod)) / _unitDecimals)
402402     if ((size(_adjustedMr._2) == 0))
403403         then $Tuple2(ret, nil)
404404         else $Tuple2(ret, _adjustedMr._2)
405405     }
406406 
407407 
408408 func _emissionRateWaves (lockPeriod,collateral) = {
409409     let extensionFactor = fraction(lockPeriod, 15, 10)
410-    fraction(collateral, ((lockPeriod * extensionFactor) - lockPeriod), _Dt)
410+    let emissionRate = (fraction(_unitDecimals, ((collateral / ((extensionFactor - lockPeriod) * _Dt)) / 2), 1) * _Dt)
411+    emissionRate
411412     }
412413 
413414 
414415 func _incrTotalStawLP (amount) = {
415416     let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
416417 [_writeInt(_totalStawLP, (oldStawLP + amount))]
417418     }
418419 
419420 
420421 func _decrTotalStawLP (amount) = {
421422     let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
422423 [_writeInt(_totalStawLP, (oldStawLP - amount))]
423424     }
424425 
425426 
426427 func _incrTotalWavesRef (amount) = {
427428     let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
428429 [_writeInt(_totalWavesRef, (oldWavesRef + amount))]
429430     }
430431 
431432 
432433 func _decrTotalWavesRef (amount) = {
433434     let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
434435 [_writeInt(_totalWavesRef, (oldWavesRef - amount))]
435436     }
436437 
437438 
438439 func _getNewTimeStamp (blockHeight) = {
439440     let time =     match blockInfoByHeight(blockHeight) {
440441         case timeInfo: BlockInfo => 
441442             timeInfo.timestamp
442443         case _ => 
443444             throw("counld get timestamp")
444445     }
445446     time
446447     }
447448 
448449 
449450 func getAssetQuantity (assetID) = match assetInfo(fromBase58String(assetID)) {
450451     case t: Asset => 
451452         t.quantity
452453     case _ => 
453454         throw("asset not found")
454455 }
455456 
456457 
457458 @Callable(i)
458459 func getEmission (lockPeriod,collateral) = {
459460     let check1 = _onlyManager(i)
460461     if ((check1 == check1))
461462         then $Tuple2(nil, _emissionRateWaves(lockPeriod, collateral))
462463         else throw("Strict value is not equal to itself.")
463464     }
464465 
465466 
466467 
467468 @Callable(i)
468469 func init (manager,dfx,assetID,leaseNode) = {
469470     let managerAlreadyExists = if (isDefined(_getS(_manager)))
470471         then _onlyManager(i)
471472         else true
472473     if ((managerAlreadyExists == managerAlreadyExists))
473474         then {
474475             let check1 = _validateAddress(manager, "invalid address")
475476             if ((check1 == check1))
476477                 then {
477478                     let check2 = _validateAddress(dfx, "invalid address")
478479                     if ((check2 == check2))
479480                         then {
480481                             let check3 = _validateAddress(leaseNode, "invalid address")
481482                             if ((check3 == check3))
482483                                 then {
483484                                     let check4 = if (_validateAsset(assetID, "invalid asset"))
484485                                         then true
485486                                         else throw("invalid asset Id")
486487                                     if ((check4 == check4))
487488                                         then {
488489                                             let circulationIndex = _setParamVal(_circulationIncrIndex, 0)
489490                                             let percentageReductionInMr = _setParamVal(_percentageReductionFactor, 0)
490491                                             let Mr = _setParamVal(_Mr, _unitDecimals)
491492                                             let totalStawMinted = _setParamVal(_totalStaw, 0)
492493                                             let totalStawLPInCirculation = _setParamVal(_totalStawLP, 0)
493494                                             let globalIndexCount = _setParamVal(_globalIndexCount, 0)
494495                                             let totalWavesRef = _setParamVal(_totalWavesRef, 0)
495496 [_writeGlobalParam(_manager, manager), _writeGlobalParam(_Dfx, dfx), _writeGlobalParam(_stawAssetId, assetID), _writeGlobalParam(_lesseeAddress, leaseNode), _writeGlobalParam(_circulationIncrIndex, circulationIndex), _writeGlobalParam(_Mr, Mr), _writeGlobalParam(_percentageReductionFactor, percentageReductionInMr), _writeGlobalParam(_totalWavesRef, totalWavesRef), _writeGlobalParam(_totalStawLP, totalStawLPInCirculation), _writeGlobalParam(_totalStaw, totalStawMinted), _writeGlobalParam(_globalIndexCount, globalIndexCount)]
496497                                             }
497498                                         else throw("Strict value is not equal to itself.")
498499                                     }
499500                                 else throw("Strict value is not equal to itself.")
500501                             }
501502                         else throw("Strict value is not equal to itself.")
502503                     }
503504                 else throw("Strict value is not equal to itself.")
504505             }
505506         else throw("Strict value is not equal to itself.")
506507     }
507508 
508509 
509510 
510511 @Callable(i)
511512 func modifyGlobalParams (val) = {
512513     let check1 = _onlyManager(i)
513514     if ((check1 == check1))
514515         then {
515516             let errorMsg = makeString(["got", "list size of", toString(size(val)), "but expected [global_key, value] pair"], " ")
516517             let check2 = _throwIf((size(val) != 2), errorMsg)
517518             if ((check2 == check2))
518519                 then {
519520                     let key = val[0]
520521                     let valType = parseInt(val[1])
521522                     match valType {
522523                         case x: Int => 
523524                             let validateKey = _throwIf((_getS(key) == unit), (("key " + key) + " not recognized"))
524525                             if ((validateKey == validateKey))
525526                                 then {
526527                                     let ensureValidPairs =                                     match _getRegistryEntryValue(key) {
527528                                         case t: Int => 
528529                                             true
529530                                         case _ => 
530531                                             throw("invalid key-value pair")
531532                                     }
532533                                     if ((ensureValidPairs == ensureValidPairs))
533534                                         then [_writeGlobalParam(key, x)]
534535                                         else throw("Strict value is not equal to itself.")
535536                                     }
536537                                 else throw("Strict value is not equal to itself.")
537538                         case x: Unit => 
538539                             let validateKey = _throwIf((_getS(key) == unit), (("key " + key) + " not recognized"))
539540                             if ((validateKey == validateKey))
540541                                 then {
541542                                     let stringValue = val[1]
542543                                     let refAddress = _getRegistryEntryValue(_manager)
543544                                     let check4 =                                     match refAddress {
544545                                         case strType: String => 
545546                                             if ((size(strType) == size(stringValue)))
546547                                                 then _validateAddress(stringValue, "string type for value not supported")
547548                                                 else _validateAsset(stringValue, "string type for value not supported")
548549                                         case _ => 
549550                                             false
550551                                     }
551552                                     if ((check4 == check4))
552553                                         then [_writeGlobalParam(key, stringValue)]
553554                                         else throw("Strict value is not equal to itself.")
554555                                     }
555556                                 else throw("Strict value is not equal to itself.")
556557                         case _ => 
557558                             throw(("failed to modify " + val[0]))
558559                     }
559560                     }
560561                 else throw("Strict value is not equal to itself.")
561562             }
562563         else throw("Strict value is not equal to itself.")
563564     }
564565 
565566 
566567 
567568 @Callable(i)
568569 func revokeLock () = {
569570     let check1 = _onlyManager(i)
570571     if ((check1 == check1))
571572         then nil
572573         else throw("Strict value is not equal to itself.")
573574     }
574575 
575576 
576577 
577578 @Callable(i)
578579 func claim (transactionID) = {
579580     let callerAddress = toBase58String(i.caller.bytes)
580581     let collateralKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
581582     let lockperiodKey = makeString([callerAddress, transactionID, _lockDuration], SEP)
582583     let lockIdKey = makeString([callerAddress, transactionID, _lockId], SEP)
583584     let lockperiodInMiliKey = makeString([callerAddress, transactionID, _lockPeriodInMiliSec], SEP)
584585     let totalWavesClaimedKey = makeString([callerAddress, transactionID, _totalWavesClaimed], SEP)
585586     let stawLPAmountKey = makeString([callerAddress, transactionID, _stawLPAmount], SEP)
586587     let wavesAmountKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
587588     let userTotalWavesLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
588589     let userLeaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
589590     let leaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
590591     let daysAfterLockPeriodElaspedKey = makeString([callerAddress, transactionID, _daysAfterLockPeriod], SEP)
591592     let globalWavesRef =     match _getRegistryEntryValue(_totalWavesRef) {
592593         case t: Int => 
593594             t
594595         case _ => 
595596             throw("failed to get global total waves")
596597     }
597598     if ((globalWavesRef == globalWavesRef))
598599         then {
599600             let globalStawPL =             match _getRegistryEntryValue(_totalStawLP) {
600601                 case t: Int => 
601602                     t
602603                 case _ => 
603604                     throw("failed to get global total waves")
604605             }
605606             if ((globalStawPL == globalStawPL))
606607                 then {
607608                     let lockId =                     match _getRegistryEntryValue(lockIdKey) {
608609                         case t: ByteVector => 
609610                             t
610611                         case _ => 
611612                             throw("failed to get lease id")
612613                     }
613614                     if ((lockId == lockId))
614615                         then {
615616                             let userTotalWavesLocked =                             match _getRegistryEntryValue(userTotalWavesLockedKey) {
616617                                 case t: Int => 
617618                                     t
618619                                 case _ => 
619620                                     throw("failed to get total waves locked by this address")
620621                             }
621622                             if ((userTotalWavesLocked == userTotalWavesLocked))
622623                                 then {
623624                                     let wavesAmount =                                     match _getRegistryEntryValue(wavesAmountKey) {
624625                                         case t: Int => 
625626                                             t
626627                                         case _ => 
627628                                             throw("failed to get total waves locked")
628629                                     }
629630                                     if ((wavesAmount == wavesAmount))
630631                                         then {
631632                                             let totalWavesClaimed =                                             match _getRegistryEntryValue(totalWavesClaimedKey) {
632633                                                 case t: Int => 
633634                                                     t
634635                                                 case _ => 
635636                                                     throw("failed to get total waves claimed")
636637                                             }
637638                                             if ((totalWavesClaimed == totalWavesClaimed))
638639                                                 then {
639640                                                     let stawLPAmount =                                                     match _getRegistryEntryValue(stawLPAmountKey) {
640641                                                         case t: Int => 
641642                                                             t
642643                                                         case _ => 
643644                                                             throw("failed to get stawPL")
644645                                                     }
645646                                                     if ((stawLPAmount == stawLPAmount))
646647                                                         then {
647648                                                             let lockPeriodInMili =                                                             match _getRegistryEntryValue(lockperiodInMiliKey) {
648649                                                                 case t: Int => 
649650                                                                     t
650651                                                                 case _ => 
651652                                                                     throw("failed to get lock period timespam")
652653                                                             }
653654                                                             if ((lockPeriodInMili == lockPeriodInMili))
654655                                                                 then {
655656                                                                     let currentTimeStamp =                                                                     match _getNewTimeStamp(height) {
656657                                                                         case t: Int => 
657658                                                                             t
658659                                                                         case _ => 
659660                                                                             throw("failed to get current timestamp")
660661                                                                     }
661662                                                                     if ((currentTimeStamp == currentTimeStamp))
662663                                                                         then {
663664                                                                             let collateral =                                                                             match _getRegistryEntryValue(collateralKey) {
664665                                                                                 case t: Int => 
665666                                                                                     t
666667                                                                                 case _ => 
667668                                                                                     throw("failed to get collateral")
668669                                                                             }
669670                                                                             if ((collateral == collateral))
670671                                                                                 then {
671672                                                                                     let lockPeriod =                                                                                     match _getRegistryEntryValue(lockperiodKey) {
672673                                                                                         case t: Int => 
673674                                                                                             t
674675                                                                                         case _ => 
675676                                                                                             throw("failed to get lockPeriod")
676677                                                                                     }
677678                                                                                     if ((lockPeriod == lockPeriod))
678679                                                                                         then {
679680                                                                                             let currentLeaseState =                                                                                             match _getRegistryEntryValue(userLeaseStateKey) {
680681                                                                                                 case t: String => 
681682                                                                                                     t
682683                                                                                                 case _ => 
683684                                                                                                     throw("failed to get lease state")
684685                                                                                             }
685686                                                                                             if ((currentLeaseState == currentLeaseState))
686687                                                                                                 then {
687688                                                                                                     let leaseState =                                                                                                     match _getRegistryEntryValue(leaseStateKey) {
688689                                                                                                         case t: String => 
689690                                                                                                             t
690691                                                                                                         case _ => 
691692                                                                                                             throw("failed to get lease state for user")
692693                                                                                                     }
693694                                                                                                     if ((leaseState == leaseState))
694695                                                                                                         then {
695696                                                                                                             let daysAfterLockPeriodElasped =                                                                                                             match _getS(daysAfterLockPeriodElaspedKey) {
696697                                                                                                                 case t: String => 
697698                                                                                                                     match _getRegistryEntryValue(daysAfterLockPeriodElaspedKey) {
698699                                                                                                                         case z: Int => 
699700                                                                                                                             z
700701                                                                                                                         case _ => 
701702                                                                                                                             0
702703                                                                                                                     }
703704                                                                                                                 case _ => 
704705                                                                                                                     0
705706                                                                                                             }
706707                                                                                                             if ((daysAfterLockPeriodElasped == daysAfterLockPeriodElasped))
707708                                                                                                                 then {
708709                                                                                                                     let check1 = _throwIf((lockPeriodInMili > currentTimeStamp), "lock period for this entry has not elapsed")
709710                                                                                                                     if ((check1 == check1))
710711                                                                                                                         then {
711712                                                                                                                             let leaseAction = if ((currentLeaseState == "leased"))
712713                                                                                                                                 then $Tuple2(LeaseCancel(lockId), _writeStr(userLeaseStateKey, "cancelled"))
713714                                                                                                                                 else $Tuple2(_writeStr(userLeaseStateKey, "cancelled"), _writeStr(userLeaseStateKey, "cancelled"))
714715                                                                                                                             let check2 = _throwIf(if ((0 == wavesAmount))
715716                                                                                                                                 then true
716717                                                                                                                                 else (0 == stawLPAmount), "all claims exhausted for this trx")
717718                                                                                                                             if ((check2 == check2))
718719                                                                                                                                 then {
719-                                                                                                                                    let emissionValuePerDT = (_emissionRateWaves(lockPeriod, collateral) * _Dt)
720+                                                                                                                                    let emissionValuePerDT = _emissionRateWaves(lockPeriod, collateral)
720721                                                                                                                                     let claimAction = {
721722                                                                                                                                         let timeStampDiff = (currentTimeStamp - lockPeriodInMili)
722723                                                                                                                                         let xdays = (timeStampDiff / _Dt)
723724                                                                                                                                         if ((xdays == 0))
724725                                                                                                                                             then throw("less than 24hrs before first claim")
725726                                                                                                                                             else if ((daysAfterLockPeriodElasped >= xdays))
726727                                                                                                                                                 then throw("24hrs or less before next claim")
727728                                                                                                                                                 else {
728729                                                                                                                                                     let totalAmountClaimable = (daysAfterLockPeriodElasped * emissionValuePerDT)
729730                                                                                                                                                     let check3_1 = _throwIf((totalAmountClaimable == totalWavesClaimed), "can only claim once in 24hrs")
730731                                                                                                                                                     if ((check3_1 == check3_1))
731732                                                                                                                                                         then {
732733                                                                                                                                                             let check3_2 = _throwIf(((totalAmountClaimable + totalWavesClaimed) > wavesAmount), "all claims exhausted")
733734                                                                                                                                                             if ((check3_2 == check3_2))
734735                                                                                                                                                                 then {
735736                                                                                                                                                                     let claimAmountToSend = if ((daysAfterLockPeriodElasped == 1))
736737                                                                                                                                                                         then totalAmountClaimable
737738                                                                                                                                                                         else (totalAmountClaimable - totalWavesClaimed)
738739                                                                                                                                                                     let newTotalWavesClaim = totalAmountClaimable
739740                                                                                                                                                                     let newWavesAmount = if ((daysAfterLockPeriodElasped == 1))
740741                                                                                                                                                                         then (wavesAmount - totalAmountClaimable)
741742                                                                                                                                                                         else (wavesAmount - (totalAmountClaimable - totalWavesClaimed))
742743                                                                                                                                                                     let newStawLPAmount = if ((daysAfterLockPeriodElasped == 1))
743744                                                                                                                                                                         then (stawLPAmount - totalAmountClaimable)
744745                                                                                                                                                                         else (stawLPAmount - (totalAmountClaimable - totalWavesClaimed))
745746                                                                                                                                                                     let newGlobalWaveRef = (globalWavesRef - newWavesAmount)
746747                                                                                                                                                                     let newGlobalStawPL = (globalStawPL - newStawLPAmount)
747748                                                                                                                                                                     let newUserTotalWavesLocked = (userTotalWavesLocked - claimAmountToSend)
748749                                                                                                                                                                     let wavesAmountEntry = makeString(["%d", toString(newWavesAmount)], SEP)
749750                                                                                                                                                                     let stawLPAmountEntry = makeString(["%d", toString(newStawLPAmount)], SEP)
750751                                                                                                                                                                     let totalWavesClaimedEntry = makeString(["%d", toString(newTotalWavesClaim)], SEP)
751752                                                                                                                                                                     let newUserTotalWavesLockedEntry = makeString(["%d", toString(newUserTotalWavesLocked)], SEP)
752753                                                                                                                                                                     let daysAfterLockPeriodElaspedEntry = makeString(["%d", toString(xdays)], SEP)
753754 [leaseAction._1, leaseAction._2, _writeStr(wavesAmountKey, wavesAmountEntry), _writeStr(stawLPAmountKey, stawLPAmountEntry), _writeStr(totalWavesClaimedKey, totalWavesClaimedEntry), _writeStr(userTotalWavesLockedKey, newUserTotalWavesLockedEntry), _writeStr(daysAfterLockPeriodElaspedKey, daysAfterLockPeriodElaspedEntry), _writeGlobalParam(_totalWavesRef, newGlobalWaveRef), _writeGlobalParam(_totalStawLP, newGlobalStawPL), ScriptTransfer(Address(i.caller.bytes), claimAmountToSend, unit)]
754755                                                                                                                                                                     }
755756                                                                                                                                                                 else throw("Strict value is not equal to itself.")
756757                                                                                                                                                             }
757758                                                                                                                                                         else throw("Strict value is not equal to itself.")
758759                                                                                                                                                     }
759760                                                                                                                                         }
760761                                                                                                                                     if ((claimAction == claimAction))
761762                                                                                                                                         then claimAction
762763                                                                                                                                         else throw("Strict value is not equal to itself.")
763764                                                                                                                                     }
764765                                                                                                                                 else throw("Strict value is not equal to itself.")
765766                                                                                                                             }
766767                                                                                                                         else throw("Strict value is not equal to itself.")
767768                                                                                                                     }
768769                                                                                                                 else throw("Strict value is not equal to itself.")
769770                                                                                                             }
770771                                                                                                         else throw("Strict value is not equal to itself.")
771772                                                                                                     }
772773                                                                                                 else throw("Strict value is not equal to itself.")
773774                                                                                             }
774775                                                                                         else throw("Strict value is not equal to itself.")
775776                                                                                     }
776777                                                                                 else throw("Strict value is not equal to itself.")
777778                                                                             }
778779                                                                         else throw("Strict value is not equal to itself.")
779780                                                                     }
780781                                                                 else throw("Strict value is not equal to itself.")
781782                                                             }
782783                                                         else throw("Strict value is not equal to itself.")
783784                                                     }
784785                                                 else throw("Strict value is not equal to itself.")
785786                                             }
786787                                         else throw("Strict value is not equal to itself.")
787788                                     }
788789                                 else throw("Strict value is not equal to itself.")
789790                             }
790791                         else throw("Strict value is not equal to itself.")
791792                     }
792793                 else throw("Strict value is not equal to itself.")
793794             }
794795         else throw("Strict value is not equal to itself.")
795796     }
796797 
797798 
798799 
799800 @Callable(i)
800801 func mintStaw (lockPeriod) = {
801802     let callerAddress = toBase58String(i.caller.bytes)
802803     let trxID = toBase58String(i.transactionId)
803804     let check1 = _throwIf((1 != size(i.payments)), "no payments attached")
804805     if ((check1 == check1))
805806         then {
806807             let check2 = if (isDefined(i.payments[0].assetId))
807808                 then throw("only waves supported")
808809                 else true
809810             if ((check2 == check2))
810811                 then {
811812                     let amountInWaves = i.payments[0].amount
812813                     let check3 = if (if ((_minLockAmount > amountInWaves))
813814                         then true
814815                         else (amountInWaves > _maxLockAmount))
815816                         then throw("lock amount out of range, minimum: 1 waves, maximum: 1000 waves")
816817                         else true
817818                     if ((check3 == check3))
818819                         then {
819820                             let check4 = if ((_minLockperiod > lockPeriod))
820821                                 then throw("minimum of 14 days lock period")
821822                                 else true
822823                             if ((check4 == check4))
823824                                 then {
824825                                     let totalStawMint = _stawMF(lockPeriod, amountInWaves)
825826                                     let stawPL = amountInWaves
826827                                     let fee = fraction(totalStawMint._1, 10, 100)
827828                                     let userGetStawAmount = (totalStawMint._1 - fee)
828829                                     let lockPeriodToMilisec = (_getNewTimeStamp(height) + _daysToMiliSec(lockPeriod))
829830                                     if ((lockPeriodToMilisec == lockPeriodToMilisec))
830831                                         then {
831832                                             let new_index =                                             match _getRegistryEntryValue(_globalIndexCount) {
832833                                                 case t: Int => 
833834                                                     (t + 1)
834835                                                 case _ => 
835836                                                     throw("failed to get current global index count")
836837                                             }
837838                                             if ((new_index == new_index))
838839                                                 then {
839840                                                     let addressFee =                                                     match _getRegistryEntryValue(_Dfx) {
840841                                                         case t: String => 
841842                                                             Address(fromBase58String(t))
842843                                                         case _ => 
843844                                                             throw("failed to get dfx address")
844845                                                     }
845846                                                     if ((addressFee == addressFee))
846847                                                         then {
847848                                                             let stawAssetId =                                                             match _getRegistryEntryValue(_stawAssetId) {
848849                                                                 case t: String => 
849850                                                                     fromBase58String(t)
850851                                                                 case _ => 
851852                                                                     throw("failed to get asset id")
852853                                                             }
853854                                                             if ((stawAssetId == stawAssetId))
854855                                                                 then {
855856                                                                     let lessee =                                                                     match _getRegistryEntryValue(_lesseeAddress) {
856857                                                                         case t: String => 
857858                                                                             Address(fromBase58String(t))
858859                                                                         case _ => 
859860                                                                             throw("failed to get lease node address")
860861                                                                     }
861862                                                                     if ((lessee == lessee))
862863                                                                         then {
863864                                                                             let userLockIndexKey = makeString([callerAddress, _userLocalIndexCount], SEP)
864865                                                                             let userTotalLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
865866                                                                             let userIndexCount =                                                                             match _getS(userLockIndexKey) {
866867                                                                                 case x: String => 
867868                                                                                     match _getRegistryEntryValue(userLockIndexKey) {
868869                                                                                         case t: Int => 
869870                                                                                             (t + 1)
870871                                                                                         case _ => 
871872                                                                                             1
872873                                                                                     }
873874                                                                                 case _ => 
874875                                                                                     1
875876                                                                             }
876877                                                                             if ((userIndexCount == userIndexCount))
877878                                                                                 then {
878879                                                                                     let userTotalLocked =                                                                                     match _getS(userTotalLockedKey) {
879880                                                                                         case x: String => 
880881                                                                                             match _getRegistryEntryValue(userTotalLockedKey) {
881882                                                                                                 case t: Int => 
882883                                                                                                     (t + amountInWaves)
883884                                                                                                 case _ => 
884885                                                                                                     amountInWaves
885886                                                                                             }
886887                                                                                         case _ => 
887888                                                                                             amountInWaves
888889                                                                                     }
889890                                                                                     if ((userTotalLocked == userTotalLocked))
890891                                                                                         then {
891892                                                                                             let leaseOut = Lease(lessee, amountInWaves)
892893                                                                                             let leaseIdStr = toBase58String(calculateLeaseId(leaseOut))
893894                                                                                             ((([leaseOut, ScriptTransfer(addressFee, fee, stawAssetId), ScriptTransfer(Address(i.caller.bytes), userGetStawAmount, stawAssetId)] ++ _registerUserEntry(trxID, callerAddress, lockPeriod, lockPeriodToMilisec, new_index, amountInWaves, userGetStawAmount, stawPL, height, leaseIdStr, userTotalLocked, userIndexCount, "leased")) ++ _updateGlobalEntry(amountInWaves, totalStawMint._1, stawPL, new_index)) ++ totalStawMint._2)
894895                                                                                             }
895896                                                                                         else throw("Strict value is not equal to itself.")
896897                                                                                     }
897898                                                                                 else throw("Strict value is not equal to itself.")
898899                                                                             }
899900                                                                         else throw("Strict value is not equal to itself.")
900901                                                                     }
901902                                                                 else throw("Strict value is not equal to itself.")
902903                                                             }
903904                                                         else throw("Strict value is not equal to itself.")
904905                                                     }
905906                                                 else throw("Strict value is not equal to itself.")
906907                                             }
907908                                         else throw("Strict value is not equal to itself.")
908909                                     }
909910                                 else throw("Strict value is not equal to itself.")
910911                             }
911912                         else throw("Strict value is not equal to itself.")
912913                     }
913914                 else throw("Strict value is not equal to itself.")
914915             }
915916         else throw("Strict value is not equal to itself.")
916917     }
917918 
918919 
github/deemru/w8io/873ac7e 
117.44 ms ◑