tx · CEAU4AETXpN3kKocb6qY3BTECyLTM9JC17jHvzNbSvhf

3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH:  -0.02300000 Waves

2023.03.14 21:15 [2490073] smart account 3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CEAU4AETXpN3kKocb6qY3BTECyLTM9JC17jHvzNbSvhf",
    "fee": 2300000,
    "feeAssetId": null,
    "timestamp": 1678817797737,
    "version": 2,
    "chainId": 84,
    "sender": "3MwukwUkp3PsyCrkjMgqiAnSfc1hBD5FQhH",
    "senderPublicKey": "5JqBVJpMCyD7dJLJttqYjL6CmJc4zahBHSFjFb7qQTga",
    "proofs": [
        "36JPfrhMJDYLfdkvC95uDDVudkSAVTT7MCwvynjf5MFhNrFbRHrv5rf7KL7V1ZjBEgwY7t311Y5EdjdgJ3PAQ5vN"
    ],
    "script": "base64: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",
    "height": 2490073,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: BrD3yKLCRSTm1M2QvaYNxdP5oXiDN4K79ZVw6yghUNrx

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "_"
5+
6+let _minLockperiod = 1
7+
8+let _unitDecimals = 100000000
9+
10+let _minLockAmount = (1 * _unitDecimals)
11+
12+let _maxLockAmount = (1000 * _unitDecimals)
13+
14+let _Dt = 86400000
15+
16+func _Ppy (lockPeriod) = fraction(_unitDecimals, 365, lockPeriod)
17+
18+
19+let _incrementRef = (1000000 * _unitDecimals)
20+
21+let _percentageFee = fraction(_unitDecimals, 10, 100)
22+
23+let _percentageReductionFactor = "Current_PercentageReduction_Factor_For_Mr"
24+
25+let _Mr = "Minting_Rate"
26+
27+let _stawAssetId = "Staw_AssetId"
28+
29+let _manager = "manager"
30+
31+let _Dfx = "Dfx"
32+
33+let _circulationIncrIndex = "CirculationIncrementIndex"
34+
35+let _lesseeAddress = "LeaseNode"
36+
37+let _userEmissionAmountClaimed = "EmissionAmountClaimed"
38+
39+let _userCanClaimEmissionAmount = "CanClaimEmissionAmount"
40+
41+let _userAddress = "WalletAddress"
42+
43+let _userLocalIndexCount = "TotalEntryIndexCount"
44+
45+let _userTotalLocked = "TotalLocked"
46+
47+let _lockDuration = "LockDuration"
48+
49+let _lockIndex = "GlobalLockIndex"
50+
51+let _lockId = "LockIdentifier"
52+
53+let _wavesAmount = "AmountInWaves"
54+
55+let _stawAmount = "AmountInStaw"
56+
57+let _stawLPAmount = "AmountInStawLP"
58+
59+let _txId = "TXID"
60+
61+let _lockAtHeight = "LockAtHeight"
62+
63+let _lockPeriodInMiliSec = "LocKPeriodInMilliSec"
64+
65+let _totalWavesClaimed = "TotalWavesClaimed"
66+
67+let _userLeaseState = "LeaseState"
68+
69+let _totalStaw = "TotalStawMinted"
70+
71+let _totalWavesRef = "TotalWavesLocked"
72+
73+let _totalStawLP = "TotalStawLP"
74+
75+let _globalIndexCount = "IndexCount"
76+
77+func _getI (key) = getInteger(this, key)
78+
79+
80+func _getS (key) = getString(this, key)
81+
82+
83+func _getB (key) = getBoolean(this, key)
84+
85+
86+func _getBV (key) = value(getBoolean(this, key))
87+
88+
89+func _getIV (key) = value(getInteger(this, key))
90+
91+
92+func _getSV (key) = value(getString(this, key))
93+
94+
95+func _setParamVal (key,defaultVal) = match defaultVal {
96+    case defaultVal: String => 
97+        if (isDefined(_getS(key)))
98+            then _getSV(key)
99+            else defaultVal
100+    case defaultVal: Int => 
101+        if (isDefined(_getI(key)))
102+            then _getIV(key)
103+            else defaultVal
104+    case defaultVal: Boolean => 
105+        if (isDefined(_getB(key)))
106+            then _getBV(key)
107+            else defaultVal
108+    case _ => 
109+        throw(("value type not supported for " + key))
110+}
111+
112+
113+func _throwOrReturnS (val,error) = match val {
114+    case val: String => 
115+        val
116+    case _ => 
117+        throw(error)
118+}
119+
120+
121+func _throwOrReturnI (val,error) = match val {
122+    case val: Int => 
123+        val
124+    case _ => 
125+        throw(error)
126+}
127+
128+
129+func _throwOrReturnBool (val,error) = match val {
130+    case val: Boolean => 
131+        val
132+    case _ => 
133+        throw(error)
134+}
135+
136+
137+func _writeInt (key,value) = if ((0 > value))
138+    then throw(((("writing negative value " + toString(value)) + " for key ") + key))
139+    else IntegerEntry(key, value)
140+
141+
142+func _writeStr (key,value) = if ((" " == value))
143+    then throw(("writing an empty string " + value))
144+    else StringEntry(key, value)
145+
146+
147+func _throwIf (condition,error) = if (condition)
148+    then throw(error)
149+    else true
150+
151+
152+func _writeGlobalParam (key,_value) = match _value {
153+    case _value: Int => 
154+        let entry = makeString(["%d", toString(_value)], SEP)
155+        _writeStr(key, entry)
156+    case _value: String => 
157+        let entry = makeString(["%s", _value], SEP)
158+        _writeStr(key, entry)
159+    case _value: Boolean => 
160+        let entry = makeString(["%b", toString(_value)], SEP)
161+        _writeStr(key, entry)
162+    case _ => 
163+        throw("type not supported")
164+}
165+
166+
167+func _daysToMiliSec (days) = {
168+    let check = _throwIf((days >= 0), "invalid locking days!")
169+    if ((check == check))
170+        then (days * _Dt)
171+        else throw("Strict value is not equal to itself.")
172+    }
173+
174+
175+func _writeConstString (key,value) = if (!(isDefined(_getS(key))))
176+    then _writeStr(key, value)
177+    else throw(("entry already initialized: " + key))
178+
179+
180+func _writeConstInteger (key,value) = if (!(isDefined(_getS(key))))
181+    then _writeInt(key, value)
182+    else throw((" entry already initialized: " + key))
183+
184+
185+func _onlyManager (i) = {
186+    let manager = _throwOrReturnS(_getS(_manager), "manager not found")
187+    if ((manager == manager))
188+        then _throwIf((toBase58String(i.caller.bytes) != manager), "address not authorized")
189+        else throw("Strict value is not equal to itself.")
190+    }
191+
192+
193+func _abs (val) = if ((0 > val))
194+    then -(val)
195+    else val
196+
197+
198+func _validateAddress (address) = match address {
199+    case address: String => 
200+        let _address = addressFromString(address)
201+        match _address {
202+            case _address: Address => 
203+                true
204+            case _ => 
205+                throw("invalid address")
206+        }
207+    case address: ByteVector => 
208+        let _address = addressFromPublicKey(address)
209+        match _address {
210+            case _address: Address => 
211+                true
212+            case _ => 
213+                throw("invalid public key")
214+        }
215+    case _ => 
216+        throw("invalid input type")
217+}
218+
219+
220+func _computeMr () = {
221+    let currentCircIndex = _throwOrReturnI(_getI(_circulationIncrIndex), "increment index not previously defined")
222+    if ((currentCircIndex == currentCircIndex))
223+        then {
224+            let stawAssetId = _throwOrReturnS(_getS(_stawAssetId), "asset id not previouly defined")
225+            if ((stawAssetId == stawAssetId))
226+                then {
227+                    let stawCirculatingSupply =                     match assetInfo(fromBase58String(stawAssetId)) {
228+                        case asset: Asset => 
229+                            asset.quantity
230+                        case _ => 
231+                            throw(("asset not found for " + stawAssetId))
232+                    }
233+                    let unitIncrement = (_abs((stawCirculatingSupply - _incrementRef)) / _incrementRef)
234+                    let newCirculationIncrIndex = if ((unitIncrement > currentCircIndex))
235+                        then (unitIncrement + currentCircIndex)
236+                        else currentCircIndex
237+                    let currentMr = _throwOrReturnI(_Mr, "miniting rate not previously defined")
238+                    if ((newCirculationIncrIndex == currentCircIndex))
239+                        then currentMr
240+                        else {
241+                            let newreductionFactor = (_throwOrReturnI(_percentageReductionFactor, "reduction factor not previously defined") + 10)
242+                            let newCurrentMr = (currentMr - fraction(currentMr, newreductionFactor, 100))
243+                            let store1 = _writeInt(_Mr, newCurrentMr)
244+                            if ((store1 == store1))
245+                                then {
246+                                    let store2 = _writeInt(_percentageReductionFactor, newreductionFactor)
247+                                    if ((store2 == store2))
248+                                        then {
249+                                            let store3 = _writeInt(_circulationIncrIndex, newCirculationIncrIndex)
250+                                            if ((store3 == store3))
251+                                                then newCurrentMr
252+                                                else throw("Strict value is not equal to itself.")
253+                                            }
254+                                        else throw("Strict value is not equal to itself.")
255+                                    }
256+                                else throw("Strict value is not equal to itself.")
257+                            }
258+                    }
259+                else throw("Strict value is not equal to itself.")
260+            }
261+        else throw("Strict value is not equal to itself.")
262+    }
263+
264+
265+func _getRegistryEntryValue (key) = {
266+    let _rawValue = _throwOrReturnS(_getS(key), "entry not found")
267+    if ((_rawValue == _rawValue))
268+        then {
269+            let x = split(_rawValue, SEP)
270+            let formatSpecifier = takeRight(x[0], 1)
271+            let _valueString = x[(size(x) - 1)]
272+            let _value = if ((formatSpecifier == "s"))
273+                then _valueString
274+                else if ((formatSpecifier == "d"))
275+                    then parseIntValue(_valueString)
276+                    else if ((formatSpecifier == "b"))
277+                        then fromBase58String(_valueString)
278+                        else throw(("could not parse registry value for " + key))
279+            _value
280+            }
281+        else throw("Strict value is not equal to itself.")
282+    }
283+
284+
285+func _updateGlobalEntry (wavesAmount,stawAmount,stawPL,indexCount) = {
286+    let _newGlobalTotalWavesAmtRef = (_throwOrReturnI(_getI(_totalWavesRef), "global waves sum not previously defined") + wavesAmount)
287+    let _newGlobalTotalStawMinted = (_throwOrReturnI(_getI(_totalStaw), "gobal staw minted not previously defined") + stawAmount)
288+    let _newGlobalTotalStawPL = (_throwOrReturnI(_getI(_totalStawLP), "global stawPL not previously defined") + stawPL)
289+    let _newGlobaIndexCount = (_throwOrReturnI(_getI(_globalIndexCount), "global index count not previously defined") + indexCount)
290+[_writeInt(_totalWavesRef, _newGlobalTotalWavesAmtRef), _writeInt(_totalStaw, _newGlobalTotalStawMinted), _writeInt(_totalStawLP, _newGlobalTotalStawPL), _writeInt(_globalIndexCount, _newGlobaIndexCount)]
291+    }
292+
293+
294+func _registerUserEntry (transactionID,userAddress,lockDuration,lockDurationInMili,lockIndex,wavesAmount,stawAmount,stawLPAmount,lockAtHeight,lockId,totalLocked,localIndexCount,leaseState) = {
295+    let _txIdKey = makeString([userAddress, transactionID, _txId], SEP)
296+    let _lockDurationKey = makeString([userAddress, transactionID, _lockDuration], SEP)
297+    let _lockIndexKey = makeString([userAddress, transactionID, _lockIndex], SEP)
298+    let _wavesAmountKey = makeString([userAddress, transactionID, _wavesAmount], SEP)
299+    let _stawAmountKey = makeString([userAddress, transactionID, _stawAmount], SEP)
300+    let _stawLPAmountKey = makeString([userAddress, transactionID, _stawLPAmount], SEP)
301+    let _lockAtHeightKey = makeString([userAddress, transactionID, _lockAtHeight], SEP)
302+    let _lockIdKey = makeString([userAddress, transactionID, _lockId], SEP)
303+    let _totalLockedKey = makeString([userAddress, _userTotalLocked], SEP)
304+    let _localLockIndexKey = makeString([userAddress, _userLocalIndexCount], SEP)
305+    let _lockPeriodInMiliSecKey = makeString([userAddress, transactionID, _lockPeriodInMiliSec], SEP)
306+    let _totalWavesClaimedKey = makeString([userAddress, transactionID, _totalWavesClaimed], SEP)
307+    let _userLeaseStateKey = makeString([userAddress, transactionID, _userLeaseState], SEP)
308+    let trxIdEntry = makeString(["%s", transactionID], SEP)
309+    let lockDurationEntry = makeString(["%d", toString(lockDuration)], SEP)
310+    let lockIndexEntry = makeString(["%d", toString(lockIndex)], SEP)
311+    let wavesAmountEntry = makeString(["%d", toString(wavesAmount)], SEP)
312+    let stawAmountEntry = makeString(["%d", toString(stawAmount)], SEP)
313+    let stawLPAmountEntry = makeString(["%d", toString(stawLPAmount)], SEP)
314+    let lockAtHeightEntry = makeString(["%d", toString(lockAtHeight)], SEP)
315+    let lockIdEntry = makeString(["%b", lockId], SEP)
316+    let totalLockedEntry = makeString(["%d", toString(totalLocked)], SEP)
317+    let userLocalIndexEntry = makeString(["%d", toString(localIndexCount)], SEP)
318+    let lockPeriodInMiliSecEntry = makeString(["%d", toString(lockDurationInMili)], SEP)
319+    let totalWavesClaimedEntry = makeString(["%d", toString(0)], SEP)
320+    let userLeaseStateEntry = makeString(["%s", leaseState], SEP)
321+[_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)]
322+    }
323+
324+
325+func _stawMF (lockPeriod,collateralWaves) = {
326+    let _adjustedMr = _computeMr()
327+    (fraction(_unitDecimals, (_Dt * _adjustedMr), _Ppy(lockPeriod)) * collateralWaves)
328+    }
329+
330+
331+func _emissionRateWaves (lockPeriod,collateral) = {
332+    let extensionFactor = fraction(lockPeriod, 15, 10)
333+    ((collateral / ((lockPeriod * extensionFactor) - lockPeriod)) * _Dt)
334+    }
335+
336+
337+func _incrTotalStawLP (amount) = {
338+    let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
339+[_writeInt(_totalStawLP, (oldStawLP + amount))]
340+    }
341+
342+
343+func _decrTotalStawLP (amount) = {
344+    let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
345+[_writeInt(_totalStawLP, (oldStawLP - amount))]
346+    }
347+
348+
349+func _incrTotalWavesRef (amount) = {
350+    let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
351+[_writeInt(_totalWavesRef, (oldWavesRef + amount))]
352+    }
353+
354+
355+func _decrTotalWavesRef (amount) = {
356+    let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
357+[_writeInt(_totalWavesRef, (oldWavesRef - amount))]
358+    }
359+
360+
361+func _getNewTimeStamp (blockHeight) = {
362+    let time =     match blockInfoByHeight(blockHeight) {
363+        case timeInfo: BlockInfo => 
364+            timeInfo.timestamp
365+        case _ => 
366+            throw("counld get timestamp")
367+    }
368+    time
369+    }
370+
371+
372+@Callable(i)
373+func getEmission (lockPeriod,collateral) = {
374+    let check1 = _onlyManager(i)
375+    if ((check1 == check1))
376+        then $Tuple2(nil, _emissionRateWaves(lockPeriod, collateral))
377+        else throw("Strict value is not equal to itself.")
378+    }
379+
380+
381+
382+@Callable(i)
383+func init (manager,dfx,assetID,leaseNode) = {
384+    let managerAlreadyExists = if (isDefined(_getS(_manager)))
385+        then _onlyManager(i)
386+        else true
387+    if ((managerAlreadyExists == managerAlreadyExists))
388+        then {
389+            let check1 = _validateAddress(manager)
390+            if ((check1 == check1))
391+                then {
392+                    let check2 = _validateAddress(dfx)
393+                    if ((check2 == check2))
394+                        then {
395+                            let check3 = _validateAddress(leaseNode)
396+                            if ((check3 == check3))
397+                                then {
398+                                    let circulationIndex = _setParamVal(_circulationIncrIndex, 0)
399+                                    let percentageReductionInMr = _setParamVal(_percentageReductionFactor, 0)
400+                                    let Mr = _setParamVal(_Mr, _unitDecimals)
401+                                    let totalStawMinted = _setParamVal(_totalStaw, 0)
402+                                    let totalStawLPInCirculation = _setParamVal(_totalStawLP, 0)
403+                                    let globalIndexCount = _setParamVal(_globalIndexCount, 0)
404+                                    let totalWavesRef = _setParamVal(_totalWavesRef, 0)
405+[_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)]
406+                                    }
407+                                else throw("Strict value is not equal to itself.")
408+                            }
409+                        else throw("Strict value is not equal to itself.")
410+                    }
411+                else throw("Strict value is not equal to itself.")
412+            }
413+        else throw("Strict value is not equal to itself.")
414+    }
415+
416+
417+
418+@Callable(i)
419+func modifyGlobalParams (val) = {
420+    let check1 = _onlyManager(i)
421+    if ((check1 == check1))
422+        then {
423+            let check2 = _throwIf((size(val) == 2), "[global_key, value] pairs expected")
424+            if ((check2 == check2))
425+                then {
426+                    let key = val[0]
427+                    let valType = parseInt(val[1])
428+                    match valType {
429+                        case x: Int => 
430+                            let validateKey = _throwIf((_getS(key) == unit), (("key " + key) + " not recognized"))
431+                            if ((validateKey == validateKey))
432+                                then [_writeGlobalParam(key, x)]
433+                                else throw("Strict value is not equal to itself.")
434+                        case x: Unit => 
435+                            let validateKey = _throwIf((_getS(key) == unit), (("key " + key) + " not recognized"))
436+                            if ((validateKey == validateKey))
437+                                then {
438+                                    let validateAddress = _validateAddress(val[1])
439+                                    if ((validateAddress == validateAddress))
440+                                        then [_writeGlobalParam(key, val[1])]
441+                                        else throw("Strict value is not equal to itself.")
442+                                    }
443+                                else throw("Strict value is not equal to itself.")
444+                        case _ => 
445+                            $Tuple2(nil, true)
446+                    }
447+                    }
448+                else throw("Strict value is not equal to itself.")
449+            }
450+        else throw("Strict value is not equal to itself.")
451+    }
452+
453+
454+
455+@Callable(i)
456+func revokeLock () = {
457+    let check1 = _onlyManager(i)
458+    if ((check1 == check1))
459+        then nil
460+        else throw("Strict value is not equal to itself.")
461+    }
462+
463+
464+
465+@Callable(i)
466+func claim (transactionID) = {
467+    let callerAddress = toBase58String(i.caller.bytes)
468+    let collateralKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
469+    let lockperiodKey = makeString([callerAddress, transactionID, _lockDuration], SEP)
470+    let lockIdKey = makeString([callerAddress, transactionID, _lockId], SEP)
471+    let lockperiodInMiliKey = makeString([callerAddress, transactionID, _lockPeriodInMiliSec], SEP)
472+    let totalWavesClaimedKey = makeString([callerAddress, transactionID, _totalWavesClaimed], SEP)
473+    let stawLPAmountKey = makeString([callerAddress, transactionID, _stawLPAmount], SEP)
474+    let wavesAmountKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
475+    let userTotalWavesLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
476+    let userLeaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
477+    let leaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
478+    let globalWavesRef = _getIV(_totalWavesRef)
479+    if ((globalWavesRef == globalWavesRef))
480+        then {
481+            let globalStawPL = _getIV(_totalStawLP)
482+            if ((globalStawPL == globalStawPL))
483+                then {
484+                    let lockId =                     match _getRegistryEntryValue(lockIdKey) {
485+                        case t: ByteVector => 
486+                            t
487+                        case _ => 
488+                            throw("failed to get lease id")
489+                    }
490+                    if ((lockId == lockId))
491+                        then {
492+                            let userTotalWavesLocked =                             match _getRegistryEntryValue(userTotalWavesLockedKey) {
493+                                case t: Int => 
494+                                    t
495+                                case _ => 
496+                                    throw("failed to get total waves locked by this address")
497+                            }
498+                            if ((userTotalWavesLocked == userTotalWavesLocked))
499+                                then {
500+                                    let wavesAmount =                                     match _getRegistryEntryValue(wavesAmountKey) {
501+                                        case t: Int => 
502+                                            t
503+                                        case _ => 
504+                                            throw("failed to get total waves locked")
505+                                    }
506+                                    if ((wavesAmount == wavesAmount))
507+                                        then {
508+                                            let totalWavesClaimed =                                             match _getRegistryEntryValue(totalWavesClaimedKey) {
509+                                                case t: Int => 
510+                                                    t
511+                                                case _ => 
512+                                                    throw("failed to get total waves claimed")
513+                                            }
514+                                            if ((totalWavesClaimed == totalWavesClaimed))
515+                                                then {
516+                                                    let stawLPAmount =                                                     match _getRegistryEntryValue(stawLPAmountKey) {
517+                                                        case t: Int => 
518+                                                            t
519+                                                        case _ => 
520+                                                            throw("failed to get stawPL")
521+                                                    }
522+                                                    if ((stawLPAmount == stawLPAmount))
523+                                                        then {
524+                                                            let lockPeriodInMili =                                                             match _getRegistryEntryValue(lockperiodInMiliKey) {
525+                                                                case t: Int => 
526+                                                                    t
527+                                                                case _ => 
528+                                                                    throw("failed to get lock period timespam")
529+                                                            }
530+                                                            if ((lockPeriodInMili == lockPeriodInMili))
531+                                                                then {
532+                                                                    let currentTimeStamp =                                                                     match _getNewTimeStamp(height) {
533+                                                                        case t: Int => 
534+                                                                            t
535+                                                                        case _ => 
536+                                                                            throw("failed to get current timestamp")
537+                                                                    }
538+                                                                    if ((currentTimeStamp == currentTimeStamp))
539+                                                                        then {
540+                                                                            let collateral =                                                                             match _getRegistryEntryValue(collateralKey) {
541+                                                                                case t: Int => 
542+                                                                                    t
543+                                                                                case _ => 
544+                                                                                    throw("failed to get collateral")
545+                                                                            }
546+                                                                            if ((collateral == collateral))
547+                                                                                then {
548+                                                                                    let lockPeriod =                                                                                     match _getRegistryEntryValue(lockperiodKey) {
549+                                                                                        case t: Int => 
550+                                                                                            t
551+                                                                                        case _ => 
552+                                                                                            throw("failed to get lockPeriod")
553+                                                                                    }
554+                                                                                    if ((lockPeriod == lockPeriod))
555+                                                                                        then {
556+                                                                                            let currentLeaseState =                                                                                             match _getRegistryEntryValue(userLeaseStateKey) {
557+                                                                                                case t: String => 
558+                                                                                                    t
559+                                                                                                case _ => 
560+                                                                                                    throw("failed to get lease state")
561+                                                                                            }
562+                                                                                            if ((currentLeaseState == currentLeaseState))
563+                                                                                                then {
564+                                                                                                    let leaseState =                                                                                                     match _getRegistryEntryValue(leaseStateKey) {
565+                                                                                                        case t: String => 
566+                                                                                                            t
567+                                                                                                        case _ => 
568+                                                                                                            throw("failed to get lease state for user")
569+                                                                                                    }
570+                                                                                                    if ((leaseState == leaseState))
571+                                                                                                        then {
572+                                                                                                            let check1 = _throwIf((lockPeriodInMili > currentTimeStamp), "lock period for this entry has not elapsed")
573+                                                                                                            if ((check1 == check1))
574+                                                                                                                then {
575+                                                                                                                    let leaseAction = if ((currentLeaseState == "leased"))
576+                                                                                                                        then $Tuple2(LeaseCancel(lockId), _writeStr(userLeaseStateKey, "cancelled"))
577+                                                                                                                        else $Tuple2(_writeStr(userLeaseStateKey, "cancelled"), _writeStr(userLeaseStateKey, "cancelled"))
578+                                                                                                                    if ((leaseAction == leaseAction))
579+                                                                                                                        then {
580+                                                                                                                            let check2 = _throwIf(if ((0 == wavesAmount))
581+                                                                                                                                then true
582+                                                                                                                                else (0 == stawLPAmount), "all claims exhausted for this trx")
583+                                                                                                                            if ((check2 == check2))
584+                                                                                                                                then {
585+                                                                                                                                    let emissionValuePerDT = (_emissionRateWaves(lockPeriod, collateral) * _Dt)
586+                                                                                                                                    let claimAction = {
587+                                                                                                                                        let timeStampDiff = (currentTimeStamp - lockPeriodInMili)
588+                                                                                                                                        let daysAfterLockPeriodElasped = (timeStampDiff / _Dt)
589+                                                                                                                                        if ((daysAfterLockPeriodElasped == 0))
590+                                                                                                                                            then throw("less than 24hrs before first claim")
591+                                                                                                                                            else if (((timeStampDiff % _Dt) != 0))
592+                                                                                                                                                then throw("already claimed or less than 24hrs before next claim")
593+                                                                                                                                                else if ((daysAfterLockPeriodElasped > lockPeriod))
594+                                                                                                                                                    then throw("all claims exhausted")
595+                                                                                                                                                    else {
596+                                                                                                                                                        let totalAmountClaimable = (daysAfterLockPeriodElasped * emissionValuePerDT)
597+                                                                                                                                                        let check3_1 = _throwIf((totalAmountClaimable == totalWavesClaimed), "can only claim once in 24hrs")
598+                                                                                                                                                        if ((check3_1 == check3_1))
599+                                                                                                                                                            then {
600+                                                                                                                                                                let check3_2 = _throwIf(((totalAmountClaimable + totalWavesClaimed) > wavesAmount), "all claims exhausted")
601+                                                                                                                                                                if ((check3_2 == check3_2))
602+                                                                                                                                                                    then {
603+                                                                                                                                                                        let claimAmountToSend = if ((daysAfterLockPeriodElasped == 1))
604+                                                                                                                                                                            then totalAmountClaimable
605+                                                                                                                                                                            else (totalAmountClaimable - totalWavesClaimed)
606+                                                                                                                                                                        let newTotalWavesClaim = totalAmountClaimable
607+                                                                                                                                                                        let newWavesAmount = if ((daysAfterLockPeriodElasped == 1))
608+                                                                                                                                                                            then (wavesAmount - totalAmountClaimable)
609+                                                                                                                                                                            else (wavesAmount - (totalAmountClaimable - totalWavesClaimed))
610+                                                                                                                                                                        let newStawLPAmount = if ((daysAfterLockPeriodElasped == 1))
611+                                                                                                                                                                            then (stawLPAmount - totalAmountClaimable)
612+                                                                                                                                                                            else (stawLPAmount - (totalAmountClaimable - totalWavesClaimed))
613+                                                                                                                                                                        let newGlobalWaveRef = (globalWavesRef - newWavesAmount)
614+                                                                                                                                                                        let newGlobalStawPL = (globalStawPL - newStawLPAmount)
615+                                                                                                                                                                        let newUserTotalWavesLocked = (userTotalWavesLocked - claimAmountToSend)
616+                                                                                                                                                                        let wavesAmountEntry = makeString(["%d", toString(newWavesAmount)], SEP)
617+                                                                                                                                                                        let stawLPAmountEntry = makeString(["%d", toString(newStawLPAmount)], SEP)
618+                                                                                                                                                                        let totalWavesClaimedEntry = makeString(["%d", toString(newTotalWavesClaim)], SEP)
619+                                                                                                                                                                        let newUserTotalWavesLockedEntry = makeString(["%d", toString(newUserTotalWavesLocked)], SEP)
620+[leaseAction._1, leaseAction._2, _writeStr(wavesAmountKey, wavesAmountEntry), _writeStr(stawLPAmountKey, stawLPAmountEntry), _writeStr(totalWavesClaimedKey, totalWavesClaimedEntry), _writeStr(userTotalWavesLockedKey, newUserTotalWavesLockedEntry), _writeInt(_totalWavesRef, newGlobalWaveRef), _writeInt(_totalStawLP, newGlobalStawPL), ScriptTransfer(Address(i.caller.bytes), claimAmountToSend, unit)]
621+                                                                                                                                                                        }
622+                                                                                                                                                                    else throw("Strict value is not equal to itself.")
623+                                                                                                                                                                }
624+                                                                                                                                                            else throw("Strict value is not equal to itself.")
625+                                                                                                                                                        }
626+                                                                                                                                        }
627+                                                                                                                                    if ((claimAction == claimAction))
628+                                                                                                                                        then claimAction
629+                                                                                                                                        else throw("Strict value is not equal to itself.")
630+                                                                                                                                    }
631+                                                                                                                                else throw("Strict value is not equal to itself.")
632+                                                                                                                            }
633+                                                                                                                        else throw("Strict value is not equal to itself.")
634+                                                                                                                    }
635+                                                                                                                else throw("Strict value is not equal to itself.")
636+                                                                                                            }
637+                                                                                                        else throw("Strict value is not equal to itself.")
638+                                                                                                    }
639+                                                                                                else throw("Strict value is not equal to itself.")
640+                                                                                            }
641+                                                                                        else throw("Strict value is not equal to itself.")
642+                                                                                    }
643+                                                                                else throw("Strict value is not equal to itself.")
644+                                                                            }
645+                                                                        else throw("Strict value is not equal to itself.")
646+                                                                    }
647+                                                                else throw("Strict value is not equal to itself.")
648+                                                            }
649+                                                        else throw("Strict value is not equal to itself.")
650+                                                    }
651+                                                else throw("Strict value is not equal to itself.")
652+                                            }
653+                                        else throw("Strict value is not equal to itself.")
654+                                    }
655+                                else throw("Strict value is not equal to itself.")
656+                            }
657+                        else throw("Strict value is not equal to itself.")
658+                    }
659+                else throw("Strict value is not equal to itself.")
660+            }
661+        else throw("Strict value is not equal to itself.")
662+    }
663+
664+
665+
666+@Callable(i)
667+func mintStaw (lockPeriod) = {
668+    let callerAddress = toBase58String(i.caller.bytes)
669+    let trxID = toBase58String(i.transactionId)
670+    let check1 = _throwIf((1 != size(i.payments)), "no payments attached")
671+    if ((check1 == check1))
672+        then {
673+            let check2 = if (isDefined(i.payments[0].assetId))
674+                then throw("only waves supported")
675+                else true
676+            if ((check2 == check2))
677+                then {
678+                    let amountInWaves = i.payments[0].amount
679+                    let check3 = if (if ((_minLockAmount > amountInWaves))
680+                        then true
681+                        else (amountInWaves > _maxLockAmount))
682+                        then throw("amount to lock is out of range")
683+                        else true
684+                    if ((check3 == check3))
685+                        then {
686+                            let check4 = if ((_minLockperiod > lockPeriod))
687+                                then throw("minimum of 14 days lock period")
688+                                else true
689+                            if ((check4 == check4))
690+                                then {
691+                                    let totalStawMint = _stawMF(lockPeriod, amountInWaves)
692+                                    let stawPL = amountInWaves
693+                                    let fee = fraction(totalStawMint, 10, 100)
694+                                    let userGetStawAmount = (totalStawMint - fee)
695+                                    let lockPeriodToMilisec = (_getNewTimeStamp(height) + _daysToMiliSec(lockPeriod))
696+                                    if ((lockPeriodToMilisec == lockPeriodToMilisec))
697+                                        then {
698+                                            let new_index = (_throwOrReturnI(_getI(_globalIndexCount), "global index not previously defined") + 1)
699+                                            if ((new_index == new_index))
700+                                                then {
701+                                                    let addressFee = Address(fromBase58String(_throwOrReturnS(_getS(_Dfx), "dfx not previously defined")))
702+                                                    if ((addressFee == addressFee))
703+                                                        then {
704+                                                            let stawAssetId = fromBase58String(_throwOrReturnS(_getS(_stawAssetId), "asset id not previously defined"))
705+                                                            if ((stawAssetId == stawAssetId))
706+                                                                then {
707+                                                                    let lessee = Address(fromBase58String(_throwOrReturnS(_getS(_lesseeAddress), "lease node not previously defined")))
708+                                                                    if ((lessee == lessee))
709+                                                                        then {
710+                                                                            let userLockIndexKey = makeString([callerAddress, _userLocalIndexCount], SEP)
711+                                                                            let userTotalLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
712+                                                                            let userIndexCount =                                                                             match _getRegistryEntryValue(userLockIndexKey) {
713+                                                                                case x: Int => 
714+                                                                                    (x + 1)
715+                                                                                case _ => 
716+                                                                                    0
717+                                                                            }
718+                                                                            if ((userIndexCount == userIndexCount))
719+                                                                                then {
720+                                                                                    let userTotalLocked =                                                                                     match _getRegistryEntryValue(userTotalLockedKey) {
721+                                                                                        case x: Int => 
722+                                                                                            (x + amountInWaves)
723+                                                                                        case _ => 
724+                                                                                            amountInWaves
725+                                                                                    }
726+                                                                                    if ((userTotalLocked == userTotalLocked))
727+                                                                                        then {
728+                                                                                            let leaseOut = Lease(lessee, amountInWaves)
729+                                                                                            if ((leaseOut == leaseOut))
730+                                                                                                then {
731+                                                                                                    let leaseIdStr = toBase58String(calculateLeaseId(leaseOut))
732+                                                                                                    if ((leaseIdStr == leaseIdStr))
733+                                                                                                        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, stawPL, new_index))
734+                                                                                                        else throw("Strict value is not equal to itself.")
735+                                                                                                    }
736+                                                                                                else throw("Strict value is not equal to itself.")
737+                                                                                            }
738+                                                                                        else throw("Strict value is not equal to itself.")
739+                                                                                    }
740+                                                                                else throw("Strict value is not equal to itself.")
741+                                                                            }
742+                                                                        else throw("Strict value is not equal to itself.")
743+                                                                    }
744+                                                                else throw("Strict value is not equal to itself.")
745+                                                            }
746+                                                        else throw("Strict value is not equal to itself.")
747+                                                    }
748+                                                else throw("Strict value is not equal to itself.")
749+                                            }
750+                                        else throw("Strict value is not equal to itself.")
751+                                    }
752+                                else throw("Strict value is not equal to itself.")
753+                            }
754+                        else throw("Strict value is not equal to itself.")
755+                    }
756+                else throw("Strict value is not equal to itself.")
757+            }
758+        else throw("Strict value is not equal to itself.")
759+    }
760+
761+
github/deemru/w8io/169f3d6 
71.57 ms ◑