tx · FVXRvsAJjA4HdbRDCngJKawU5UMqKpkf5ATRYw5nxtSC

3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH:  -0.02500000 Waves

2023.03.18 11:01 [2495180] smart account 3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH > SELF 0.00000000 Waves

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

View: original | compacted
Prev: 2mpv6umohyuNVKvESwUrY9acrJvsuqhcR9NVgpvVxMgD
Next: 8FRpNf98EMv3oYEvpfy1bi29Ro2Z9AivHpe9yFqBze1a

Diff: 

OldNewDifferences
220220     else val
221221 
222222 
223-func _validateAddress (address) = match address {
223+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 _ => 
230-                throw("invalid address")
230+                match errorMsg {
231+                    case msg: String => 
232+                        throw(msg)
233+                    case _ => 
234+                        false
235+                }
231236         }
232237     case address: ByteVector => 
233238         let _address = addressFromPublicKey(address)
235240             case _address: Address => 
236241                 true
237242             case _ => 
238-                throw("invalid public key")
243+                match errorMsg {
244+                    case msg: String => 
245+                        throw(msg)
246+                    case _ => 
247+                        false
248+                }
239249         }
240250     case _ => 
241251         throw("invalid input type")
242252 }
243253 
244254 
245-func _validateAsset (assetID) = match assetInfo(fromBase58String(assetID)) {
255+func _validateAsset (assetID,errorMsg) = match assetInfo(fromBase58String(assetID)) {
246256     case asset: Asset => 
247257         true
248258     case _ => 
249-        false
259+        match errorMsg {
260+            case msg: String => 
261+                throw(msg)
262+            case _ => 
263+                false
264+        }
250265 }
251266 
252267 
446461         else true
447462     if ((managerAlreadyExists == managerAlreadyExists))
448463         then {
449-            let check1 = _validateAddress(manager)
464+            let check1 = _validateAddress(manager, "invalid address")
450465             if ((check1 == check1))
451466                 then {
452-                    let check2 = _validateAddress(dfx)
467+                    let check2 = _validateAddress(dfx, "invalid address")
453468                     if ((check2 == check2))
454469                         then {
455-                            let check3 = _validateAddress(leaseNode)
470+                            let check3 = _validateAddress(leaseNode, "invalid address")
456471                             if ((check3 == check3))
457472                                 then {
458-                                    let check4 = if (_validateAsset(assetID))
473+                                    let check4 = if (_validateAsset(assetID, "invalid asset"))
459474                                         then true
460475                                         else throw("invalid asset Id")
461476                                     if ((check4 == check4))
518533                                     let check4 =                                     match refAddress {
519534                                         case strType: String => 
520535                                             if ((size(strType) == size(stringValue)))
521-                                                then _validateAddress(stringValue)
522-                                                else if (_validateAsset(stringValue))
523-                                                    then true
524-                                                    else throw("string type for value not supported")
536+                                                then _validateAddress(stringValue, "string type for value not supported")
537+                                                else _validateAsset(stringValue, "string type for value not supported")
525538                                         case _ => 
526-                                            throw("type for value not supported")
539+                                            false
527540                                     }
528541                                     if ((check4 == check4))
529542                                         then [_writeGlobalParam(key, stringValue)]

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")
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 
223-func _validateAddress (address) = match address {
223+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 _ => 
230-                throw("invalid address")
230+                match errorMsg {
231+                    case msg: String => 
232+                        throw(msg)
233+                    case _ => 
234+                        false
235+                }
231236         }
232237     case address: ByteVector => 
233238         let _address = addressFromPublicKey(address)
234239         match _address {
235240             case _address: Address => 
236241                 true
237242             case _ => 
238-                throw("invalid public key")
243+                match errorMsg {
244+                    case msg: String => 
245+                        throw(msg)
246+                    case _ => 
247+                        false
248+                }
239249         }
240250     case _ => 
241251         throw("invalid input type")
242252 }
243253 
244254 
245-func _validateAsset (assetID) = match assetInfo(fromBase58String(assetID)) {
255+func _validateAsset (assetID,errorMsg) = match assetInfo(fromBase58String(assetID)) {
246256     case asset: Asset => 
247257         true
248258     case _ => 
249-        false
259+        match errorMsg {
260+            case msg: String => 
261+                throw(msg)
262+            case _ => 
263+                false
264+        }
250265 }
251266 
252267 
253268 func _computeMr () = {
254269     let currentCircIndex =     match _getRegistryEntryValue(_circulationIncrIndex) {
255270         case t: Int => 
256271             t
257272         case _ => 
258273             throw("circulation index not previously defined")
259274     }
260275     if ((currentCircIndex == currentCircIndex))
261276         then {
262277             let stawAssetId =             match _getRegistryEntryValue(_stawAssetId) {
263278                 case t: String => 
264279                     t
265280                 case _ => 
266281                     throw("asset id not previously defined")
267282             }
268283             if ((stawAssetId == stawAssetId))
269284                 then {
270285                     let stawCirculatingSupply =                     match assetInfo(fromBase58String(stawAssetId)) {
271286                         case asset: Asset => 
272287                             asset.quantity
273288                         case _ => 
274289                             throw(("asset not found for " + stawAssetId))
275290                     }
276291                     let unitIncrement = (_abs((stawCirculatingSupply - _incrementRef)) / _incrementRef)
277292                     let newCirculationIncrIndex = if ((unitIncrement > currentCircIndex))
278293                         then (unitIncrement + currentCircIndex)
279294                         else currentCircIndex
280295                     let currentMr =                     match _getRegistryEntryValue(_Mr) {
281296                         case t: Int => 
282297                             t
283298                         case _ => 
284299                             throw("failed to get miniting rate")
285300                     }
286301                     if ((newCirculationIncrIndex == currentCircIndex))
287302                         then $Tuple2(currentMr, nil)
288303                         else {
289304                             let newreductionFactor =                             match _getRegistryEntryValue(_percentageReductionFactor) {
290305                                 case t: Int => 
291306                                     t
292307                                 case _ => 
293308                                     throw("failed to get percentage reduction factor")
294309                             }
295310                             let newCurrentMr = (currentMr - fraction(currentMr, newreductionFactor, 100))
296311                             let store1 = _writeGlobalParam(_Mr, newCurrentMr)
297312                             let store2 = _writeGlobalParam(_percentageReductionFactor, newreductionFactor)
298313                             let store3 = _writeGlobalParam(_circulationIncrIndex, newCirculationIncrIndex)
299314                             $Tuple2(newCurrentMr, [store1, store2, store3])
300315                             }
301316                     }
302317                 else throw("Strict value is not equal to itself.")
303318             }
304319         else throw("Strict value is not equal to itself.")
305320     }
306321 
307322 
308323 func _updateGlobalEntry (wavesAmount,stawAmount,stawPL,indexCount) = {
309324     let _newGlobalTotalWavesAmtRef =     match _getRegistryEntryValue(_totalWavesRef) {
310325         case t: Int => 
311326             (t + wavesAmount)
312327         case _ => 
313328             throw("failed to get global total waves")
314329     }
315330     if ((_newGlobalTotalWavesAmtRef == _newGlobalTotalWavesAmtRef))
316331         then {
317332             let _newGlobalTotalStawMinted =             match _getRegistryEntryValue(_totalStaw) {
318333                 case t: Int => 
319334                     (t + stawAmount)
320335                 case _ => 
321336                     throw("failed to get global total staw minted")
322337             }
323338             if ((_newGlobalTotalStawMinted == _newGlobalTotalStawMinted))
324339                 then {
325340                     let _newGlobalTotalStawPL =                     match _getRegistryEntryValue(_totalStawLP) {
326341                         case t: Int => 
327342                             (t + stawPL)
328343                         case _ => 
329344                             throw("failed to get global total stawpl")
330345                     }
331346                     if ((_newGlobalTotalStawPL == _newGlobalTotalStawPL))
332347                         then {
333348                             let _newGlobaIndexCount =                             match _getRegistryEntryValue(_globalIndexCount) {
334349                                 case t: Int => 
335350                                     (t + indexCount)
336351                                 case _ => 
337352                                     throw("failed to get global index count")
338353                             }
339354                             if ((_newGlobaIndexCount == _newGlobaIndexCount))
340355                                 then [_writeGlobalParam(_totalWavesRef, _newGlobalTotalWavesAmtRef), _writeGlobalParam(_totalStaw, _newGlobalTotalStawMinted), _writeGlobalParam(_totalStawLP, _newGlobalTotalStawPL), _writeGlobalParam(_globalIndexCount, _newGlobaIndexCount)]
341356                                 else throw("Strict value is not equal to itself.")
342357                             }
343358                         else throw("Strict value is not equal to itself.")
344359                     }
345360                 else throw("Strict value is not equal to itself.")
346361             }
347362         else throw("Strict value is not equal to itself.")
348363     }
349364 
350365 
351366 func _registerUserEntry (transactionID,userAddress,lockDuration,lockDurationInMili,lockIndex,wavesAmount,stawAmount,stawLPAmount,lockAtHeight,lockId,totalLocked,localIndexCount,leaseState) = {
352367     let _txIdKey = makeString([userAddress, transactionID, _txId], SEP)
353368     let _lockDurationKey = makeString([userAddress, transactionID, _lockDuration], SEP)
354369     let _lockIndexKey = makeString([userAddress, transactionID, _lockIndex], SEP)
355370     let _wavesAmountKey = makeString([userAddress, transactionID, _wavesAmount], SEP)
356371     let _stawAmountKey = makeString([userAddress, transactionID, _stawAmount], SEP)
357372     let _stawLPAmountKey = makeString([userAddress, transactionID, _stawLPAmount], SEP)
358373     let _lockAtHeightKey = makeString([userAddress, transactionID, _lockAtHeight], SEP)
359374     let _lockIdKey = makeString([userAddress, transactionID, _lockId], SEP)
360375     let _totalLockedKey = makeString([userAddress, _userTotalLocked], SEP)
361376     let _localLockIndexKey = makeString([userAddress, _userLocalIndexCount], SEP)
362377     let _lockPeriodInMiliSecKey = makeString([userAddress, transactionID, _lockPeriodInMiliSec], SEP)
363378     let _totalWavesClaimedKey = makeString([userAddress, transactionID, _totalWavesClaimed], SEP)
364379     let _userLeaseStateKey = makeString([userAddress, transactionID, _userLeaseState], SEP)
365380     let trxIdEntry = makeString(["%s", transactionID], SEP)
366381     let lockDurationEntry = makeString(["%d", toString(lockDuration)], SEP)
367382     let lockIndexEntry = makeString(["%d", toString(lockIndex)], SEP)
368383     let wavesAmountEntry = makeString(["%d", toString(wavesAmount)], SEP)
369384     let stawAmountEntry = makeString(["%d", toString(stawAmount)], SEP)
370385     let stawLPAmountEntry = makeString(["%d", toString(stawLPAmount)], SEP)
371386     let lockAtHeightEntry = makeString(["%d", toString(lockAtHeight)], SEP)
372387     let lockIdEntry = makeString(["%b", lockId], SEP)
373388     let totalLockedEntry = makeString(["%d", toString(totalLocked)], SEP)
374389     let userLocalIndexEntry = makeString(["%d", toString(localIndexCount)], SEP)
375390     let lockPeriodInMiliSecEntry = makeString(["%d", toString(lockDurationInMili)], SEP)
376391     let totalWavesClaimedEntry = makeString(["%d", toString(0)], SEP)
377392     let userLeaseStateEntry = makeString(["%s", leaseState], SEP)
378393 [_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)]
379394     }
380395 
381396 
382397 func _stawMF (lockPeriod,collateralWaves) = {
383398     let _adjustedMr = _computeMr()
384399     let ret = (fraction(_unitDecimals, (_Dt * _adjustedMr._1), _Ppy(lockPeriod)) * collateralWaves)
385400     if ((size(_adjustedMr._2) == 0))
386401         then $Tuple2(ret, nil)
387402         else $Tuple2(ret, _adjustedMr._2)
388403     }
389404 
390405 
391406 func _emissionRateWaves (lockPeriod,collateral) = {
392407     let extensionFactor = fraction(lockPeriod, 15, 10)
393408     ((collateral / ((lockPeriod * extensionFactor) - lockPeriod)) * _Dt)
394409     }
395410 
396411 
397412 func _incrTotalStawLP (amount) = {
398413     let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
399414 [_writeInt(_totalStawLP, (oldStawLP + amount))]
400415     }
401416 
402417 
403418 func _decrTotalStawLP (amount) = {
404419     let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
405420 [_writeInt(_totalStawLP, (oldStawLP - amount))]
406421     }
407422 
408423 
409424 func _incrTotalWavesRef (amount) = {
410425     let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
411426 [_writeInt(_totalWavesRef, (oldWavesRef + amount))]
412427     }
413428 
414429 
415430 func _decrTotalWavesRef (amount) = {
416431     let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
417432 [_writeInt(_totalWavesRef, (oldWavesRef - amount))]
418433     }
419434 
420435 
421436 func _getNewTimeStamp (blockHeight) = {
422437     let time =     match blockInfoByHeight(blockHeight) {
423438         case timeInfo: BlockInfo => 
424439             timeInfo.timestamp
425440         case _ => 
426441             throw("counld get timestamp")
427442     }
428443     time
429444     }
430445 
431446 
432447 @Callable(i)
433448 func getEmission (lockPeriod,collateral) = {
434449     let check1 = _onlyManager(i)
435450     if ((check1 == check1))
436451         then $Tuple2(nil, _emissionRateWaves(lockPeriod, collateral))
437452         else throw("Strict value is not equal to itself.")
438453     }
439454 
440455 
441456 
442457 @Callable(i)
443458 func init (manager,dfx,assetID,leaseNode) = {
444459     let managerAlreadyExists = if (isDefined(_getS(_manager)))
445460         then _onlyManager(i)
446461         else true
447462     if ((managerAlreadyExists == managerAlreadyExists))
448463         then {
449-            let check1 = _validateAddress(manager)
464+            let check1 = _validateAddress(manager, "invalid address")
450465             if ((check1 == check1))
451466                 then {
452-                    let check2 = _validateAddress(dfx)
467+                    let check2 = _validateAddress(dfx, "invalid address")
453468                     if ((check2 == check2))
454469                         then {
455-                            let check3 = _validateAddress(leaseNode)
470+                            let check3 = _validateAddress(leaseNode, "invalid address")
456471                             if ((check3 == check3))
457472                                 then {
458-                                    let check4 = if (_validateAsset(assetID))
473+                                    let check4 = if (_validateAsset(assetID, "invalid asset"))
459474                                         then true
460475                                         else throw("invalid asset Id")
461476                                     if ((check4 == check4))
462477                                         then {
463478                                             let circulationIndex = _setParamVal(_circulationIncrIndex, 0)
464479                                             let percentageReductionInMr = _setParamVal(_percentageReductionFactor, 0)
465480                                             let Mr = _setParamVal(_Mr, _unitDecimals)
466481                                             let totalStawMinted = _setParamVal(_totalStaw, 0)
467482                                             let totalStawLPInCirculation = _setParamVal(_totalStawLP, 0)
468483                                             let globalIndexCount = _setParamVal(_globalIndexCount, 0)
469484                                             let totalWavesRef = _setParamVal(_totalWavesRef, 0)
470485 [_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)]
471486                                             }
472487                                         else throw("Strict value is not equal to itself.")
473488                                     }
474489                                 else throw("Strict value is not equal to itself.")
475490                             }
476491                         else throw("Strict value is not equal to itself.")
477492                     }
478493                 else throw("Strict value is not equal to itself.")
479494             }
480495         else throw("Strict value is not equal to itself.")
481496     }
482497 
483498 
484499 
485500 @Callable(i)
486501 func modifyGlobalParams (val) = {
487502     let check1 = _onlyManager(i)
488503     if ((check1 == check1))
489504         then {
490505             let errorMsg = makeString(["got", "list size of", toString(size(val)), "but expected [global_key, value] pair"], " ")
491506             let check2 = _throwIf((size(val) != 2), errorMsg)
492507             if ((check2 == check2))
493508                 then {
494509                     let key = val[0]
495510                     let valType = parseInt(val[1])
496511                     match valType {
497512                         case x: Int => 
498513                             let validateKey = _throwIf((_getS(key) == unit), (("key " + key) + " not recognized"))
499514                             if ((validateKey == validateKey))
500515                                 then {
501516                                     let ensureValidPairs =                                     match _getRegistryEntryValue(key) {
502517                                         case t: Int => 
503518                                             true
504519                                         case _ => 
505520                                             throw("invalid key-value pair")
506521                                     }
507522                                     if ((ensureValidPairs == ensureValidPairs))
508523                                         then [_writeGlobalParam(key, x)]
509524                                         else throw("Strict value is not equal to itself.")
510525                                     }
511526                                 else throw("Strict value is not equal to itself.")
512527                         case x: Unit => 
513528                             let validateKey = _throwIf((_getS(key) == unit), (("key " + key) + " not recognized"))
514529                             if ((validateKey == validateKey))
515530                                 then {
516531                                     let stringValue = val[1]
517532                                     let refAddress = _getRegistryEntryValue(_manager)
518533                                     let check4 =                                     match refAddress {
519534                                         case strType: String => 
520535                                             if ((size(strType) == size(stringValue)))
521-                                                then _validateAddress(stringValue)
522-                                                else if (_validateAsset(stringValue))
523-                                                    then true
524-                                                    else throw("string type for value not supported")
536+                                                then _validateAddress(stringValue, "string type for value not supported")
537+                                                else _validateAsset(stringValue, "string type for value not supported")
525538                                         case _ => 
526-                                            throw("type for value not supported")
539+                                            false
527540                                     }
528541                                     if ((check4 == check4))
529542                                         then [_writeGlobalParam(key, stringValue)]
530543                                         else throw("Strict value is not equal to itself.")
531544                                     }
532545                                 else throw("Strict value is not equal to itself.")
533546                         case _ => 
534547                             throw(("failed to modify " + val[0]))
535548                     }
536549                     }
537550                 else throw("Strict value is not equal to itself.")
538551             }
539552         else throw("Strict value is not equal to itself.")
540553     }
541554 
542555 
543556 
544557 @Callable(i)
545558 func revokeLock () = {
546559     let check1 = _onlyManager(i)
547560     if ((check1 == check1))
548561         then nil
549562         else throw("Strict value is not equal to itself.")
550563     }
551564 
552565 
553566 
554567 @Callable(i)
555568 func claim (transactionID) = {
556569     let callerAddress = toBase58String(i.caller.bytes)
557570     let collateralKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
558571     let lockperiodKey = makeString([callerAddress, transactionID, _lockDuration], SEP)
559572     let lockIdKey = makeString([callerAddress, transactionID, _lockId], SEP)
560573     let lockperiodInMiliKey = makeString([callerAddress, transactionID, _lockPeriodInMiliSec], SEP)
561574     let totalWavesClaimedKey = makeString([callerAddress, transactionID, _totalWavesClaimed], SEP)
562575     let stawLPAmountKey = makeString([callerAddress, transactionID, _stawLPAmount], SEP)
563576     let wavesAmountKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
564577     let userTotalWavesLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
565578     let userLeaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
566579     let leaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
567580     let globalWavesRef =     match _getRegistryEntryValue(_totalWavesRef) {
568581         case t: Int => 
569582             t
570583         case _ => 
571584             throw("failed to get global total waves")
572585     }
573586     if ((globalWavesRef == globalWavesRef))
574587         then {
575588             let globalStawPL =             match _getRegistryEntryValue(_totalStawLP) {
576589                 case t: Int => 
577590                     t
578591                 case _ => 
579592                     throw("failed to get global total waves")
580593             }
581594             if ((globalStawPL == globalStawPL))
582595                 then {
583596                     let lockId =                     match _getRegistryEntryValue(lockIdKey) {
584597                         case t: ByteVector => 
585598                             t
586599                         case _ => 
587600                             throw("failed to get lease id")
588601                     }
589602                     if ((lockId == lockId))
590603                         then {
591604                             let userTotalWavesLocked =                             match _getRegistryEntryValue(userTotalWavesLockedKey) {
592605                                 case t: Int => 
593606                                     t
594607                                 case _ => 
595608                                     throw("failed to get total waves locked by this address")
596609                             }
597610                             if ((userTotalWavesLocked == userTotalWavesLocked))
598611                                 then {
599612                                     let wavesAmount =                                     match _getRegistryEntryValue(wavesAmountKey) {
600613                                         case t: Int => 
601614                                             t
602615                                         case _ => 
603616                                             throw("failed to get total waves locked")
604617                                     }
605618                                     if ((wavesAmount == wavesAmount))
606619                                         then {
607620                                             let totalWavesClaimed =                                             match _getRegistryEntryValue(totalWavesClaimedKey) {
608621                                                 case t: Int => 
609622                                                     t
610623                                                 case _ => 
611624                                                     throw("failed to get total waves claimed")
612625                                             }
613626                                             if ((totalWavesClaimed == totalWavesClaimed))
614627                                                 then {
615628                                                     let stawLPAmount =                                                     match _getRegistryEntryValue(stawLPAmountKey) {
616629                                                         case t: Int => 
617630                                                             t
618631                                                         case _ => 
619632                                                             throw("failed to get stawPL")
620633                                                     }
621634                                                     if ((stawLPAmount == stawLPAmount))
622635                                                         then {
623636                                                             let lockPeriodInMili =                                                             match _getRegistryEntryValue(lockperiodInMiliKey) {
624637                                                                 case t: Int => 
625638                                                                     t
626639                                                                 case _ => 
627640                                                                     throw("failed to get lock period timespam")
628641                                                             }
629642                                                             if ((lockPeriodInMili == lockPeriodInMili))
630643                                                                 then {
631644                                                                     let currentTimeStamp =                                                                     match _getNewTimeStamp(height) {
632645                                                                         case t: Int => 
633646                                                                             t
634647                                                                         case _ => 
635648                                                                             throw("failed to get current timestamp")
636649                                                                     }
637650                                                                     if ((currentTimeStamp == currentTimeStamp))
638651                                                                         then {
639652                                                                             let collateral =                                                                             match _getRegistryEntryValue(collateralKey) {
640653                                                                                 case t: Int => 
641654                                                                                     t
642655                                                                                 case _ => 
643656                                                                                     throw("failed to get collateral")
644657                                                                             }
645658                                                                             if ((collateral == collateral))
646659                                                                                 then {
647660                                                                                     let lockPeriod =                                                                                     match _getRegistryEntryValue(lockperiodKey) {
648661                                                                                         case t: Int => 
649662                                                                                             t
650663                                                                                         case _ => 
651664                                                                                             throw("failed to get lockPeriod")
652665                                                                                     }
653666                                                                                     if ((lockPeriod == lockPeriod))
654667                                                                                         then {
655668                                                                                             let currentLeaseState =                                                                                             match _getRegistryEntryValue(userLeaseStateKey) {
656669                                                                                                 case t: String => 
657670                                                                                                     t
658671                                                                                                 case _ => 
659672                                                                                                     throw("failed to get lease state")
660673                                                                                             }
661674                                                                                             if ((currentLeaseState == currentLeaseState))
662675                                                                                                 then {
663676                                                                                                     let leaseState =                                                                                                     match _getRegistryEntryValue(leaseStateKey) {
664677                                                                                                         case t: String => 
665678                                                                                                             t
666679                                                                                                         case _ => 
667680                                                                                                             throw("failed to get lease state for user")
668681                                                                                                     }
669682                                                                                                     if ((leaseState == leaseState))
670683                                                                                                         then {
671684                                                                                                             let check1 = _throwIf((lockPeriodInMili > currentTimeStamp), "lock period for this entry has not elapsed")
672685                                                                                                             if ((check1 == check1))
673686                                                                                                                 then {
674687                                                                                                                     let leaseAction = if ((currentLeaseState == "leased"))
675688                                                                                                                         then $Tuple2(LeaseCancel(lockId), _writeStr(userLeaseStateKey, "cancelled"))
676689                                                                                                                         else $Tuple2(_writeStr(userLeaseStateKey, "cancelled"), _writeStr(userLeaseStateKey, "cancelled"))
677690                                                                                                                     if ((leaseAction == leaseAction))
678691                                                                                                                         then {
679692                                                                                                                             let check2 = _throwIf(if ((0 == wavesAmount))
680693                                                                                                                                 then true
681694                                                                                                                                 else (0 == stawLPAmount), "all claims exhausted for this trx")
682695                                                                                                                             if ((check2 == check2))
683696                                                                                                                                 then {
684697                                                                                                                                     let emissionValuePerDT = (_emissionRateWaves(lockPeriod, collateral) * _Dt)
685698                                                                                                                                     let claimAction = {
686699                                                                                                                                         let timeStampDiff = (currentTimeStamp - lockPeriodInMili)
687700                                                                                                                                         let daysAfterLockPeriodElasped = (timeStampDiff / _Dt)
688701                                                                                                                                         if ((daysAfterLockPeriodElasped == 0))
689702                                                                                                                                             then throw("less than 24hrs before first claim")
690703                                                                                                                                             else if (((timeStampDiff % _Dt) != 0))
691704                                                                                                                                                 then throw("already claimed or less than 24hrs before next claim")
692705                                                                                                                                                 else if ((daysAfterLockPeriodElasped > lockPeriod))
693706                                                                                                                                                     then throw("all claims exhausted")
694707                                                                                                                                                     else {
695708                                                                                                                                                         let totalAmountClaimable = (daysAfterLockPeriodElasped * emissionValuePerDT)
696709                                                                                                                                                         let check3_1 = _throwIf((totalAmountClaimable == totalWavesClaimed), "can only claim once in 24hrs")
697710                                                                                                                                                         if ((check3_1 == check3_1))
698711                                                                                                                                                             then {
699712                                                                                                                                                                 let check3_2 = _throwIf(((totalAmountClaimable + totalWavesClaimed) > wavesAmount), "all claims exhausted")
700713                                                                                                                                                                 if ((check3_2 == check3_2))
701714                                                                                                                                                                     then {
702715                                                                                                                                                                         let claimAmountToSend = if ((daysAfterLockPeriodElasped == 1))
703716                                                                                                                                                                             then totalAmountClaimable
704717                                                                                                                                                                             else (totalAmountClaimable - totalWavesClaimed)
705718                                                                                                                                                                         let newTotalWavesClaim = totalAmountClaimable
706719                                                                                                                                                                         let newWavesAmount = if ((daysAfterLockPeriodElasped == 1))
707720                                                                                                                                                                             then (wavesAmount - totalAmountClaimable)
708721                                                                                                                                                                             else (wavesAmount - (totalAmountClaimable - totalWavesClaimed))
709722                                                                                                                                                                         let newStawLPAmount = if ((daysAfterLockPeriodElasped == 1))
710723                                                                                                                                                                             then (stawLPAmount - totalAmountClaimable)
711724                                                                                                                                                                             else (stawLPAmount - (totalAmountClaimable - totalWavesClaimed))
712725                                                                                                                                                                         let newGlobalWaveRef = (globalWavesRef - newWavesAmount)
713726                                                                                                                                                                         let newGlobalStawPL = (globalStawPL - newStawLPAmount)
714727                                                                                                                                                                         let newUserTotalWavesLocked = (userTotalWavesLocked - claimAmountToSend)
715728                                                                                                                                                                         let wavesAmountEntry = makeString(["%d", toString(newWavesAmount)], SEP)
716729                                                                                                                                                                         let stawLPAmountEntry = makeString(["%d", toString(newStawLPAmount)], SEP)
717730                                                                                                                                                                         let totalWavesClaimedEntry = makeString(["%d", toString(newTotalWavesClaim)], SEP)
718731                                                                                                                                                                         let newUserTotalWavesLockedEntry = makeString(["%d", toString(newUserTotalWavesLocked)], SEP)
719732 [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)]
720733                                                                                                                                                                         }
721734                                                                                                                                                                     else throw("Strict value is not equal to itself.")
722735                                                                                                                                                                 }
723736                                                                                                                                                             else throw("Strict value is not equal to itself.")
724737                                                                                                                                                         }
725738                                                                                                                                         }
726739                                                                                                                                     if ((claimAction == claimAction))
727740                                                                                                                                         then claimAction
728741                                                                                                                                         else throw("Strict value is not equal to itself.")
729742                                                                                                                                     }
730743                                                                                                                                 else throw("Strict value is not equal to itself.")
731744                                                                                                                             }
732745                                                                                                                         else throw("Strict value is not equal to itself.")
733746                                                                                                                     }
734747                                                                                                                 else throw("Strict value is not equal to itself.")
735748                                                                                                             }
736749                                                                                                         else throw("Strict value is not equal to itself.")
737750                                                                                                     }
738751                                                                                                 else throw("Strict value is not equal to itself.")
739752                                                                                             }
740753                                                                                         else throw("Strict value is not equal to itself.")
741754                                                                                     }
742755                                                                                 else throw("Strict value is not equal to itself.")
743756                                                                             }
744757                                                                         else throw("Strict value is not equal to itself.")
745758                                                                     }
746759                                                                 else throw("Strict value is not equal to itself.")
747760                                                             }
748761                                                         else throw("Strict value is not equal to itself.")
749762                                                     }
750763                                                 else throw("Strict value is not equal to itself.")
751764                                             }
752765                                         else throw("Strict value is not equal to itself.")
753766                                     }
754767                                 else throw("Strict value is not equal to itself.")
755768                             }
756769                         else throw("Strict value is not equal to itself.")
757770                     }
758771                 else throw("Strict value is not equal to itself.")
759772             }
760773         else throw("Strict value is not equal to itself.")
761774     }
762775 
763776 
764777 
765778 @Callable(i)
766779 func mintStaw (lockPeriod) = {
767780     let callerAddress = toBase58String(i.caller.bytes)
768781     let trxID = toBase58String(i.transactionId)
769782     let check1 = _throwIf((1 != size(i.payments)), "no payments attached")
770783     if ((check1 == check1))
771784         then {
772785             let check2 = if (isDefined(i.payments[0].assetId))
773786                 then throw("only waves supported")
774787                 else true
775788             if ((check2 == check2))
776789                 then {
777790                     let amountInWaves = i.payments[0].amount
778791                     let check3 = if (if ((_minLockAmount > amountInWaves))
779792                         then true
780793                         else (amountInWaves > _maxLockAmount))
781794                         then throw("lock amount out of range, minimum: 1 waves, maximum: 1000 waves")
782795                         else true
783796                     if ((check3 == check3))
784797                         then {
785798                             let check4 = if ((_minLockperiod > lockPeriod))
786799                                 then throw("minimum of 14 days lock period")
787800                                 else true
788801                             if ((check4 == check4))
789802                                 then {
790803                                     let totalStawMint = _stawMF(lockPeriod, amountInWaves)
791804                                     let stawPL = amountInWaves
792805                                     let fee = fraction(totalStawMint._1, 10, 100)
793806                                     let userGetStawAmount = (totalStawMint._1 - fee)
794807                                     let lockPeriodToMilisec = (_getNewTimeStamp(height) + _daysToMiliSec(lockPeriod))
795808                                     if ((lockPeriodToMilisec == lockPeriodToMilisec))
796809                                         then {
797810                                             let new_index =                                             match _getRegistryEntryValue(_globalIndexCount) {
798811                                                 case t: Int => 
799812                                                     (t + 1)
800813                                                 case _ => 
801814                                                     throw("failed to get current global index count")
802815                                             }
803816                                             if ((new_index == new_index))
804817                                                 then {
805818                                                     let addressFee =                                                     match _getRegistryEntryValue(_Dfx) {
806819                                                         case t: String => 
807820                                                             Address(fromBase58String(t))
808821                                                         case _ => 
809822                                                             throw("failed to get dfx address")
810823                                                     }
811824                                                     if ((addressFee == addressFee))
812825                                                         then {
813826                                                             let stawAssetId =                                                             match _getRegistryEntryValue(_stawAssetId) {
814827                                                                 case t: String => 
815828                                                                     fromBase58String(t)
816829                                                                 case _ => 
817830                                                                     throw("failed to get asset id")
818831                                                             }
819832                                                             if ((stawAssetId == stawAssetId))
820833                                                                 then {
821834                                                                     let lessee =                                                                     match _getRegistryEntryValue(_lesseeAddress) {
822835                                                                         case t: String => 
823836                                                                             Address(fromBase58String(t))
824837                                                                         case _ => 
825838                                                                             throw("failed to get lease node address")
826839                                                                     }
827840                                                                     if ((lessee == lessee))
828841                                                                         then {
829842                                                                             let userLockIndexKey = makeString([callerAddress, _userLocalIndexCount], SEP)
830843                                                                             let userTotalLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
831844                                                                             let userIndexCount =                                                                             match _getRegistryEntryValue(userLockIndexKey) {
832845                                                                                 case x: Int => 
833846                                                                                     (x + 1)
834847                                                                                 case _ => 
835848                                                                                     0
836849                                                                             }
837850                                                                             if ((userIndexCount == userIndexCount))
838851                                                                                 then {
839852                                                                                     let userTotalLocked =                                                                                     match _getRegistryEntryValue(userTotalLockedKey) {
840853                                                                                         case x: Int => 
841854                                                                                             (x + amountInWaves)
842855                                                                                         case _ => 
843856                                                                                             amountInWaves
844857                                                                                     }
845858                                                                                     if ((userTotalLocked == userTotalLocked))
846859                                                                                         then {
847860                                                                                             let leaseOut = Lease(lessee, amountInWaves)
848861                                                                                             if ((leaseOut == leaseOut))
849862                                                                                                 then {
850863                                                                                                     let leaseIdStr = toBase58String(calculateLeaseId(leaseOut))
851864                                                                                                     if ((leaseIdStr == leaseIdStr))
852865                                                                                                         then ((([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)
853866                                                                                                         else throw("Strict value is not equal to itself.")
854867                                                                                                     }
855868                                                                                                 else throw("Strict value is not equal to itself.")
856869                                                                                             }
857870                                                                                         else throw("Strict value is not equal to itself.")
858871                                                                                     }
859872                                                                                 else throw("Strict value is not equal to itself.")
860873                                                                             }
861874                                                                         else throw("Strict value is not equal to itself.")
862875                                                                     }
863876                                                                 else throw("Strict value is not equal to itself.")
864877                                                             }
865878                                                         else throw("Strict value is not equal to itself.")
866879                                                     }
867880                                                 else throw("Strict value is not equal to itself.")
868881                                             }
869882                                         else throw("Strict value is not equal to itself.")
870883                                     }
871884                                 else throw("Strict value is not equal to itself.")
872885                             }
873886                         else throw("Strict value is not equal to itself.")
874887                     }
875888                 else throw("Strict value is not equal to itself.")
876889             }
877890         else throw("Strict value is not equal to itself.")
878891     }
879892 
880893 
github/deemru/w8io/169f3d6 
107.90 ms ◑