tx · HRBPaAcvWTVy5piK6EUJv5ThzjkMmJSmG8hLQYkuEPWZ

3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH:  -0.02600000 Waves

2023.03.20 18:47 [2498532] smart account 3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH > SELF 0.00000000 Waves

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

View: original | compacted
Prev: EUKnu2SVoYaqHEyVi9PTZsGtbJZ2i6DbdNaKpxusjn1w
Next: 3uL5zc2gvaWZHd9ja2NvViS1bK8Q79VFZzriKsAtWVKb

Diff: 

OldNewDifferences
446446     }
447447 
448448 
449+func getAssetQuantity (assetID) = match assetInfo(fromBase58String(assetID)) {
450+    case t: Asset => 
451+        t.quantity
452+    case _ => 
453+        throw("asset not found")
454+}
455+
456+
449457 @Callable(i)
450458 func getEmission (lockPeriod,collateral) = {
451459     let check1 = _onlyManager(i)
860868                                                                                         case t: Int => 
861869                                                                                             (t + 1)
862870                                                                                         case _ => 
863-                                                                                            0
871+                                                                                            1
864872                                                                                     }
865873                                                                                 case _ => 
866-                                                                                    0
874+                                                                                    1
867875                                                                             }
868876                                                                             if ((userIndexCount == userIndexCount))
869877                                                                                 then {

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 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
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 => 
308308                                     t
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()
401401     let ret = fraction(collateralWaves, (_Dt * _adjustedMr._1), _Ppy(lockPeriod))
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)
410410     fraction(collateral, ((lockPeriod * extensionFactor) - lockPeriod), _Dt)
411411     }
412412 
413413 
414414 func _incrTotalStawLP (amount) = {
415415     let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
416416 [_writeInt(_totalStawLP, (oldStawLP + amount))]
417417     }
418418 
419419 
420420 func _decrTotalStawLP (amount) = {
421421     let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
422422 [_writeInt(_totalStawLP, (oldStawLP - amount))]
423423     }
424424 
425425 
426426 func _incrTotalWavesRef (amount) = {
427427     let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
428428 [_writeInt(_totalWavesRef, (oldWavesRef + amount))]
429429     }
430430 
431431 
432432 func _decrTotalWavesRef (amount) = {
433433     let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
434434 [_writeInt(_totalWavesRef, (oldWavesRef - amount))]
435435     }
436436 
437437 
438438 func _getNewTimeStamp (blockHeight) = {
439439     let time =     match blockInfoByHeight(blockHeight) {
440440         case timeInfo: BlockInfo => 
441441             timeInfo.timestamp
442442         case _ => 
443443             throw("counld get timestamp")
444444     }
445445     time
446446     }
447447 
448448 
449+func getAssetQuantity (assetID) = match assetInfo(fromBase58String(assetID)) {
450+    case t: Asset => 
451+        t.quantity
452+    case _ => 
453+        throw("asset not found")
454+}
455+
456+
449457 @Callable(i)
450458 func getEmission (lockPeriod,collateral) = {
451459     let check1 = _onlyManager(i)
452460     if ((check1 == check1))
453461         then $Tuple2(nil, _emissionRateWaves(lockPeriod, collateral))
454462         else throw("Strict value is not equal to itself.")
455463     }
456464 
457465 
458466 
459467 @Callable(i)
460468 func init (manager,dfx,assetID,leaseNode) = {
461469     let managerAlreadyExists = if (isDefined(_getS(_manager)))
462470         then _onlyManager(i)
463471         else true
464472     if ((managerAlreadyExists == managerAlreadyExists))
465473         then {
466474             let check1 = _validateAddress(manager, "invalid address")
467475             if ((check1 == check1))
468476                 then {
469477                     let check2 = _validateAddress(dfx, "invalid address")
470478                     if ((check2 == check2))
471479                         then {
472480                             let check3 = _validateAddress(leaseNode, "invalid address")
473481                             if ((check3 == check3))
474482                                 then {
475483                                     let check4 = if (_validateAsset(assetID, "invalid asset"))
476484                                         then true
477485                                         else throw("invalid asset Id")
478486                                     if ((check4 == check4))
479487                                         then {
480488                                             let circulationIndex = _setParamVal(_circulationIncrIndex, 0)
481489                                             let percentageReductionInMr = _setParamVal(_percentageReductionFactor, 0)
482490                                             let Mr = _setParamVal(_Mr, _unitDecimals)
483491                                             let totalStawMinted = _setParamVal(_totalStaw, 0)
484492                                             let totalStawLPInCirculation = _setParamVal(_totalStawLP, 0)
485493                                             let globalIndexCount = _setParamVal(_globalIndexCount, 0)
486494                                             let totalWavesRef = _setParamVal(_totalWavesRef, 0)
487495 [_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)]
488496                                             }
489497                                         else throw("Strict value is not equal to itself.")
490498                                     }
491499                                 else throw("Strict value is not equal to itself.")
492500                             }
493501                         else throw("Strict value is not equal to itself.")
494502                     }
495503                 else throw("Strict value is not equal to itself.")
496504             }
497505         else throw("Strict value is not equal to itself.")
498506     }
499507 
500508 
501509 
502510 @Callable(i)
503511 func modifyGlobalParams (val) = {
504512     let check1 = _onlyManager(i)
505513     if ((check1 == check1))
506514         then {
507515             let errorMsg = makeString(["got", "list size of", toString(size(val)), "but expected [global_key, value] pair"], " ")
508516             let check2 = _throwIf((size(val) != 2), errorMsg)
509517             if ((check2 == check2))
510518                 then {
511519                     let key = val[0]
512520                     let valType = parseInt(val[1])
513521                     match valType {
514522                         case x: Int => 
515523                             let validateKey = _throwIf((_getS(key) == unit), (("key " + key) + " not recognized"))
516524                             if ((validateKey == validateKey))
517525                                 then {
518526                                     let ensureValidPairs =                                     match _getRegistryEntryValue(key) {
519527                                         case t: Int => 
520528                                             true
521529                                         case _ => 
522530                                             throw("invalid key-value pair")
523531                                     }
524532                                     if ((ensureValidPairs == ensureValidPairs))
525533                                         then [_writeGlobalParam(key, x)]
526534                                         else throw("Strict value is not equal to itself.")
527535                                     }
528536                                 else throw("Strict value is not equal to itself.")
529537                         case x: Unit => 
530538                             let validateKey = _throwIf((_getS(key) == unit), (("key " + key) + " not recognized"))
531539                             if ((validateKey == validateKey))
532540                                 then {
533541                                     let stringValue = val[1]
534542                                     let refAddress = _getRegistryEntryValue(_manager)
535543                                     let check4 =                                     match refAddress {
536544                                         case strType: String => 
537545                                             if ((size(strType) == size(stringValue)))
538546                                                 then _validateAddress(stringValue, "string type for value not supported")
539547                                                 else _validateAsset(stringValue, "string type for value not supported")
540548                                         case _ => 
541549                                             false
542550                                     }
543551                                     if ((check4 == check4))
544552                                         then [_writeGlobalParam(key, stringValue)]
545553                                         else throw("Strict value is not equal to itself.")
546554                                     }
547555                                 else throw("Strict value is not equal to itself.")
548556                         case _ => 
549557                             throw(("failed to modify " + val[0]))
550558                     }
551559                     }
552560                 else throw("Strict value is not equal to itself.")
553561             }
554562         else throw("Strict value is not equal to itself.")
555563     }
556564 
557565 
558566 
559567 @Callable(i)
560568 func revokeLock () = {
561569     let check1 = _onlyManager(i)
562570     if ((check1 == check1))
563571         then nil
564572         else throw("Strict value is not equal to itself.")
565573     }
566574 
567575 
568576 
569577 @Callable(i)
570578 func claim (transactionID) = {
571579     let callerAddress = toBase58String(i.caller.bytes)
572580     let collateralKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
573581     let lockperiodKey = makeString([callerAddress, transactionID, _lockDuration], SEP)
574582     let lockIdKey = makeString([callerAddress, transactionID, _lockId], SEP)
575583     let lockperiodInMiliKey = makeString([callerAddress, transactionID, _lockPeriodInMiliSec], SEP)
576584     let totalWavesClaimedKey = makeString([callerAddress, transactionID, _totalWavesClaimed], SEP)
577585     let stawLPAmountKey = makeString([callerAddress, transactionID, _stawLPAmount], SEP)
578586     let wavesAmountKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
579587     let userTotalWavesLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
580588     let userLeaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
581589     let leaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
582590     let daysAfterLockPeriodElaspedKey = makeString([callerAddress, transactionID, _daysAfterLockPeriod], SEP)
583591     let globalWavesRef =     match _getRegistryEntryValue(_totalWavesRef) {
584592         case t: Int => 
585593             t
586594         case _ => 
587595             throw("failed to get global total waves")
588596     }
589597     if ((globalWavesRef == globalWavesRef))
590598         then {
591599             let globalStawPL =             match _getRegistryEntryValue(_totalStawLP) {
592600                 case t: Int => 
593601                     t
594602                 case _ => 
595603                     throw("failed to get global total waves")
596604             }
597605             if ((globalStawPL == globalStawPL))
598606                 then {
599607                     let lockId =                     match _getRegistryEntryValue(lockIdKey) {
600608                         case t: ByteVector => 
601609                             t
602610                         case _ => 
603611                             throw("failed to get lease id")
604612                     }
605613                     if ((lockId == lockId))
606614                         then {
607615                             let userTotalWavesLocked =                             match _getRegistryEntryValue(userTotalWavesLockedKey) {
608616                                 case t: Int => 
609617                                     t
610618                                 case _ => 
611619                                     throw("failed to get total waves locked by this address")
612620                             }
613621                             if ((userTotalWavesLocked == userTotalWavesLocked))
614622                                 then {
615623                                     let wavesAmount =                                     match _getRegistryEntryValue(wavesAmountKey) {
616624                                         case t: Int => 
617625                                             t
618626                                         case _ => 
619627                                             throw("failed to get total waves locked")
620628                                     }
621629                                     if ((wavesAmount == wavesAmount))
622630                                         then {
623631                                             let totalWavesClaimed =                                             match _getRegistryEntryValue(totalWavesClaimedKey) {
624632                                                 case t: Int => 
625633                                                     t
626634                                                 case _ => 
627635                                                     throw("failed to get total waves claimed")
628636                                             }
629637                                             if ((totalWavesClaimed == totalWavesClaimed))
630638                                                 then {
631639                                                     let stawLPAmount =                                                     match _getRegistryEntryValue(stawLPAmountKey) {
632640                                                         case t: Int => 
633641                                                             t
634642                                                         case _ => 
635643                                                             throw("failed to get stawPL")
636644                                                     }
637645                                                     if ((stawLPAmount == stawLPAmount))
638646                                                         then {
639647                                                             let lockPeriodInMili =                                                             match _getRegistryEntryValue(lockperiodInMiliKey) {
640648                                                                 case t: Int => 
641649                                                                     t
642650                                                                 case _ => 
643651                                                                     throw("failed to get lock period timespam")
644652                                                             }
645653                                                             if ((lockPeriodInMili == lockPeriodInMili))
646654                                                                 then {
647655                                                                     let currentTimeStamp =                                                                     match _getNewTimeStamp(height) {
648656                                                                         case t: Int => 
649657                                                                             t
650658                                                                         case _ => 
651659                                                                             throw("failed to get current timestamp")
652660                                                                     }
653661                                                                     if ((currentTimeStamp == currentTimeStamp))
654662                                                                         then {
655663                                                                             let collateral =                                                                             match _getRegistryEntryValue(collateralKey) {
656664                                                                                 case t: Int => 
657665                                                                                     t
658666                                                                                 case _ => 
659667                                                                                     throw("failed to get collateral")
660668                                                                             }
661669                                                                             if ((collateral == collateral))
662670                                                                                 then {
663671                                                                                     let lockPeriod =                                                                                     match _getRegistryEntryValue(lockperiodKey) {
664672                                                                                         case t: Int => 
665673                                                                                             t
666674                                                                                         case _ => 
667675                                                                                             throw("failed to get lockPeriod")
668676                                                                                     }
669677                                                                                     if ((lockPeriod == lockPeriod))
670678                                                                                         then {
671679                                                                                             let currentLeaseState =                                                                                             match _getRegistryEntryValue(userLeaseStateKey) {
672680                                                                                                 case t: String => 
673681                                                                                                     t
674682                                                                                                 case _ => 
675683                                                                                                     throw("failed to get lease state")
676684                                                                                             }
677685                                                                                             if ((currentLeaseState == currentLeaseState))
678686                                                                                                 then {
679687                                                                                                     let leaseState =                                                                                                     match _getRegistryEntryValue(leaseStateKey) {
680688                                                                                                         case t: String => 
681689                                                                                                             t
682690                                                                                                         case _ => 
683691                                                                                                             throw("failed to get lease state for user")
684692                                                                                                     }
685693                                                                                                     if ((leaseState == leaseState))
686694                                                                                                         then {
687695                                                                                                             let daysAfterLockPeriodElasped =                                                                                                             match _getS(daysAfterLockPeriodElaspedKey) {
688696                                                                                                                 case t: String => 
689697                                                                                                                     match _getRegistryEntryValue(daysAfterLockPeriodElaspedKey) {
690698                                                                                                                         case z: Int => 
691699                                                                                                                             z
692700                                                                                                                         case _ => 
693701                                                                                                                             0
694702                                                                                                                     }
695703                                                                                                                 case _ => 
696704                                                                                                                     0
697705                                                                                                             }
698706                                                                                                             if ((daysAfterLockPeriodElasped == daysAfterLockPeriodElasped))
699707                                                                                                                 then {
700708                                                                                                                     let check1 = _throwIf((lockPeriodInMili > currentTimeStamp), "lock period for this entry has not elapsed")
701709                                                                                                                     if ((check1 == check1))
702710                                                                                                                         then {
703711                                                                                                                             let leaseAction = if ((currentLeaseState == "leased"))
704712                                                                                                                                 then $Tuple2(LeaseCancel(lockId), _writeStr(userLeaseStateKey, "cancelled"))
705713                                                                                                                                 else $Tuple2(_writeStr(userLeaseStateKey, "cancelled"), _writeStr(userLeaseStateKey, "cancelled"))
706714                                                                                                                             let check2 = _throwIf(if ((0 == wavesAmount))
707715                                                                                                                                 then true
708716                                                                                                                                 else (0 == stawLPAmount), "all claims exhausted for this trx")
709717                                                                                                                             if ((check2 == check2))
710718                                                                                                                                 then {
711719                                                                                                                                     let emissionValuePerDT = (_emissionRateWaves(lockPeriod, collateral) * _Dt)
712720                                                                                                                                     let claimAction = {
713721                                                                                                                                         let timeStampDiff = (currentTimeStamp - lockPeriodInMili)
714722                                                                                                                                         let xdays = (timeStampDiff / _Dt)
715723                                                                                                                                         if ((daysAfterLockPeriodElasped == 0))
716724                                                                                                                                             then throw("less than 24hrs before first claim")
717725                                                                                                                                             else if ((daysAfterLockPeriodElasped >= xdays))
718726                                                                                                                                                 then throw("24hrs or less before next claim")
719727                                                                                                                                                 else {
720728                                                                                                                                                     let totalAmountClaimable = (daysAfterLockPeriodElasped * emissionValuePerDT)
721729                                                                                                                                                     let check3_1 = _throwIf((totalAmountClaimable == totalWavesClaimed), "can only claim once in 24hrs")
722730                                                                                                                                                     if ((check3_1 == check3_1))
723731                                                                                                                                                         then {
724732                                                                                                                                                             let check3_2 = _throwIf(((totalAmountClaimable + totalWavesClaimed) > wavesAmount), "all claims exhausted")
725733                                                                                                                                                             if ((check3_2 == check3_2))
726734                                                                                                                                                                 then {
727735                                                                                                                                                                     let claimAmountToSend = if ((daysAfterLockPeriodElasped == 1))
728736                                                                                                                                                                         then totalAmountClaimable
729737                                                                                                                                                                         else (totalAmountClaimable - totalWavesClaimed)
730738                                                                                                                                                                     let newTotalWavesClaim = totalAmountClaimable
731739                                                                                                                                                                     let newWavesAmount = if ((daysAfterLockPeriodElasped == 1))
732740                                                                                                                                                                         then (wavesAmount - totalAmountClaimable)
733741                                                                                                                                                                         else (wavesAmount - (totalAmountClaimable - totalWavesClaimed))
734742                                                                                                                                                                     let newStawLPAmount = if ((daysAfterLockPeriodElasped == 1))
735743                                                                                                                                                                         then (stawLPAmount - totalAmountClaimable)
736744                                                                                                                                                                         else (stawLPAmount - (totalAmountClaimable - totalWavesClaimed))
737745                                                                                                                                                                     let newGlobalWaveRef = (globalWavesRef - newWavesAmount)
738746                                                                                                                                                                     let newGlobalStawPL = (globalStawPL - newStawLPAmount)
739747                                                                                                                                                                     let newUserTotalWavesLocked = (userTotalWavesLocked - claimAmountToSend)
740748                                                                                                                                                                     let wavesAmountEntry = makeString(["%d", toString(newWavesAmount)], SEP)
741749                                                                                                                                                                     let stawLPAmountEntry = makeString(["%d", toString(newStawLPAmount)], SEP)
742750                                                                                                                                                                     let totalWavesClaimedEntry = makeString(["%d", toString(newTotalWavesClaim)], SEP)
743751                                                                                                                                                                     let newUserTotalWavesLockedEntry = makeString(["%d", toString(newUserTotalWavesLocked)], SEP)
744752                                                                                                                                                                     let daysAfterLockPeriodElaspedEntry = makeString(["%d", toString(xdays)], SEP)
745753 [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)]
746754                                                                                                                                                                     }
747755                                                                                                                                                                 else throw("Strict value is not equal to itself.")
748756                                                                                                                                                             }
749757                                                                                                                                                         else throw("Strict value is not equal to itself.")
750758                                                                                                                                                     }
751759                                                                                                                                         }
752760                                                                                                                                     if ((claimAction == claimAction))
753761                                                                                                                                         then claimAction
754762                                                                                                                                         else throw("Strict value is not equal to itself.")
755763                                                                                                                                     }
756764                                                                                                                                 else throw("Strict value is not equal to itself.")
757765                                                                                                                             }
758766                                                                                                                         else throw("Strict value is not equal to itself.")
759767                                                                                                                     }
760768                                                                                                                 else throw("Strict value is not equal to itself.")
761769                                                                                                             }
762770                                                                                                         else throw("Strict value is not equal to itself.")
763771                                                                                                     }
764772                                                                                                 else throw("Strict value is not equal to itself.")
765773                                                                                             }
766774                                                                                         else throw("Strict value is not equal to itself.")
767775                                                                                     }
768776                                                                                 else throw("Strict value is not equal to itself.")
769777                                                                             }
770778                                                                         else throw("Strict value is not equal to itself.")
771779                                                                     }
772780                                                                 else throw("Strict value is not equal to itself.")
773781                                                             }
774782                                                         else throw("Strict value is not equal to itself.")
775783                                                     }
776784                                                 else throw("Strict value is not equal to itself.")
777785                                             }
778786                                         else throw("Strict value is not equal to itself.")
779787                                     }
780788                                 else throw("Strict value is not equal to itself.")
781789                             }
782790                         else throw("Strict value is not equal to itself.")
783791                     }
784792                 else throw("Strict value is not equal to itself.")
785793             }
786794         else throw("Strict value is not equal to itself.")
787795     }
788796 
789797 
790798 
791799 @Callable(i)
792800 func mintStaw (lockPeriod) = {
793801     let callerAddress = toBase58String(i.caller.bytes)
794802     let trxID = toBase58String(i.transactionId)
795803     let check1 = _throwIf((1 != size(i.payments)), "no payments attached")
796804     if ((check1 == check1))
797805         then {
798806             let check2 = if (isDefined(i.payments[0].assetId))
799807                 then throw("only waves supported")
800808                 else true
801809             if ((check2 == check2))
802810                 then {
803811                     let amountInWaves = i.payments[0].amount
804812                     let check3 = if (if ((_minLockAmount > amountInWaves))
805813                         then true
806814                         else (amountInWaves > _maxLockAmount))
807815                         then throw("lock amount out of range, minimum: 1 waves, maximum: 1000 waves")
808816                         else true
809817                     if ((check3 == check3))
810818                         then {
811819                             let check4 = if ((_minLockperiod > lockPeriod))
812820                                 then throw("minimum of 14 days lock period")
813821                                 else true
814822                             if ((check4 == check4))
815823                                 then {
816824                                     let totalStawMint = _stawMF(lockPeriod, amountInWaves)
817825                                     let stawPL = amountInWaves
818826                                     let fee = fraction(totalStawMint._1, 10, 100)
819827                                     let userGetStawAmount = (totalStawMint._1 - fee)
820828                                     let lockPeriodToMilisec = (_getNewTimeStamp(height) + _daysToMiliSec(lockPeriod))
821829                                     if ((lockPeriodToMilisec == lockPeriodToMilisec))
822830                                         then {
823831                                             let new_index =                                             match _getRegistryEntryValue(_globalIndexCount) {
824832                                                 case t: Int => 
825833                                                     (t + 1)
826834                                                 case _ => 
827835                                                     throw("failed to get current global index count")
828836                                             }
829837                                             if ((new_index == new_index))
830838                                                 then {
831839                                                     let addressFee =                                                     match _getRegistryEntryValue(_Dfx) {
832840                                                         case t: String => 
833841                                                             Address(fromBase58String(t))
834842                                                         case _ => 
835843                                                             throw("failed to get dfx address")
836844                                                     }
837845                                                     if ((addressFee == addressFee))
838846                                                         then {
839847                                                             let stawAssetId =                                                             match _getRegistryEntryValue(_stawAssetId) {
840848                                                                 case t: String => 
841849                                                                     fromBase58String(t)
842850                                                                 case _ => 
843851                                                                     throw("failed to get asset id")
844852                                                             }
845853                                                             if ((stawAssetId == stawAssetId))
846854                                                                 then {
847855                                                                     let lessee =                                                                     match _getRegistryEntryValue(_lesseeAddress) {
848856                                                                         case t: String => 
849857                                                                             Address(fromBase58String(t))
850858                                                                         case _ => 
851859                                                                             throw("failed to get lease node address")
852860                                                                     }
853861                                                                     if ((lessee == lessee))
854862                                                                         then {
855863                                                                             let userLockIndexKey = makeString([callerAddress, _userLocalIndexCount], SEP)
856864                                                                             let userTotalLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
857865                                                                             let userIndexCount =                                                                             match _getS(userLockIndexKey) {
858866                                                                                 case x: String => 
859867                                                                                     match _getRegistryEntryValue(userLockIndexKey) {
860868                                                                                         case t: Int => 
861869                                                                                             (t + 1)
862870                                                                                         case _ => 
863-                                                                                            0
871+                                                                                            1
864872                                                                                     }
865873                                                                                 case _ => 
866-                                                                                    0
874+                                                                                    1
867875                                                                             }
868876                                                                             if ((userIndexCount == userIndexCount))
869877                                                                                 then {
870878                                                                                     let userTotalLocked =                                                                                     match _getS(userTotalLockedKey) {
871879                                                                                         case x: String => 
872880                                                                                             match _getRegistryEntryValue(userTotalLockedKey) {
873881                                                                                                 case t: Int => 
874882                                                                                                     (t + amountInWaves)
875883                                                                                                 case _ => 
876884                                                                                                     amountInWaves
877885                                                                                             }
878886                                                                                         case _ => 
879887                                                                                             amountInWaves
880888                                                                                     }
881889                                                                                     if ((userTotalLocked == userTotalLocked))
882890                                                                                         then {
883891                                                                                             let leaseOut = Lease(lessee, amountInWaves)
884892                                                                                             let leaseIdStr = toBase58String(calculateLeaseId(leaseOut))
885893                                                                                             ((([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)
886894                                                                                             }
887895                                                                                         else throw("Strict value is not equal to itself.")
888896                                                                                     }
889897                                                                                 else throw("Strict value is not equal to itself.")
890898                                                                             }
891899                                                                         else throw("Strict value is not equal to itself.")
892900                                                                     }
893901                                                                 else throw("Strict value is not equal to itself.")
894902                                                             }
895903                                                         else throw("Strict value is not equal to itself.")
896904                                                     }
897905                                                 else throw("Strict value is not equal to itself.")
898906                                             }
899907                                         else throw("Strict value is not equal to itself.")
900908                                     }
901909                                 else throw("Strict value is not equal to itself.")
902910                             }
903911                         else throw("Strict value is not equal to itself.")
904912                     }
905913                 else throw("Strict value is not equal to itself.")
906914             }
907915         else throw("Strict value is not equal to itself.")
908916     }
909917 
910918 
github/deemru/w8io/169f3d6 
112.38 ms ◑