tx · CrLHGCTHCs8B1kLdTHnpggzop83EfsPc2aa7vffZznjj

3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH:  -0.02500000 Waves

2023.03.19 02:06 [2496080] smart account 3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH > SELF 0.00000000 Waves

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

View: original | compacted
Prev: ED1h1SuZhBNqwDCmT8aYcz3GRG8qYWuTJaBFrZQeRNbr
Next: 4HRzwe8P96dfp9NAgksqBUxYLMMC77YmuFdv3uRLSoT7

Diff: 

OldNewDifferences
396396 
397397 func _stawMF (lockPeriod,collateralWaves) = {
398398     let _adjustedMr = _computeMr()
399-    let ret = (fraction(_unitDecimals, (_Dt * _adjustedMr._1), _Ppy(lockPeriod)) * collateralWaves)
399+    let ret = fraction(collateralWaves, (_Dt * _adjustedMr._1), _Ppy(lockPeriod))
400400     if ((size(_adjustedMr._2) == 0))
401401         then $Tuple2(ret, nil)
402402         else $Tuple2(ret, _adjustedMr._2)
405405 
406406 func _emissionRateWaves (lockPeriod,collateral) = {
407407     let extensionFactor = fraction(lockPeriod, 15, 10)
408-    ((collateral / ((lockPeriod * extensionFactor) - lockPeriod)) * _Dt)
408+    fraction(collateral, ((lockPeriod * extensionFactor) - lockPeriod), _Dt)
409409     }
410410 
411411 

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 * _unitDecimals)
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 func _getI (key) = getInteger(this, key)
7878 
7979 
8080 func _getS (key) = getString(this, key)
8181 
8282 
8383 func _getB (key) = getBoolean(this, key)
8484 
8585 
8686 func _getBV (key) = value(getBoolean(this, key))
8787 
8888 
8989 func _getIV (key) = value(getInteger(this, key))
9090 
9191 
9292 func _getSV (key) = value(getString(this, key))
9393 
9494 
9595 func _setParamVal (key,defaultVal) = match defaultVal {
9696     case defaultVal: String => 
9797         if (isDefined(_getS(key)))
9898             then _getSV(key)
9999             else defaultVal
100100     case defaultVal: Int => 
101101         if (isDefined(_getI(key)))
102102             then _getIV(key)
103103             else defaultVal
104104     case defaultVal: Boolean => 
105105         if (isDefined(_getB(key)))
106106             then _getBV(key)
107107             else defaultVal
108108     case _ => 
109109         throw(("value type not supported for " + key))
110110 }
111111 
112112 
113113 func _throwOrReturnS (val,error) = match val {
114114     case val: String => 
115115         val
116116     case _ => 
117117         throw(error)
118118 }
119119 
120120 
121121 func _throwOrReturnI (val,error) = match val {
122122     case val: Int => 
123123         val
124124     case _ => 
125125         throw(error)
126126 }
127127 
128128 
129129 func _throwOrReturnBool (val,error) = match val {
130130     case val: Boolean => 
131131         val
132132     case _ => 
133133         throw(error)
134134 }
135135 
136136 
137137 func _writeInt (key,value) = if ((0 > value))
138138     then throw(((("writing negative value " + toString(value)) + " for key ") + key))
139139     else IntegerEntry(key, value)
140140 
141141 
142142 func _writeStr (key,value) = if ((" " == value))
143143     then throw(("writing an empty string " + value))
144144     else StringEntry(key, value)
145145 
146146 
147147 func _throwIf (condition,error) = if (condition)
148148     then throw(error)
149149     else true
150150 
151151 
152152 func _writeGlobalParam (key,_value) = match _value {
153153     case _value: Int => 
154154         let entry = makeString(["%d", toString(_value)], SEP)
155155         _writeStr(key, entry)
156156     case _value: String => 
157157         let entry = makeString(["%s", _value], SEP)
158158         _writeStr(key, entry)
159159     case _value: Boolean => 
160160         let entry = makeString(["%b", toString(_value)], SEP)
161161         _writeStr(key, entry)
162162     case _ => 
163163         throw("type not supported")
164164 }
165165 
166166 
167167 func _getRegistryEntryValue (key) = {
168168     let _rawValue = _throwOrReturnS(_getS(key), ("entry not found for " + key))
169169     if ((_rawValue == _rawValue))
170170         then {
171171             let x = split(_rawValue, SEP)
172172             let formatSpecifier = takeRight(x[0], 1)
173173             let _valueString = x[(size(x) - 1)]
174174             let _value = if ((formatSpecifier == "s"))
175175                 then _valueString
176176                 else if ((formatSpecifier == "d"))
177177                     then parseIntValue(_valueString)
178178                     else if ((formatSpecifier == "b"))
179179                         then fromBase58String(_valueString)
180180                         else throw(("could not parse registry value for " + key))
181181             _value
182182             }
183183         else throw("Strict value is not equal to itself.")
184184     }
185185 
186186 
187187 func _daysToMiliSec (days) = {
188188     let check = _throwIf((0 >= days), "invalid locking days!")
189189     if ((check == check))
190190         then (days * _Dt)
191191         else throw("Strict value is not equal to itself.")
192192     }
193193 
194194 
195195 func _writeConstString (key,value) = if (!(isDefined(_getS(key))))
196196     then _writeStr(key, value)
197197     else throw(("entry already initialized: " + key))
198198 
199199 
200200 func _writeConstInteger (key,value) = if (!(isDefined(_getS(key))))
201201     then _writeInt(key, value)
202202     else throw((" entry already initialized: " + key))
203203 
204204 
205205 func _onlyManager (i) = {
206206     let manager =     match _getRegistryEntryValue(_manager) {
207207         case val: String => 
208208             val
209209         case _ => 
210210             "failed to get manager"
211211     }
212212     if ((manager == manager))
213213         then _throwIf((toBase58String(i.caller.bytes) != manager), "address not authorized")
214214         else throw("Strict value is not equal to itself.")
215215     }
216216 
217217 
218218 func _abs (val) = if ((0 > val))
219219     then -(val)
220220     else val
221221 
222222 
223223 func _validateAddress (address,errorMsg) = match address {
224224     case address: String => 
225225         let _address = addressFromString(address)
226226         match _address {
227227             case _address: Address => 
228228                 true
229229             case _ => 
230230                 match errorMsg {
231231                     case msg: String => 
232232                         throw(msg)
233233                     case _ => 
234234                         false
235235                 }
236236         }
237237     case address: ByteVector => 
238238         let _address = addressFromPublicKey(address)
239239         match _address {
240240             case _address: Address => 
241241                 true
242242             case _ => 
243243                 match errorMsg {
244244                     case msg: String => 
245245                         throw(msg)
246246                     case _ => 
247247                         false
248248                 }
249249         }
250250     case _ => 
251251         throw("invalid input type")
252252 }
253253 
254254 
255255 func _validateAsset (assetID,errorMsg) = match assetInfo(fromBase58String(assetID)) {
256256     case asset: Asset => 
257257         true
258258     case _ => 
259259         match errorMsg {
260260             case msg: String => 
261261                 throw(msg)
262262             case _ => 
263263                 false
264264         }
265265 }
266266 
267267 
268268 func _computeMr () = {
269269     let currentCircIndex =     match _getRegistryEntryValue(_circulationIncrIndex) {
270270         case t: Int => 
271271             t
272272         case _ => 
273273             throw("circulation index not previously defined")
274274     }
275275     if ((currentCircIndex == currentCircIndex))
276276         then {
277277             let stawAssetId =             match _getRegistryEntryValue(_stawAssetId) {
278278                 case t: String => 
279279                     t
280280                 case _ => 
281281                     throw("asset id not previously defined")
282282             }
283283             if ((stawAssetId == stawAssetId))
284284                 then {
285285                     let stawCirculatingSupply =                     match assetInfo(fromBase58String(stawAssetId)) {
286286                         case asset: Asset => 
287287                             asset.quantity
288288                         case _ => 
289289                             throw(("asset not found for " + stawAssetId))
290290                     }
291291                     let unitIncrement = (_abs((stawCirculatingSupply - _incrementRef)) / _incrementRef)
292292                     let newCirculationIncrIndex = if ((unitIncrement > currentCircIndex))
293293                         then (unitIncrement + currentCircIndex)
294294                         else currentCircIndex
295295                     let currentMr =                     match _getRegistryEntryValue(_Mr) {
296296                         case t: Int => 
297297                             t
298298                         case _ => 
299299                             throw("failed to get miniting rate")
300300                     }
301301                     if ((newCirculationIncrIndex == currentCircIndex))
302302                         then $Tuple2(currentMr, nil)
303303                         else {
304304                             let newreductionFactor =                             match _getRegistryEntryValue(_percentageReductionFactor) {
305305                                 case t: Int => 
306306                                     t
307307                                 case _ => 
308308                                     throw("failed to get percentage reduction factor")
309309                             }
310310                             let newCurrentMr = (currentMr - fraction(currentMr, newreductionFactor, 100))
311311                             let store1 = _writeGlobalParam(_Mr, newCurrentMr)
312312                             let store2 = _writeGlobalParam(_percentageReductionFactor, newreductionFactor)
313313                             let store3 = _writeGlobalParam(_circulationIncrIndex, newCirculationIncrIndex)
314314                             $Tuple2(newCurrentMr, [store1, store2, store3])
315315                             }
316316                     }
317317                 else throw("Strict value is not equal to itself.")
318318             }
319319         else throw("Strict value is not equal to itself.")
320320     }
321321 
322322 
323323 func _updateGlobalEntry (wavesAmount,stawAmount,stawPL,indexCount) = {
324324     let _newGlobalTotalWavesAmtRef =     match _getRegistryEntryValue(_totalWavesRef) {
325325         case t: Int => 
326326             (t + wavesAmount)
327327         case _ => 
328328             throw("failed to get global total waves")
329329     }
330330     if ((_newGlobalTotalWavesAmtRef == _newGlobalTotalWavesAmtRef))
331331         then {
332332             let _newGlobalTotalStawMinted =             match _getRegistryEntryValue(_totalStaw) {
333333                 case t: Int => 
334334                     (t + stawAmount)
335335                 case _ => 
336336                     throw("failed to get global total staw minted")
337337             }
338338             if ((_newGlobalTotalStawMinted == _newGlobalTotalStawMinted))
339339                 then {
340340                     let _newGlobalTotalStawPL =                     match _getRegistryEntryValue(_totalStawLP) {
341341                         case t: Int => 
342342                             (t + stawPL)
343343                         case _ => 
344344                             throw("failed to get global total stawpl")
345345                     }
346346                     if ((_newGlobalTotalStawPL == _newGlobalTotalStawPL))
347347                         then {
348348                             let _newGlobaIndexCount =                             match _getRegistryEntryValue(_globalIndexCount) {
349349                                 case t: Int => 
350350                                     (t + indexCount)
351351                                 case _ => 
352352                                     throw("failed to get global index count")
353353                             }
354354                             if ((_newGlobaIndexCount == _newGlobaIndexCount))
355355                                 then [_writeGlobalParam(_totalWavesRef, _newGlobalTotalWavesAmtRef), _writeGlobalParam(_totalStaw, _newGlobalTotalStawMinted), _writeGlobalParam(_totalStawLP, _newGlobalTotalStawPL), _writeGlobalParam(_globalIndexCount, _newGlobaIndexCount)]
356356                                 else throw("Strict value is not equal to itself.")
357357                             }
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 
365365 
366366 func _registerUserEntry (transactionID,userAddress,lockDuration,lockDurationInMili,lockIndex,wavesAmount,stawAmount,stawLPAmount,lockAtHeight,lockId,totalLocked,localIndexCount,leaseState) = {
367367     let _txIdKey = makeString([userAddress, transactionID, _txId], SEP)
368368     let _lockDurationKey = makeString([userAddress, transactionID, _lockDuration], SEP)
369369     let _lockIndexKey = makeString([userAddress, transactionID, _lockIndex], SEP)
370370     let _wavesAmountKey = makeString([userAddress, transactionID, _wavesAmount], SEP)
371371     let _stawAmountKey = makeString([userAddress, transactionID, _stawAmount], SEP)
372372     let _stawLPAmountKey = makeString([userAddress, transactionID, _stawLPAmount], SEP)
373373     let _lockAtHeightKey = makeString([userAddress, transactionID, _lockAtHeight], SEP)
374374     let _lockIdKey = makeString([userAddress, transactionID, _lockId], SEP)
375375     let _totalLockedKey = makeString([userAddress, _userTotalLocked], SEP)
376376     let _localLockIndexKey = makeString([userAddress, _userLocalIndexCount], SEP)
377377     let _lockPeriodInMiliSecKey = makeString([userAddress, transactionID, _lockPeriodInMiliSec], SEP)
378378     let _totalWavesClaimedKey = makeString([userAddress, transactionID, _totalWavesClaimed], SEP)
379379     let _userLeaseStateKey = makeString([userAddress, transactionID, _userLeaseState], SEP)
380380     let trxIdEntry = makeString(["%s", transactionID], SEP)
381381     let lockDurationEntry = makeString(["%d", toString(lockDuration)], SEP)
382382     let lockIndexEntry = makeString(["%d", toString(lockIndex)], SEP)
383383     let wavesAmountEntry = makeString(["%d", toString(wavesAmount)], SEP)
384384     let stawAmountEntry = makeString(["%d", toString(stawAmount)], SEP)
385385     let stawLPAmountEntry = makeString(["%d", toString(stawLPAmount)], SEP)
386386     let lockAtHeightEntry = makeString(["%d", toString(lockAtHeight)], SEP)
387387     let lockIdEntry = makeString(["%b", lockId], SEP)
388388     let totalLockedEntry = makeString(["%d", toString(totalLocked)], SEP)
389389     let userLocalIndexEntry = makeString(["%d", toString(localIndexCount)], SEP)
390390     let lockPeriodInMiliSecEntry = makeString(["%d", toString(lockDurationInMili)], SEP)
391391     let totalWavesClaimedEntry = makeString(["%d", toString(0)], SEP)
392392     let userLeaseStateEntry = makeString(["%s", leaseState], SEP)
393393 [_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)]
394394     }
395395 
396396 
397397 func _stawMF (lockPeriod,collateralWaves) = {
398398     let _adjustedMr = _computeMr()
399-    let ret = (fraction(_unitDecimals, (_Dt * _adjustedMr._1), _Ppy(lockPeriod)) * collateralWaves)
399+    let ret = fraction(collateralWaves, (_Dt * _adjustedMr._1), _Ppy(lockPeriod))
400400     if ((size(_adjustedMr._2) == 0))
401401         then $Tuple2(ret, nil)
402402         else $Tuple2(ret, _adjustedMr._2)
403403     }
404404 
405405 
406406 func _emissionRateWaves (lockPeriod,collateral) = {
407407     let extensionFactor = fraction(lockPeriod, 15, 10)
408-    ((collateral / ((lockPeriod * extensionFactor) - lockPeriod)) * _Dt)
408+    fraction(collateral, ((lockPeriod * extensionFactor) - lockPeriod), _Dt)
409409     }
410410 
411411 
412412 func _incrTotalStawLP (amount) = {
413413     let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
414414 [_writeInt(_totalStawLP, (oldStawLP + amount))]
415415     }
416416 
417417 
418418 func _decrTotalStawLP (amount) = {
419419     let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
420420 [_writeInt(_totalStawLP, (oldStawLP - amount))]
421421     }
422422 
423423 
424424 func _incrTotalWavesRef (amount) = {
425425     let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
426426 [_writeInt(_totalWavesRef, (oldWavesRef + amount))]
427427     }
428428 
429429 
430430 func _decrTotalWavesRef (amount) = {
431431     let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
432432 [_writeInt(_totalWavesRef, (oldWavesRef - amount))]
433433     }
434434 
435435 
436436 func _getNewTimeStamp (blockHeight) = {
437437     let time =     match blockInfoByHeight(blockHeight) {
438438         case timeInfo: BlockInfo => 
439439             timeInfo.timestamp
440440         case _ => 
441441             throw("counld get timestamp")
442442     }
443443     time
444444     }
445445 
446446 
447447 @Callable(i)
448448 func getEmission (lockPeriod,collateral) = {
449449     let check1 = _onlyManager(i)
450450     if ((check1 == check1))
451451         then $Tuple2(nil, _emissionRateWaves(lockPeriod, collateral))
452452         else throw("Strict value is not equal to itself.")
453453     }
454454 
455455 
456456 
457457 @Callable(i)
458458 func init (manager,dfx,assetID,leaseNode) = {
459459     let managerAlreadyExists = if (isDefined(_getS(_manager)))
460460         then _onlyManager(i)
461461         else true
462462     if ((managerAlreadyExists == managerAlreadyExists))
463463         then {
464464             let check1 = _validateAddress(manager, "invalid address")
465465             if ((check1 == check1))
466466                 then {
467467                     let check2 = _validateAddress(dfx, "invalid address")
468468                     if ((check2 == check2))
469469                         then {
470470                             let check3 = _validateAddress(leaseNode, "invalid address")
471471                             if ((check3 == check3))
472472                                 then {
473473                                     let check4 = if (_validateAsset(assetID, "invalid asset"))
474474                                         then true
475475                                         else throw("invalid asset Id")
476476                                     if ((check4 == check4))
477477                                         then {
478478                                             let circulationIndex = _setParamVal(_circulationIncrIndex, 0)
479479                                             let percentageReductionInMr = _setParamVal(_percentageReductionFactor, 0)
480480                                             let Mr = _setParamVal(_Mr, _unitDecimals)
481481                                             let totalStawMinted = _setParamVal(_totalStaw, 0)
482482                                             let totalStawLPInCirculation = _setParamVal(_totalStawLP, 0)
483483                                             let globalIndexCount = _setParamVal(_globalIndexCount, 0)
484484                                             let totalWavesRef = _setParamVal(_totalWavesRef, 0)
485485 [_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)]
486486                                             }
487487                                         else throw("Strict value is not equal to itself.")
488488                                     }
489489                                 else throw("Strict value is not equal to itself.")
490490                             }
491491                         else throw("Strict value is not equal to itself.")
492492                     }
493493                 else throw("Strict value is not equal to itself.")
494494             }
495495         else throw("Strict value is not equal to itself.")
496496     }
497497 
498498 
499499 
500500 @Callable(i)
501501 func modifyGlobalParams (val) = {
502502     let check1 = _onlyManager(i)
503503     if ((check1 == check1))
504504         then {
505505             let errorMsg = makeString(["got", "list size of", toString(size(val)), "but expected [global_key, value] pair"], " ")
506506             let check2 = _throwIf((size(val) != 2), errorMsg)
507507             if ((check2 == check2))
508508                 then {
509509                     let key = val[0]
510510                     let valType = parseInt(val[1])
511511                     match valType {
512512                         case x: Int => 
513513                             let validateKey = _throwIf((_getS(key) == unit), (("key " + key) + " not recognized"))
514514                             if ((validateKey == validateKey))
515515                                 then {
516516                                     let ensureValidPairs =                                     match _getRegistryEntryValue(key) {
517517                                         case t: Int => 
518518                                             true
519519                                         case _ => 
520520                                             throw("invalid key-value pair")
521521                                     }
522522                                     if ((ensureValidPairs == ensureValidPairs))
523523                                         then [_writeGlobalParam(key, x)]
524524                                         else throw("Strict value is not equal to itself.")
525525                                     }
526526                                 else throw("Strict value is not equal to itself.")
527527                         case x: Unit => 
528528                             let validateKey = _throwIf((_getS(key) == unit), (("key " + key) + " not recognized"))
529529                             if ((validateKey == validateKey))
530530                                 then {
531531                                     let stringValue = val[1]
532532                                     let refAddress = _getRegistryEntryValue(_manager)
533533                                     let check4 =                                     match refAddress {
534534                                         case strType: String => 
535535                                             if ((size(strType) == size(stringValue)))
536536                                                 then _validateAddress(stringValue, "string type for value not supported")
537537                                                 else _validateAsset(stringValue, "string type for value not supported")
538538                                         case _ => 
539539                                             false
540540                                     }
541541                                     if ((check4 == check4))
542542                                         then [_writeGlobalParam(key, stringValue)]
543543                                         else throw("Strict value is not equal to itself.")
544544                                     }
545545                                 else throw("Strict value is not equal to itself.")
546546                         case _ => 
547547                             throw(("failed to modify " + val[0]))
548548                     }
549549                     }
550550                 else throw("Strict value is not equal to itself.")
551551             }
552552         else throw("Strict value is not equal to itself.")
553553     }
554554 
555555 
556556 
557557 @Callable(i)
558558 func revokeLock () = {
559559     let check1 = _onlyManager(i)
560560     if ((check1 == check1))
561561         then nil
562562         else throw("Strict value is not equal to itself.")
563563     }
564564 
565565 
566566 
567567 @Callable(i)
568568 func claim (transactionID) = {
569569     let callerAddress = toBase58String(i.caller.bytes)
570570     let collateralKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
571571     let lockperiodKey = makeString([callerAddress, transactionID, _lockDuration], SEP)
572572     let lockIdKey = makeString([callerAddress, transactionID, _lockId], SEP)
573573     let lockperiodInMiliKey = makeString([callerAddress, transactionID, _lockPeriodInMiliSec], SEP)
574574     let totalWavesClaimedKey = makeString([callerAddress, transactionID, _totalWavesClaimed], SEP)
575575     let stawLPAmountKey = makeString([callerAddress, transactionID, _stawLPAmount], SEP)
576576     let wavesAmountKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
577577     let userTotalWavesLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
578578     let userLeaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
579579     let leaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
580580     let globalWavesRef =     match _getRegistryEntryValue(_totalWavesRef) {
581581         case t: Int => 
582582             t
583583         case _ => 
584584             throw("failed to get global total waves")
585585     }
586586     if ((globalWavesRef == globalWavesRef))
587587         then {
588588             let globalStawPL =             match _getRegistryEntryValue(_totalStawLP) {
589589                 case t: Int => 
590590                     t
591591                 case _ => 
592592                     throw("failed to get global total waves")
593593             }
594594             if ((globalStawPL == globalStawPL))
595595                 then {
596596                     let lockId =                     match _getRegistryEntryValue(lockIdKey) {
597597                         case t: ByteVector => 
598598                             t
599599                         case _ => 
600600                             throw("failed to get lease id")
601601                     }
602602                     if ((lockId == lockId))
603603                         then {
604604                             let userTotalWavesLocked =                             match _getRegistryEntryValue(userTotalWavesLockedKey) {
605605                                 case t: Int => 
606606                                     t
607607                                 case _ => 
608608                                     throw("failed to get total waves locked by this address")
609609                             }
610610                             if ((userTotalWavesLocked == userTotalWavesLocked))
611611                                 then {
612612                                     let wavesAmount =                                     match _getRegistryEntryValue(wavesAmountKey) {
613613                                         case t: Int => 
614614                                             t
615615                                         case _ => 
616616                                             throw("failed to get total waves locked")
617617                                     }
618618                                     if ((wavesAmount == wavesAmount))
619619                                         then {
620620                                             let totalWavesClaimed =                                             match _getRegistryEntryValue(totalWavesClaimedKey) {
621621                                                 case t: Int => 
622622                                                     t
623623                                                 case _ => 
624624                                                     throw("failed to get total waves claimed")
625625                                             }
626626                                             if ((totalWavesClaimed == totalWavesClaimed))
627627                                                 then {
628628                                                     let stawLPAmount =                                                     match _getRegistryEntryValue(stawLPAmountKey) {
629629                                                         case t: Int => 
630630                                                             t
631631                                                         case _ => 
632632                                                             throw("failed to get stawPL")
633633                                                     }
634634                                                     if ((stawLPAmount == stawLPAmount))
635635                                                         then {
636636                                                             let lockPeriodInMili =                                                             match _getRegistryEntryValue(lockperiodInMiliKey) {
637637                                                                 case t: Int => 
638638                                                                     t
639639                                                                 case _ => 
640640                                                                     throw("failed to get lock period timespam")
641641                                                             }
642642                                                             if ((lockPeriodInMili == lockPeriodInMili))
643643                                                                 then {
644644                                                                     let currentTimeStamp =                                                                     match _getNewTimeStamp(height) {
645645                                                                         case t: Int => 
646646                                                                             t
647647                                                                         case _ => 
648648                                                                             throw("failed to get current timestamp")
649649                                                                     }
650650                                                                     if ((currentTimeStamp == currentTimeStamp))
651651                                                                         then {
652652                                                                             let collateral =                                                                             match _getRegistryEntryValue(collateralKey) {
653653                                                                                 case t: Int => 
654654                                                                                     t
655655                                                                                 case _ => 
656656                                                                                     throw("failed to get collateral")
657657                                                                             }
658658                                                                             if ((collateral == collateral))
659659                                                                                 then {
660660                                                                                     let lockPeriod =                                                                                     match _getRegistryEntryValue(lockperiodKey) {
661661                                                                                         case t: Int => 
662662                                                                                             t
663663                                                                                         case _ => 
664664                                                                                             throw("failed to get lockPeriod")
665665                                                                                     }
666666                                                                                     if ((lockPeriod == lockPeriod))
667667                                                                                         then {
668668                                                                                             let currentLeaseState =                                                                                             match _getRegistryEntryValue(userLeaseStateKey) {
669669                                                                                                 case t: String => 
670670                                                                                                     t
671671                                                                                                 case _ => 
672672                                                                                                     throw("failed to get lease state")
673673                                                                                             }
674674                                                                                             if ((currentLeaseState == currentLeaseState))
675675                                                                                                 then {
676676                                                                                                     let leaseState =                                                                                                     match _getRegistryEntryValue(leaseStateKey) {
677677                                                                                                         case t: String => 
678678                                                                                                             t
679679                                                                                                         case _ => 
680680                                                                                                             throw("failed to get lease state for user")
681681                                                                                                     }
682682                                                                                                     if ((leaseState == leaseState))
683683                                                                                                         then {
684684                                                                                                             let check1 = _throwIf((lockPeriodInMili > currentTimeStamp), "lock period for this entry has not elapsed")
685685                                                                                                             if ((check1 == check1))
686686                                                                                                                 then {
687687                                                                                                                     let leaseAction = if ((currentLeaseState == "leased"))
688688                                                                                                                         then $Tuple2(LeaseCancel(lockId), _writeStr(userLeaseStateKey, "cancelled"))
689689                                                                                                                         else $Tuple2(_writeStr(userLeaseStateKey, "cancelled"), _writeStr(userLeaseStateKey, "cancelled"))
690690                                                                                                                     if ((leaseAction == leaseAction))
691691                                                                                                                         then {
692692                                                                                                                             let check2 = _throwIf(if ((0 == wavesAmount))
693693                                                                                                                                 then true
694694                                                                                                                                 else (0 == stawLPAmount), "all claims exhausted for this trx")
695695                                                                                                                             if ((check2 == check2))
696696                                                                                                                                 then {
697697                                                                                                                                     let emissionValuePerDT = (_emissionRateWaves(lockPeriod, collateral) * _Dt)
698698                                                                                                                                     let claimAction = {
699699                                                                                                                                         let timeStampDiff = (currentTimeStamp - lockPeriodInMili)
700700                                                                                                                                         let daysAfterLockPeriodElasped = (timeStampDiff / _Dt)
701701                                                                                                                                         if ((daysAfterLockPeriodElasped == 0))
702702                                                                                                                                             then throw("less than 24hrs before first claim")
703703                                                                                                                                             else if (((timeStampDiff % _Dt) != 0))
704704                                                                                                                                                 then throw("already claimed or less than 24hrs before next claim")
705705                                                                                                                                                 else if ((daysAfterLockPeriodElasped > lockPeriod))
706706                                                                                                                                                     then throw("all claims exhausted")
707707                                                                                                                                                     else {
708708                                                                                                                                                         let totalAmountClaimable = (daysAfterLockPeriodElasped * emissionValuePerDT)
709709                                                                                                                                                         let check3_1 = _throwIf((totalAmountClaimable == totalWavesClaimed), "can only claim once in 24hrs")
710710                                                                                                                                                         if ((check3_1 == check3_1))
711711                                                                                                                                                             then {
712712                                                                                                                                                                 let check3_2 = _throwIf(((totalAmountClaimable + totalWavesClaimed) > wavesAmount), "all claims exhausted")
713713                                                                                                                                                                 if ((check3_2 == check3_2))
714714                                                                                                                                                                     then {
715715                                                                                                                                                                         let claimAmountToSend = if ((daysAfterLockPeriodElasped == 1))
716716                                                                                                                                                                             then totalAmountClaimable
717717                                                                                                                                                                             else (totalAmountClaimable - totalWavesClaimed)
718718                                                                                                                                                                         let newTotalWavesClaim = totalAmountClaimable
719719                                                                                                                                                                         let newWavesAmount = if ((daysAfterLockPeriodElasped == 1))
720720                                                                                                                                                                             then (wavesAmount - totalAmountClaimable)
721721                                                                                                                                                                             else (wavesAmount - (totalAmountClaimable - totalWavesClaimed))
722722                                                                                                                                                                         let newStawLPAmount = if ((daysAfterLockPeriodElasped == 1))
723723                                                                                                                                                                             then (stawLPAmount - totalAmountClaimable)
724724                                                                                                                                                                             else (stawLPAmount - (totalAmountClaimable - totalWavesClaimed))
725725                                                                                                                                                                         let newGlobalWaveRef = (globalWavesRef - newWavesAmount)
726726                                                                                                                                                                         let newGlobalStawPL = (globalStawPL - newStawLPAmount)
727727                                                                                                                                                                         let newUserTotalWavesLocked = (userTotalWavesLocked - claimAmountToSend)
728728                                                                                                                                                                         let wavesAmountEntry = makeString(["%d", toString(newWavesAmount)], SEP)
729729                                                                                                                                                                         let stawLPAmountEntry = makeString(["%d", toString(newStawLPAmount)], SEP)
730730                                                                                                                                                                         let totalWavesClaimedEntry = makeString(["%d", toString(newTotalWavesClaim)], SEP)
731731                                                                                                                                                                         let newUserTotalWavesLockedEntry = makeString(["%d", toString(newUserTotalWavesLocked)], SEP)
732732 [leaseAction._1, leaseAction._2, _writeStr(wavesAmountKey, wavesAmountEntry), _writeStr(stawLPAmountKey, stawLPAmountEntry), _writeStr(totalWavesClaimedKey, totalWavesClaimedEntry), _writeStr(userTotalWavesLockedKey, newUserTotalWavesLockedEntry), _writeGlobalParam(_totalWavesRef, newGlobalWaveRef), _writeGlobalParam(_totalStawLP, newGlobalStawPL), ScriptTransfer(Address(i.caller.bytes), claimAmountToSend, unit)]
733733                                                                                                                                                                         }
734734                                                                                                                                                                     else throw("Strict value is not equal to itself.")
735735                                                                                                                                                                 }
736736                                                                                                                                                             else throw("Strict value is not equal to itself.")
737737                                                                                                                                                         }
738738                                                                                                                                         }
739739                                                                                                                                     if ((claimAction == claimAction))
740740                                                                                                                                         then claimAction
741741                                                                                                                                         else throw("Strict value is not equal to itself.")
742742                                                                                                                                     }
743743                                                                                                                                 else throw("Strict value is not equal to itself.")
744744                                                                                                                             }
745745                                                                                                                         else throw("Strict value is not equal to itself.")
746746                                                                                                                     }
747747                                                                                                                 else throw("Strict value is not equal to itself.")
748748                                                                                                             }
749749                                                                                                         else throw("Strict value is not equal to itself.")
750750                                                                                                     }
751751                                                                                                 else throw("Strict value is not equal to itself.")
752752                                                                                             }
753753                                                                                         else throw("Strict value is not equal to itself.")
754754                                                                                     }
755755                                                                                 else throw("Strict value is not equal to itself.")
756756                                                                             }
757757                                                                         else throw("Strict value is not equal to itself.")
758758                                                                     }
759759                                                                 else throw("Strict value is not equal to itself.")
760760                                                             }
761761                                                         else throw("Strict value is not equal to itself.")
762762                                                     }
763763                                                 else throw("Strict value is not equal to itself.")
764764                                             }
765765                                         else throw("Strict value is not equal to itself.")
766766                                     }
767767                                 else throw("Strict value is not equal to itself.")
768768                             }
769769                         else throw("Strict value is not equal to itself.")
770770                     }
771771                 else throw("Strict value is not equal to itself.")
772772             }
773773         else throw("Strict value is not equal to itself.")
774774     }
775775 
776776 
777777 
778778 @Callable(i)
779779 func mintStaw (lockPeriod) = {
780780     let callerAddress = toBase58String(i.caller.bytes)
781781     let trxID = toBase58String(i.transactionId)
782782     let check1 = _throwIf((1 != size(i.payments)), "no payments attached")
783783     if ((check1 == check1))
784784         then {
785785             let check2 = if (isDefined(i.payments[0].assetId))
786786                 then throw("only waves supported")
787787                 else true
788788             if ((check2 == check2))
789789                 then {
790790                     let amountInWaves = i.payments[0].amount
791791                     let check3 = if (if ((_minLockAmount > amountInWaves))
792792                         then true
793793                         else (amountInWaves > _maxLockAmount))
794794                         then throw("lock amount out of range, minimum: 1 waves, maximum: 1000 waves")
795795                         else true
796796                     if ((check3 == check3))
797797                         then {
798798                             let check4 = if ((_minLockperiod > lockPeriod))
799799                                 then throw("minimum of 14 days lock period")
800800                                 else true
801801                             if ((check4 == check4))
802802                                 then {
803803                                     let totalStawMint = _stawMF(lockPeriod, amountInWaves)
804804                                     let stawPL = amountInWaves
805805                                     let fee = fraction(totalStawMint._1, 10, 100)
806806                                     let userGetStawAmount = (totalStawMint._1 - fee)
807807                                     let lockPeriodToMilisec = (_getNewTimeStamp(height) + _daysToMiliSec(lockPeriod))
808808                                     if ((lockPeriodToMilisec == lockPeriodToMilisec))
809809                                         then {
810810                                             let new_index =                                             match _getRegistryEntryValue(_globalIndexCount) {
811811                                                 case t: Int => 
812812                                                     (t + 1)
813813                                                 case _ => 
814814                                                     throw("failed to get current global index count")
815815                                             }
816816                                             if ((new_index == new_index))
817817                                                 then {
818818                                                     let addressFee =                                                     match _getRegistryEntryValue(_Dfx) {
819819                                                         case t: String => 
820820                                                             Address(fromBase58String(t))
821821                                                         case _ => 
822822                                                             throw("failed to get dfx address")
823823                                                     }
824824                                                     if ((addressFee == addressFee))
825825                                                         then {
826826                                                             let stawAssetId =                                                             match _getRegistryEntryValue(_stawAssetId) {
827827                                                                 case t: String => 
828828                                                                     fromBase58String(t)
829829                                                                 case _ => 
830830                                                                     throw("failed to get asset id")
831831                                                             }
832832                                                             if ((stawAssetId == stawAssetId))
833833                                                                 then {
834834                                                                     let lessee =                                                                     match _getRegistryEntryValue(_lesseeAddress) {
835835                                                                         case t: String => 
836836                                                                             Address(fromBase58String(t))
837837                                                                         case _ => 
838838                                                                             throw("failed to get lease node address")
839839                                                                     }
840840                                                                     if ((lessee == lessee))
841841                                                                         then {
842842                                                                             let userLockIndexKey = makeString([callerAddress, _userLocalIndexCount], SEP)
843843                                                                             let userTotalLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
844844                                                                             let userIndexCount =                                                                             match _getS(userLockIndexKey) {
845845                                                                                 case x: String => 
846846                                                                                     match _getRegistryEntryValue(userLockIndexKey) {
847847                                                                                         case t: Int => 
848848                                                                                             (t + 1)
849849                                                                                         case _ => 
850850                                                                                             0
851851                                                                                     }
852852                                                                                 case _ => 
853853                                                                                     0
854854                                                                             }
855855                                                                             if ((userIndexCount == userIndexCount))
856856                                                                                 then {
857857                                                                                     let userTotalLocked =                                                                                     match _getS(userTotalLockedKey) {
858858                                                                                         case x: String => 
859859                                                                                             match _getRegistryEntryValue(userTotalLockedKey) {
860860                                                                                                 case t: Int => 
861861                                                                                                     (t + amountInWaves)
862862                                                                                                 case _ => 
863863                                                                                                     amountInWaves
864864                                                                                             }
865865                                                                                         case _ => 
866866                                                                                             amountInWaves
867867                                                                                     }
868868                                                                                     if ((userTotalLocked == userTotalLocked))
869869                                                                                         then {
870870                                                                                             let leaseOut = Lease(lessee, amountInWaves)
871871                                                                                             let leaseIdStr = toBase58String(calculateLeaseId(leaseOut))
872872                                                                                             ((([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)
873873                                                                                             }
874874                                                                                         else throw("Strict value is not equal to itself.")
875875                                                                                     }
876876                                                                                 else throw("Strict value is not equal to itself.")
877877                                                                             }
878878                                                                         else throw("Strict value is not equal to itself.")
879879                                                                     }
880880                                                                 else throw("Strict value is not equal to itself.")
881881                                                             }
882882                                                         else throw("Strict value is not equal to itself.")
883883                                                     }
884884                                                 else throw("Strict value is not equal to itself.")
885885                                             }
886886                                         else throw("Strict value is not equal to itself.")
887887                                     }
888888                                 else throw("Strict value is not equal to itself.")
889889                             }
890890                         else throw("Strict value is not equal to itself.")
891891                     }
892892                 else throw("Strict value is not equal to itself.")
893893             }
894894         else throw("Strict value is not equal to itself.")
895895     }
896896 
897897 
github/deemru/w8io/873ac7e 
113.99 ms ◑