w8 · tx · EBz···P8o

tx · EBzqmd3VceqSzZUj3QE4kRbTSB61VZvns1KnPh9xDP8o

3NCBhUuq2LX5fqkbvsQ5LPHtCkt3B9T2Q8j:  -0.02200000 Waves

2023.03.13 15:56 [2488280] smart account 3NCBhUuq2LX5fqkbvsQ5LPHtCkt3B9T2Q8j > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EBzqmd3VceqSzZUj3QE4kRbTSB61VZvns1KnPh9xDP8o",
    "fee": 2200000,
    "feeAssetId": null,
    "timestamp": 1678712287332,
    "version": 2,
    "chainId": 84,
    "sender": "3NCBhUuq2LX5fqkbvsQ5LPHtCkt3B9T2Q8j",
    "senderPublicKey": "DC4RRwQbHG5vzo62QQXx7F4TqWREogNeJ8dk97jHNGcp",
    "proofs": [
        "4cjenk1xzkZ25qXZrQ7acDW7BvnMdnXoAQqGQwidv6kB7buASTKFfStrdkxFP7xriaLzZ7dFk85jqG7tfXMpzjWu"
    ],
    "script": "base64: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",
    "height": 2488280,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 
Old New Differences
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 _writeAny (key,_value) = match _value {
153 +     case _value: Int => 
154 +         _writeInt(key, _value)
155 +     case _value: String => 
156 +         _writeStr(key, _value)
157 +     case _value: Boolean => 
158 +         BooleanEntry(key, _value)
159 +     case _ => 
160 +         throw("type not supported")
161 + }
162 + 
163 + 
164 + func _daysToMiliSec (days) = {
165 +     let check = _throwIf((days >= 0), "invalid locking days!")
166 +     if ((check == check))
167 +         then (days * _Dt)
168 +         else throw("Strict value is not equal to itself.")
169 +     }
170 + 
171 + 
172 + func _writeConstString (key,value) = if (!(isDefined(_getS(key))))
173 +     then _writeStr(key, value)
174 +     else throw(("entry already initialized: " + key))
175 + 
176 + 
177 + func _writeConstInteger (key,value) = if (!(isDefined(_getS(key))))
178 +     then _writeInt(key, value)
179 +     else throw((" entry already initialized: " + key))
180 + 
181 + 
182 + func _onlyManager (i) = {
183 +     let manager = _throwOrReturnS(_getS(_manager), "manager not found")
184 +     if ((manager == manager))
185 +         then _throwIf((toBase58String(i.caller.bytes) != manager), "address not authorized")
186 +         else throw("Strict value is not equal to itself.")
187 +     }
188 + 
189 + 
190 + func _abs (val) = if ((0 > val))
191 +     then -(val)
192 +     else val
193 + 
194 + 
195 + func _validateAddress (address) = match address {
196 +     case address: String => 
197 +         let _address = addressFromString(address)
198 +         match _address {
199 +             case _address: Address => 
200 +                 true
201 +             case _ => 
202 +                 throw("invalid address")
203 +         }
204 +     case address: ByteVector => 
205 +         let _address = addressFromPublicKey(address)
206 +         match _address {
207 +             case _address: Address => 
208 +                 true
209 +             case _ => 
210 +                 throw("invalid public key")
211 +         }
212 +     case _ => 
213 +         throw("invalid input type")
214 + }
215 + 
216 + 
217 + func _computeMr () = {
218 +     let currentCircIndex = _throwOrReturnI(_getI(_circulationIncrIndex), "increment index not previously defined")
219 +     if ((currentCircIndex == currentCircIndex))
220 +         then {
221 +             let stawAssetId = _throwOrReturnS(_getS(_stawAssetId), "asset id not previouly defined")
222 +             if ((stawAssetId == stawAssetId))
223 +                 then {
224 +                     let stawCirculatingSupply =                     match assetInfo(fromBase58String(stawAssetId)) {
225 +                         case asset: Asset => 
226 +                             asset.quantity
227 +                         case _ => 
228 +                             throw(("asset not found for " + stawAssetId))
229 +                     }
230 +                     let unitIncrement = (_abs((stawCirculatingSupply - _incrementRef)) / _incrementRef)
231 +                     let newCirculationIncrIndex = if ((unitIncrement > currentCircIndex))
232 +                         then (unitIncrement + currentCircIndex)
233 +                         else currentCircIndex
234 +                     let currentMr = _throwOrReturnI(_Mr, "miniting rate not previously defined")
235 +                     if ((newCirculationIncrIndex == currentCircIndex))
236 +                         then currentMr
237 +                         else {
238 +                             let newreductionFactor = (_throwOrReturnI(_percentageReductionFactor, "reduction factor not previously defined") + 10)
239 +                             let newCurrentMr = (currentMr - fraction(currentMr, newreductionFactor, 100))
240 +                             let store1 = _writeInt(_Mr, newCurrentMr)
241 +                             if ((store1 == store1))
242 +                                 then {
243 +                                     let store2 = _writeInt(_percentageReductionFactor, newreductionFactor)
244 +                                     if ((store2 == store2))
245 +                                         then {
246 +                                             let store3 = _writeInt(_circulationIncrIndex, newCirculationIncrIndex)
247 +                                             if ((store3 == store3))
248 +                                                 then newCurrentMr
249 +                                                 else throw("Strict value is not equal to itself.")
250 +                                             }
251 +                                         else throw("Strict value is not equal to itself.")
252 +                                     }
253 +                                 else throw("Strict value is not equal to itself.")
254 +                             }
255 +                     }
256 +                 else throw("Strict value is not equal to itself.")
257 +             }
258 +         else throw("Strict value is not equal to itself.")
259 +     }
260 + 
261 + 
262 + func _getRegistryEntryValue (key) = {
263 +     let _rawValue = _throwOrReturnS(_getS(key), "entry not found")
264 +     if ((_rawValue == _rawValue))
265 +         then {
266 +             let x = split(_rawValue, SEP)
267 +             let formatSpecifier = takeRight(x[0], 1)
268 +             let _valueString = x[(size(x) - 1)]
269 +             let _value = if ((formatSpecifier == "s"))
270 +                 then _valueString
271 +                 else if ((formatSpecifier == "d"))
272 +                     then parseIntValue(_valueString)
273 +                     else if ((formatSpecifier == "b"))
274 +                         then fromBase58String(_valueString)
275 +                         else throw(("could not parse registry value for " + key))
276 +             _value
277 +             }
278 +         else throw("Strict value is not equal to itself.")
279 +     }
280 + 
281 + 
282 + func _updateGlobalEntry (wavesAmount,stawAmount,stawPL,indexCount) = {
283 +     let _newGlobalTotalWavesAmtRef = (_throwOrReturnI(_getI(_totalWavesRef), "global waves sum not previously defined") + wavesAmount)
284 +     let _newGlobalTotalStawMinted = (_throwOrReturnI(_getI(_totalStaw), "gobal staw minted not previously defined") + stawAmount)
285 +     let _newGlobalTotalStawPL = (_throwOrReturnI(_getI(_totalStawLP), "global stawPL not previously defined") + stawPL)
286 +     let _newGlobaIndexCount = (_throwOrReturnI(_getI(_globalIndexCount), "global index count not previously defined") + indexCount)
287 + [_writeInt(_totalWavesRef, _newGlobalTotalWavesAmtRef), _writeInt(_totalStaw, _newGlobalTotalStawMinted), _writeInt(_totalStawLP, _newGlobalTotalStawPL), _writeInt(_globalIndexCount, _newGlobaIndexCount)]
288 +     }
289 + 
290 + 
291 + func _registerUserEntry (transactionID,userAddress,lockDuration,lockDurationInMili,lockIndex,wavesAmount,stawAmount,stawLPAmount,lockAtHeight,lockId,totalLocked,localIndexCount,leaseState) = {
292 +     let _txIdKey = makeString([userAddress, transactionID, _txId], SEP)
293 +     let _lockDurationKey = makeString([userAddress, transactionID, _lockDuration], SEP)
294 +     let _lockIndexKey = makeString([userAddress, transactionID, _lockIndex], SEP)
295 +     let _wavesAmountKey = makeString([userAddress, transactionID, _wavesAmount], SEP)
296 +     let _stawAmountKey = makeString([userAddress, transactionID, _stawAmount], SEP)
297 +     let _stawLPAmountKey = makeString([userAddress, transactionID, _stawLPAmount], SEP)
298 +     let _lockAtHeightKey = makeString([userAddress, transactionID, _lockAtHeight], SEP)
299 +     let _lockIdKey = makeString([userAddress, transactionID, _lockId], SEP)
300 +     let _totalLockedKey = makeString([userAddress, _userTotalLocked], SEP)
301 +     let _localLockIndexKey = makeString([userAddress, _userLocalIndexCount], SEP)
302 +     let _lockPeriodInMiliSecKey = makeString([userAddress, transactionID, _lockPeriodInMiliSec], SEP)
303 +     let _totalWavesClaimedKey = makeString([userAddress, transactionID, _totalWavesClaimed], SEP)
304 +     let _userLeaseStateKey = makeString([userAddress, transactionID, _userLeaseState], SEP)
305 +     let trxIdEntry = makeString(["%s", transactionID], SEP)
306 +     let lockDurationEntry = makeString(["%d", toString(lockDuration)], SEP)
307 +     let lockIndexEntry = makeString(["%d", toString(lockIndex)], SEP)
308 +     let wavesAmountEntry = makeString(["%d", toString(wavesAmount)], SEP)
309 +     let stawAmountEntry = makeString(["%d", toString(stawAmount)], SEP)
310 +     let stawLPAmountEntry = makeString(["%d", toString(stawLPAmount)], SEP)
311 +     let lockAtHeightEntry = makeString(["%d", toString(lockAtHeight)], SEP)
312 +     let lockIdEntry = makeString(["%b", lockId], SEP)
313 +     let totalLockedEntry = makeString(["%d", toString(totalLocked)], SEP)
314 +     let userLocalIndexEntry = makeString(["%d", toString(localIndexCount)], SEP)
315 +     let lockPeriodInMiliSecEntry = makeString(["%d", toString(lockDurationInMili)], SEP)
316 +     let totalWavesClaimedEntry = makeString(["%d", toString(0)], SEP)
317 +     let userLeaseStateEntry = makeString(["%s", leaseState], SEP)
318 + [_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)]
319 +     }
320 + 
321 + 
322 + func _stawMF (lockPeriod,collateralWaves) = {
323 +     let _adjustedMr = _computeMr()
324 +     (fraction(_unitDecimals, (_Dt * _adjustedMr), _Ppy(lockPeriod)) * collateralWaves)
325 +     }
326 + 
327 + 
328 + func _emissionRateWaves (lockPeriod,collateral) = {
329 +     let extensionFactor = fraction(lockPeriod, 15, 10)
330 +     ((collateral / ((lockPeriod * extensionFactor) - lockPeriod)) * _Dt)
331 +     }
332 + 
333 + 
334 + func _incrTotalStawLP (amount) = {
335 +     let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
336 + [_writeInt(_totalStawLP, (oldStawLP + amount))]
337 +     }
338 + 
339 + 
340 + func _decrTotalStawLP (amount) = {
341 +     let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
342 + [_writeInt(_totalStawLP, (oldStawLP - amount))]
343 +     }
344 + 
345 + 
346 + func _incrTotalWavesRef (amount) = {
347 +     let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
348 + [_writeInt(_totalWavesRef, (oldWavesRef + amount))]
349 +     }
350 + 
351 + 
352 + func _decrTotalWavesRef (amount) = {
353 +     let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
354 + [_writeInt(_totalWavesRef, (oldWavesRef - amount))]
355 +     }
356 + 
357 + 
358 + func _getNewTimeStamp (blockHeight) = {
359 +     let time =     match blockInfoByHeight(blockHeight) {
360 +         case timeInfo: BlockInfo => 
361 +             timeInfo.timestamp
362 +         case _ => 
363 +             throw("counld get timestamp")
364 +     }
365 +     time
366 +     }
367 + 
368 + 
369 + func _leaseOut () = true
370 + 
371 + 
372 + func _cancelLeaseOut () = true
373 + 
374 + 
375 + func _mintStaw () = true
376 + 
377 + 
378 + func _updateStats () = true
379 + 
380 + 
381 + @Callable(i)
382 + func getEmission (lockPeriod,collateral) = {
383 +     let check1 = _onlyManager(i)
384 +     if ((check1 == check1))
385 +         then $Tuple2(nil, _emissionRateWaves(lockPeriod, collateral))
386 +         else throw("Strict value is not equal to itself.")
387 +     }
388 + 
389 + 
390 + 
391 + @Callable(i)
392 + func init (manager,dfx,assetID,leaseNode) = {
393 +     let check1 = _validateAddress(manager)
394 +     if ((check1 == check1))
395 +         then {
396 +             let check2 = _validateAddress(dfx)
397 +             if ((check2 == check2))
398 +                 then {
399 +                     let check3 = _validateAddress(leaseNode)
400 +                     if ((check3 == check3))
401 +                         then {
402 +                             let circulationIndex = _setParamVal(_circulationIncrIndex, 0)
403 +                             let percentageReductionInMr = _setParamVal(_percentageReductionFactor, 0)
404 +                             let Mr = _setParamVal(_Mr, _unitDecimals)
405 +                             let totalStawMinted = _setParamVal(_totalStaw, 0)
406 +                             let totalStawLPInCirculation = _setParamVal(_totalStawLP, 0)
407 +                             let globalIndexCount = _setParamVal(_globalIndexCount, 0)
408 +                             let totalWavesRef = _setParamVal(_totalWavesRef, 0)
409 + [_writeConstString(_manager, manager), _writeConstString(_Dfx, dfx), _writeConstString(_stawAssetId, assetID), _writeStr(_lesseeAddress, leaseNode), _writeAny(_circulationIncrIndex, circulationIndex), _writeAny(_Mr, Mr), _writeAny(_percentageReductionFactor, percentageReductionInMr), _writeAny(_totalWavesRef, totalWavesRef)]
410 +                             }
411 +                         else throw("Strict value is not equal to itself.")
412 +                     }
413 +                 else throw("Strict value is not equal to itself.")
414 +             }
415 +         else throw("Strict value is not equal to itself.")
416 +     }
417 + 
418 + 
419 + 
420 + @Callable(i)
421 + func modifyInternalParams (key) = {
422 +     let check1 = _onlyManager(i)
423 +     if ((check1 == check1))
424 +         then nil
425 +         else throw("Strict value is not equal to itself.")
426 +     }
427 + 
428 + 
429 + 
430 + @Callable(i)
431 + func revokeMint () = {
432 +     let check1 = _onlyManager(i)
433 +     if ((check1 == check1))
434 +         then nil
435 +         else throw("Strict value is not equal to itself.")
436 +     }
437 + 
438 + 
439 + 
440 + @Callable(i)
441 + func claim (transactionID) = {
442 +     let callerAddress = toBase58String(i.caller.bytes)
443 +     let collateralKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
444 +     let lockperiodKey = makeString([callerAddress, transactionID, _lockDuration], SEP)
445 +     let lockIdKey = makeString([callerAddress, transactionID, _lockId], SEP)
446 +     let lockperiodInMiliKey = makeString([callerAddress, transactionID, _lockPeriodInMiliSec], SEP)
447 +     let totalWavesClaimedKey = makeString([callerAddress, transactionID, _totalWavesClaimed], SEP)
448 +     let stawLPAmountKey = makeString([callerAddress, transactionID, _stawLPAmount], SEP)
449 +     let wavesAmountKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
450 +     let userTotalWavesLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
451 +     let userLeaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
452 +     let leaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
453 +     let globalWavesRef = _getIV(_totalWavesRef)
454 +     if ((globalWavesRef == globalWavesRef))
455 +         then {
456 +             let globalStawPL = _getIV(_totalStawLP)
457 +             if ((globalStawPL == globalStawPL))
458 +                 then {
459 +                     let lockId =                     match _getRegistryEntryValue(lockIdKey) {
460 +                         case t: ByteVector => 
461 +                             t
462 +                         case _ => 
463 +                             throw("failed to get lease id")
464 +                     }
465 +                     if ((lockId == lockId))
466 +                         then {
467 +                             let userTotalWavesLocked =                             match _getRegistryEntryValue(userTotalWavesLockedKey) {
468 +                                 case t: Int => 
469 +                                     t
470 +                                 case _ => 
471 +                                     throw("failed to get total waves locked by this address")
472 +                             }
473 +                             if ((userTotalWavesLocked == userTotalWavesLocked))
474 +                                 then {
475 +                                     let wavesAmount =                                     match _getRegistryEntryValue(wavesAmountKey) {
476 +                                         case t: Int => 
477 +                                             t
478 +                                         case _ => 
479 +                                             throw("failed to get total waves locked")
480 +                                     }
481 +                                     if ((wavesAmount == wavesAmount))
482 +                                         then {
483 +                                             let totalWavesClaimed =                                             match _getRegistryEntryValue(totalWavesClaimedKey) {
484 +                                                 case t: Int => 
485 +                                                     t
486 +                                                 case _ => 
487 +                                                     throw("failed to get total waves claimed")
488 +                                             }
489 +                                             if ((totalWavesClaimed == totalWavesClaimed))
490 +                                                 then {
491 +                                                     let stawLPAmount =                                                     match _getRegistryEntryValue(stawLPAmountKey) {
492 +                                                         case t: Int => 
493 +                                                             t
494 +                                                         case _ => 
495 +                                                             throw("failed to get stawPL")
496 +                                                     }
497 +                                                     if ((stawLPAmount == stawLPAmount))
498 +                                                         then {
499 +                                                             let lockPeriodInMili =                                                             match _getRegistryEntryValue(lockperiodInMiliKey) {
500 +                                                                 case t: Int => 
501 +                                                                     t
502 +                                                                 case _ => 
503 +                                                                     throw("failed to get lock period timespam")
504 +                                                             }
505 +                                                             if ((lockPeriodInMili == lockPeriodInMili))
506 +                                                                 then {
507 +                                                                     let currentTimeStamp =                                                                     match _getNewTimeStamp(height) {
508 +                                                                         case t: Int => 
509 +                                                                             t
510 +                                                                         case _ => 
511 +                                                                             throw("failed to get current timestamp")
512 +                                                                     }
513 +                                                                     if ((currentTimeStamp == currentTimeStamp))
514 +                                                                         then {
515 +                                                                             let collateral =                                                                             match _getRegistryEntryValue(collateralKey) {
516 +                                                                                 case t: Int => 
517 +                                                                                     t
518 +                                                                                 case _ => 
519 +                                                                                     throw("failed to get collateral")
520 +                                                                             }
521 +                                                                             if ((collateral == collateral))
522 +                                                                                 then {
523 +                                                                                     let lockPeriod =                                                                                     match _getRegistryEntryValue(lockperiodKey) {
524 +                                                                                         case t: Int => 
525 +                                                                                             t
526 +                                                                                         case _ => 
527 +                                                                                             throw("failed to get lockPeriod")
528 +                                                                                     }
529 +                                                                                     if ((lockPeriod == lockPeriod))
530 +                                                                                         then {
531 +                                                                                             let currentLeaseState =                                                                                             match _getRegistryEntryValue(userLeaseStateKey) {
532 +                                                                                                 case t: String => 
533 +                                                                                                     t
534 +                                                                                                 case _ => 
535 +                                                                                                     throw("failed to get lease state")
536 +                                                                                             }
537 +                                                                                             if ((currentLeaseState == currentLeaseState))
538 +                                                                                                 then {
539 +                                                                                                     let leaseState =                                                                                                     match _getRegistryEntryValue(leaseStateKey) {
540 +                                                                                                         case t: String => 
541 +                                                                                                             t
542 +                                                                                                         case _ => 
543 +                                                                                                             throw("failed to get lease state for user")
544 +                                                                                                     }
545 +                                                                                                     if ((leaseState == leaseState))
546 +                                                                                                         then {
547 +                                                                                                             let check1 = _throwIf((lockPeriodInMili > currentTimeStamp), "lock period for this entry has not elapsed")
548 +                                                                                                             if ((check1 == check1))
549 +                                                                                                                 then {
550 +                                                                                                                     let leaseAction = if ((currentLeaseState == "leased"))
551 +                                                                                                                         then $Tuple2(LeaseCancel(lockId), _writeStr(userLeaseStateKey, "cancelled"))
552 +                                                                                                                         else $Tuple2(_writeStr(userLeaseStateKey, "cancelled"), _writeStr(userLeaseStateKey, "cancelled"))
553 +                                                                                                                     if ((leaseAction == leaseAction))
554 +                                                                                                                         then {
555 +                                                                                                                             let check2 = _throwIf(if ((0 == wavesAmount))
556 +                                                                                                                                 then true
557 +                                                                                                                                 else (0 == stawLPAmount), "all claims exhausted for this trx")
558 +                                                                                                                             if ((check2 == check2))
559 +                                                                                                                                 then {
560 +                                                                                                                                     let emissionValuePerDT = (_emissionRateWaves(lockPeriod, collateral) * _Dt)
561 +                                                                                                                                     let claimAction = {
562 +                                                                                                                                         let timeStampDiff = (currentTimeStamp - lockPeriodInMili)
563 +                                                                                                                                         let daysAfterLockPeriodElasped = (timeStampDiff / _Dt)
564 +                                                                                                                                         if ((daysAfterLockPeriodElasped == 0))
565 +                                                                                                                                             then throw("less than 24hrs before first claim")
566 +                                                                                                                                             else if (((timeStampDiff % _Dt) != 0))
567 +                                                                                                                                                 then throw("already claimed or less than 24hrs before next claim")
568 +                                                                                                                                                 else if ((daysAfterLockPeriodElasped > lockPeriod))
569 +                                                                                                                                                     then throw("all claims exhausted")
570 +                                                                                                                                                     else {
571 +                                                                                                                                                         let totalAmountClaimable = (daysAfterLockPeriodElasped * emissionValuePerDT)
572 +                                                                                                                                                         let check3_1 = _throwIf((totalAmountClaimable == totalWavesClaimed), "can only claim once in 24hrs")
573 +                                                                                                                                                         if ((check3_1 == check3_1))
574 +                                                                                                                                                             then {
575 +                                                                                                                                                                 let check3_2 = _throwIf(((totalAmountClaimable + totalWavesClaimed) > wavesAmount), "all claims exhausted")
576 +                                                                                                                                                                 if ((check3_2 == check3_2))
577 +                                                                                                                                                                     then {
578 +                                                                                                                                                                         let claimAmountToSend = if ((daysAfterLockPeriodElasped == 1))
579 +                                                                                                                                                                             then totalAmountClaimable
580 +                                                                                                                                                                             else (totalAmountClaimable - totalWavesClaimed)
581 +                                                                                                                                                                         let newTotalWavesClaim = totalAmountClaimable
582 +                                                                                                                                                                         let newWavesAmount = if ((daysAfterLockPeriodElasped == 1))
583 +                                                                                                                                                                             then (wavesAmount - totalAmountClaimable)
584 +                                                                                                                                                                             else (wavesAmount - (totalAmountClaimable - totalWavesClaimed))
585 +                                                                                                                                                                         let newStawLPAmount = if ((daysAfterLockPeriodElasped == 1))
586 +                                                                                                                                                                             then (stawLPAmount - totalAmountClaimable)
587 +                                                                                                                                                                             else (stawLPAmount - (totalAmountClaimable - totalWavesClaimed))
588 +                                                                                                                                                                         let newGlobalWaveRef = (globalWavesRef - newWavesAmount)
589 +                                                                                                                                                                         let newGlobalStawPL = (globalStawPL - newStawLPAmount)
590 +                                                                                                                                                                         let newUserTotalWavesLocked = (userTotalWavesLocked - claimAmountToSend)
591 +                                                                                                                                                                         let wavesAmountEntry = makeString(["%d", toString(newWavesAmount)], SEP)
592 +                                                                                                                                                                         let stawLPAmountEntry = makeString(["%d", toString(newStawLPAmount)], SEP)
593 +                                                                                                                                                                         let totalWavesClaimedEntry = makeString(["%d", toString(newTotalWavesClaim)], SEP)
594 +                                                                                                                                                                         let newUserTotalWavesLockedEntry = makeString(["%d", toString(newUserTotalWavesLocked)], SEP)
595 + [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)]
596 +                                                                                                                                                                         }
597 +                                                                                                                                                                     else throw("Strict value is not equal to itself.")
598 +                                                                                                                                                                 }
599 +                                                                                                                                                             else throw("Strict value is not equal to itself.")
600 +                                                                                                                                                         }
601 +                                                                                                                                         }
602 +                                                                                                                                     if ((claimAction == claimAction))
603 +                                                                                                                                         then claimAction
604 +                                                                                                                                         else throw("Strict value is not equal to itself.")
605 +                                                                                                                                     }
606 +                                                                                                                                 else throw("Strict value is not equal to itself.")
607 +                                                                                                                             }
608 +                                                                                                                         else throw("Strict value is not equal to itself.")
609 +                                                                                                                     }
610 +                                                                                                                 else throw("Strict value is not equal to itself.")
611 +                                                                                                             }
612 +                                                                                                         else throw("Strict value is not equal to itself.")
613 +                                                                                                     }
614 +                                                                                                 else throw("Strict value is not equal to itself.")
615 +                                                                                             }
616 +                                                                                         else throw("Strict value is not equal to itself.")
617 +                                                                                     }
618 +                                                                                 else throw("Strict value is not equal to itself.")
619 +                                                                             }
620 +                                                                         else throw("Strict value is not equal to itself.")
621 +                                                                     }
622 +                                                                 else throw("Strict value is not equal to itself.")
623 +                                                             }
624 +                                                         else throw("Strict value is not equal to itself.")
625 +                                                     }
626 +                                                 else throw("Strict value is not equal to itself.")
627 +                                             }
628 +                                         else throw("Strict value is not equal to itself.")
629 +                                     }
630 +                                 else throw("Strict value is not equal to itself.")
631 +                             }
632 +                         else throw("Strict value is not equal to itself.")
633 +                     }
634 +                 else throw("Strict value is not equal to itself.")
635 +             }
636 +         else throw("Strict value is not equal to itself.")
637 +     }
638 + 
639 + 
640 + 
641 + @Callable(i)
642 + func mintStaw (lockPeriod) = {
643 +     let callerAddress = toBase58String(i.caller.bytes)
644 +     let trxID = toBase58String(i.transactionId)
645 +     let check1 = _throwIf((1 != size(i.payments)), "no payments attached")
646 +     if ((check1 == check1))
647 +         then {
648 +             let check2 = if (isDefined(i.payments[0].assetId))
649 +                 then throw("only waves supported")
650 +                 else true
651 +             if ((check2 == check2))
652 +                 then {
653 +                     let amountInWaves = i.payments[0].amount
654 +                     let check3 = if (if ((_minLockAmount > amountInWaves))
655 +                         then true
656 +                         else (amountInWaves > _maxLockAmount))
657 +                         then throw("amount to lock is out of range")
658 +                         else true
659 +                     if ((check3 == check3))
660 +                         then {
661 +                             let check4 = if ((_minLockperiod > lockPeriod))
662 +                                 then throw("minimum of 14 days lock period")
663 +                                 else true
664 +                             if ((check4 == check4))
665 +                                 then {
666 +                                     let totalStawMint = _stawMF(lockPeriod, amountInWaves)
667 +                                     let stawPL = amountInWaves
668 +                                     let fee = fraction(totalStawMint, 10, 100)
669 +                                     let userGetStawAmount = (totalStawMint - fee)
670 +                                     let lockPeriodToMilisec = (_getNewTimeStamp(height) + _daysToMiliSec(lockPeriod))
671 +                                     if ((lockPeriodToMilisec == lockPeriodToMilisec))
672 +                                         then {
673 +                                             let new_index = (_throwOrReturnI(_getI(_globalIndexCount), "global index not previously defined") + 1)
674 +                                             if ((new_index == new_index))
675 +                                                 then {
676 +                                                     let addressFee = Address(fromBase58String(_throwOrReturnS(_getS(_Dfx), "dfx not previously defined")))
677 +                                                     if ((addressFee == addressFee))
678 +                                                         then {
679 +                                                             let stawAssetId = fromBase58String(_throwOrReturnS(_getS(_stawAssetId), "asset id not previously defined"))
680 +                                                             if ((stawAssetId == stawAssetId))
681 +                                                                 then {
682 +                                                                     let lessee = Address(fromBase58String(_throwOrReturnS(_getS(_lesseeAddress), "lease node not previously defined")))
683 +                                                                     if ((lessee == lessee))
684 +                                                                         then {
685 +                                                                             let userLockIndexKey = makeString([callerAddress, _userLocalIndexCount], SEP)
686 +                                                                             let userTotalLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
687 +                                                                             let userIndexCount =                                                                             match _getRegistryEntryValue(userLockIndexKey) {
688 +                                                                                 case x: Int => 
689 +                                                                                     (x + 1)
690 +                                                                                 case _ => 
691 +                                                                                     0
692 +                                                                             }
693 +                                                                             if ((userIndexCount == userIndexCount))
694 +                                                                                 then {
695 +                                                                                     let userTotalLocked =                                                                                     match _getRegistryEntryValue(userTotalLockedKey) {
696 +                                                                                         case x: Int => 
697 +                                                                                             (x + amountInWaves)
698 +                                                                                         case _ => 
699 +                                                                                             amountInWaves
700 +                                                                                     }
701 +                                                                                     if ((userTotalLocked == userTotalLocked))
702 +                                                                                         then {
703 +                                                                                             let leaseOut = Lease(lessee, amountInWaves)
704 +                                                                                             if ((leaseOut == leaseOut))
705 +                                                                                                 then {
706 +                                                                                                     let leaseIdStr = toBase58String(calculateLeaseId(leaseOut))
707 +                                                                                                     if ((leaseIdStr == leaseIdStr))
708 +                                                                                                         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))
709 +                                                                                                         else throw("Strict value is not equal to itself.")
710 +                                                                                                     }
711 +                                                                                                 else throw("Strict value is not equal to itself.")
712 +                                                                                             }
713 +                                                                                         else throw("Strict value is not equal to itself.")
714 +                                                                                     }
715 +                                                                                 else throw("Strict value is not equal to itself.")
716 +                                                                             }
717 +                                                                         else throw("Strict value is not equal to itself.")
718 +                                                                     }
719 +                                                                 else throw("Strict value is not equal to itself.")
720 +                                                             }
721 +                                                         else throw("Strict value is not equal to itself.")
722 +                                                     }
723 +                                                 else throw("Strict value is not equal to itself.")
724 +                                             }
725 +                                         else throw("Strict value is not equal to itself.")
726 +                                     }
727 +                                 else throw("Strict value is not equal to itself.")
728 +                             }
729 +                         else throw("Strict value is not equal to itself.")
730 +                     }
731 +                 else throw("Strict value is not equal to itself.")
732 +             }
733 +         else throw("Strict value is not equal to itself.")
734 +     }
735 + 
736 + 
737 + @Verifier(tt)
738 + func verify () = match tt {
739 +     case ttx: TransferTransaction => 
740 +         if ((100 > ttx.amount))
741 +             then sigVerify(ttx.bodyBytes, ttx.proofs[0], ttx.senderPublicKey)
742 +             else false
743 +     case _ => 
744 +         false
745 + }
746 +

Old	New		Differences
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 _writeAny (key,_value) = match _value {
	153	+	case _value: Int =>
	154	+	_writeInt(key, _value)
	155	+	case _value: String =>
	156	+	_writeStr(key, _value)
	157	+	case _value: Boolean =>
	158	+	BooleanEntry(key, _value)
	159	+	case _ =>
	160	+	throw("type not supported")
	161	+	}
	162	+
	163	+
	164	+	func _daysToMiliSec (days) = {
	165	+	let check = _throwIf((days >= 0), "invalid locking days!")
	166	+	if ((check == check))
	167	+	then (days * _Dt)
	168	+	else throw("Strict value is not equal to itself.")
	169	+	}
	170	+
	171	+
	172	+	func _writeConstString (key,value) = if (!(isDefined(_getS(key))))
	173	+	then _writeStr(key, value)
	174	+	else throw(("entry already initialized: " + key))
	175	+
	176	+
	177	+	func _writeConstInteger (key,value) = if (!(isDefined(_getS(key))))
	178	+	then _writeInt(key, value)
	179	+	else throw((" entry already initialized: " + key))
	180	+
	181	+
	182	+	func _onlyManager (i) = {
	183	+	let manager = _throwOrReturnS(_getS(_manager), "manager not found")
	184	+	if ((manager == manager))
	185	+	then _throwIf((toBase58String(i.caller.bytes) != manager), "address not authorized")
	186	+	else throw("Strict value is not equal to itself.")
	187	+	}
	188	+
	189	+
	190	+	func _abs (val) = if ((0 > val))
	191	+	then -(val)
	192	+	else val
	193	+
	194	+
	195	+	func _validateAddress (address) = match address {
	196	+	case address: String =>
	197	+	let _address = addressFromString(address)
	198	+	match _address {
	199	+	case _address: Address =>
	200	+	true
	201	+	case _ =>
	202	+	throw("invalid address")
	203	+	}
	204	+	case address: ByteVector =>
	205	+	let _address = addressFromPublicKey(address)
	206	+	match _address {
	207	+	case _address: Address =>
	208	+	true
	209	+	case _ =>
	210	+	throw("invalid public key")
	211	+	}
	212	+	case _ =>
	213	+	throw("invalid input type")
	214	+	}
	215	+
	216	+
	217	+	func _computeMr () = {
	218	+	let currentCircIndex = _throwOrReturnI(_getI(_circulationIncrIndex), "increment index not previously defined")
	219	+	if ((currentCircIndex == currentCircIndex))
	220	+	then {
	221	+	let stawAssetId = _throwOrReturnS(_getS(_stawAssetId), "asset id not previouly defined")
	222	+	if ((stawAssetId == stawAssetId))
	223	+	then {
	224	+	let stawCirculatingSupply = match assetInfo(fromBase58String(stawAssetId)) {
	225	+	case asset: Asset =>
	226	+	asset.quantity
	227	+	case _ =>
	228	+	throw(("asset not found for " + stawAssetId))
	229	+	}
	230	+	let unitIncrement = (_abs((stawCirculatingSupply - _incrementRef)) / _incrementRef)
	231	+	let newCirculationIncrIndex = if ((unitIncrement > currentCircIndex))
	232	+	then (unitIncrement + currentCircIndex)
	233	+	else currentCircIndex
	234	+	let currentMr = _throwOrReturnI(_Mr, "miniting rate not previously defined")
	235	+	if ((newCirculationIncrIndex == currentCircIndex))
	236	+	then currentMr
	237	+	else {
	238	+	let newreductionFactor = (_throwOrReturnI(_percentageReductionFactor, "reduction factor not previously defined") + 10)
	239	+	let newCurrentMr = (currentMr - fraction(currentMr, newreductionFactor, 100))
	240	+	let store1 = _writeInt(_Mr, newCurrentMr)
	241	+	if ((store1 == store1))
	242	+	then {
	243	+	let store2 = _writeInt(_percentageReductionFactor, newreductionFactor)
	244	+	if ((store2 == store2))
	245	+	then {
	246	+	let store3 = _writeInt(_circulationIncrIndex, newCirculationIncrIndex)
	247	+	if ((store3 == store3))
	248	+	then newCurrentMr
	249	+	else throw("Strict value is not equal to itself.")
	250	+	}
	251	+	else throw("Strict value is not equal to itself.")
	252	+	}
	253	+	else throw("Strict value is not equal to itself.")
	254	+	}
	255	+	}
	256	+	else throw("Strict value is not equal to itself.")
	257	+	}
	258	+	else throw("Strict value is not equal to itself.")
	259	+	}
	260	+
	261	+
	262	+	func _getRegistryEntryValue (key) = {
	263	+	let _rawValue = _throwOrReturnS(_getS(key), "entry not found")
	264	+	if ((_rawValue == _rawValue))
	265	+	then {
	266	+	let x = split(_rawValue, SEP)
	267	+	let formatSpecifier = takeRight(x[0], 1)
	268	+	let _valueString = x[(size(x) - 1)]
	269	+	let _value = if ((formatSpecifier == "s"))
	270	+	then _valueString
	271	+	else if ((formatSpecifier == "d"))
	272	+	then parseIntValue(_valueString)
	273	+	else if ((formatSpecifier == "b"))
	274	+	then fromBase58String(_valueString)
	275	+	else throw(("could not parse registry value for " + key))
	276	+	_value
	277	+	}
	278	+	else throw("Strict value is not equal to itself.")
	279	+	}
	280	+
	281	+
	282	+	func _updateGlobalEntry (wavesAmount,stawAmount,stawPL,indexCount) = {
	283	+	let _newGlobalTotalWavesAmtRef = (_throwOrReturnI(_getI(_totalWavesRef), "global waves sum not previously defined") + wavesAmount)
	284	+	let _newGlobalTotalStawMinted = (_throwOrReturnI(_getI(_totalStaw), "gobal staw minted not previously defined") + stawAmount)
	285	+	let _newGlobalTotalStawPL = (_throwOrReturnI(_getI(_totalStawLP), "global stawPL not previously defined") + stawPL)
	286	+	let _newGlobaIndexCount = (_throwOrReturnI(_getI(_globalIndexCount), "global index count not previously defined") + indexCount)
	287	+	[_writeInt(_totalWavesRef, _newGlobalTotalWavesAmtRef), _writeInt(_totalStaw, _newGlobalTotalStawMinted), _writeInt(_totalStawLP, _newGlobalTotalStawPL), _writeInt(_globalIndexCount, _newGlobaIndexCount)]
	288	+	}
	289	+
	290	+
	291	+	func _registerUserEntry (transactionID,userAddress,lockDuration,lockDurationInMili,lockIndex,wavesAmount,stawAmount,stawLPAmount,lockAtHeight,lockId,totalLocked,localIndexCount,leaseState) = {
	292	+	let _txIdKey = makeString([userAddress, transactionID, _txId], SEP)
	293	+	let _lockDurationKey = makeString([userAddress, transactionID, _lockDuration], SEP)
	294	+	let _lockIndexKey = makeString([userAddress, transactionID, _lockIndex], SEP)
	295	+	let _wavesAmountKey = makeString([userAddress, transactionID, _wavesAmount], SEP)
	296	+	let _stawAmountKey = makeString([userAddress, transactionID, _stawAmount], SEP)
	297	+	let _stawLPAmountKey = makeString([userAddress, transactionID, _stawLPAmount], SEP)
	298	+	let _lockAtHeightKey = makeString([userAddress, transactionID, _lockAtHeight], SEP)
	299	+	let _lockIdKey = makeString([userAddress, transactionID, _lockId], SEP)
	300	+	let _totalLockedKey = makeString([userAddress, _userTotalLocked], SEP)
	301	+	let _localLockIndexKey = makeString([userAddress, _userLocalIndexCount], SEP)
	302	+	let _lockPeriodInMiliSecKey = makeString([userAddress, transactionID, _lockPeriodInMiliSec], SEP)
	303	+	let _totalWavesClaimedKey = makeString([userAddress, transactionID, _totalWavesClaimed], SEP)
	304	+	let _userLeaseStateKey = makeString([userAddress, transactionID, _userLeaseState], SEP)
	305	+	let trxIdEntry = makeString(["%s", transactionID], SEP)
	306	+	let lockDurationEntry = makeString(["%d", toString(lockDuration)], SEP)
	307	+	let lockIndexEntry = makeString(["%d", toString(lockIndex)], SEP)
	308	+	let wavesAmountEntry = makeString(["%d", toString(wavesAmount)], SEP)
	309	+	let stawAmountEntry = makeString(["%d", toString(stawAmount)], SEP)
	310	+	let stawLPAmountEntry = makeString(["%d", toString(stawLPAmount)], SEP)
	311	+	let lockAtHeightEntry = makeString(["%d", toString(lockAtHeight)], SEP)
	312	+	let lockIdEntry = makeString(["%b", lockId], SEP)
	313	+	let totalLockedEntry = makeString(["%d", toString(totalLocked)], SEP)
	314	+	let userLocalIndexEntry = makeString(["%d", toString(localIndexCount)], SEP)
	315	+	let lockPeriodInMiliSecEntry = makeString(["%d", toString(lockDurationInMili)], SEP)
	316	+	let totalWavesClaimedEntry = makeString(["%d", toString(0)], SEP)
	317	+	let userLeaseStateEntry = makeString(["%s", leaseState], SEP)
	318	+	[_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)]
	319	+	}
	320	+
	321	+
	322	+	func _stawMF (lockPeriod,collateralWaves) = {
	323	+	let _adjustedMr = _computeMr()
	324	+	(fraction(_unitDecimals, (_Dt * _adjustedMr), _Ppy(lockPeriod)) * collateralWaves)
	325	+	}
	326	+
	327	+
	328	+	func _emissionRateWaves (lockPeriod,collateral) = {
	329	+	let extensionFactor = fraction(lockPeriod, 15, 10)
	330	+	((collateral / ((lockPeriod * extensionFactor) - lockPeriod)) * _Dt)
	331	+	}
	332	+
	333	+
	334	+	func _incrTotalStawLP (amount) = {
	335	+	let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
	336	+	[_writeInt(_totalStawLP, (oldStawLP + amount))]
	337	+	}
	338	+
	339	+
	340	+	func _decrTotalStawLP (amount) = {
	341	+	let oldStawLP = _throwOrReturnI(_getI(_totalStawLP), "could not get the running StawLP")
	342	+	[_writeInt(_totalStawLP, (oldStawLP - amount))]
	343	+	}
	344	+
	345	+
	346	+	func _incrTotalWavesRef (amount) = {
	347	+	let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
	348	+	[_writeInt(_totalWavesRef, (oldWavesRef + amount))]
	349	+	}
	350	+
	351	+
	352	+	func _decrTotalWavesRef (amount) = {
	353	+	let oldWavesRef = _throwOrReturnI(_getI(_totalWavesRef), "could not get total locked waves")
	354	+	[_writeInt(_totalWavesRef, (oldWavesRef - amount))]
	355	+	}
	356	+
	357	+
	358	+	func _getNewTimeStamp (blockHeight) = {
	359	+	let time = match blockInfoByHeight(blockHeight) {
	360	+	case timeInfo: BlockInfo =>
	361	+	timeInfo.timestamp
	362	+	case _ =>
	363	+	throw("counld get timestamp")
	364	+	}
	365	+	time
	366	+	}
	367	+
	368	+
	369	+	func _leaseOut () = true
	370	+
	371	+
	372	+	func _cancelLeaseOut () = true
	373	+
	374	+
	375	+	func _mintStaw () = true
	376	+
	377	+
	378	+	func _updateStats () = true
	379	+
	380	+
	381	+	@Callable(i)
	382	+	func getEmission (lockPeriod,collateral) = {
	383	+	let check1 = _onlyManager(i)
	384	+	if ((check1 == check1))
	385	+	then $Tuple2(nil, _emissionRateWaves(lockPeriod, collateral))
	386	+	else throw("Strict value is not equal to itself.")
	387	+	}
	388	+
	389	+
	390	+
	391	+	@Callable(i)
	392	+	func init (manager,dfx,assetID,leaseNode) = {
	393	+	let check1 = _validateAddress(manager)
	394	+	if ((check1 == check1))
	395	+	then {
	396	+	let check2 = _validateAddress(dfx)
	397	+	if ((check2 == check2))
	398	+	then {
	399	+	let check3 = _validateAddress(leaseNode)
	400	+	if ((check3 == check3))
	401	+	then {
	402	+	let circulationIndex = _setParamVal(_circulationIncrIndex, 0)
	403	+	let percentageReductionInMr = _setParamVal(_percentageReductionFactor, 0)
	404	+	let Mr = _setParamVal(_Mr, _unitDecimals)
	405	+	let totalStawMinted = _setParamVal(_totalStaw, 0)
	406	+	let totalStawLPInCirculation = _setParamVal(_totalStawLP, 0)
	407	+	let globalIndexCount = _setParamVal(_globalIndexCount, 0)
	408	+	let totalWavesRef = _setParamVal(_totalWavesRef, 0)
	409	+	[_writeConstString(_manager, manager), _writeConstString(_Dfx, dfx), _writeConstString(_stawAssetId, assetID), _writeStr(_lesseeAddress, leaseNode), _writeAny(_circulationIncrIndex, circulationIndex), _writeAny(_Mr, Mr), _writeAny(_percentageReductionFactor, percentageReductionInMr), _writeAny(_totalWavesRef, totalWavesRef)]
	410	+	}
	411	+	else throw("Strict value is not equal to itself.")
	412	+	}
	413	+	else throw("Strict value is not equal to itself.")
	414	+	}
	415	+	else throw("Strict value is not equal to itself.")
	416	+	}
	417	+
	418	+
	419	+
	420	+	@Callable(i)
	421	+	func modifyInternalParams (key) = {
	422	+	let check1 = _onlyManager(i)
	423	+	if ((check1 == check1))
	424	+	then nil
	425	+	else throw("Strict value is not equal to itself.")
	426	+	}
	427	+
	428	+
	429	+
	430	+	@Callable(i)
	431	+	func revokeMint () = {
	432	+	let check1 = _onlyManager(i)
	433	+	if ((check1 == check1))
	434	+	then nil
	435	+	else throw("Strict value is not equal to itself.")
	436	+	}
	437	+
	438	+
	439	+
	440	+	@Callable(i)
	441	+	func claim (transactionID) = {
	442	+	let callerAddress = toBase58String(i.caller.bytes)
	443	+	let collateralKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
	444	+	let lockperiodKey = makeString([callerAddress, transactionID, _lockDuration], SEP)
	445	+	let lockIdKey = makeString([callerAddress, transactionID, _lockId], SEP)
	446	+	let lockperiodInMiliKey = makeString([callerAddress, transactionID, _lockPeriodInMiliSec], SEP)
	447	+	let totalWavesClaimedKey = makeString([callerAddress, transactionID, _totalWavesClaimed], SEP)
	448	+	let stawLPAmountKey = makeString([callerAddress, transactionID, _stawLPAmount], SEP)
	449	+	let wavesAmountKey = makeString([callerAddress, transactionID, _wavesAmount], SEP)
	450	+	let userTotalWavesLockedKey = makeString([callerAddress, _userTotalLocked], SEP)
	451	+	let userLeaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
	452	+	let leaseStateKey = makeString([callerAddress, transactionID, _userLeaseState], SEP)
	453	+	let globalWavesRef = _getIV(_totalWavesRef)
	454	+	if ((globalWavesRef == globalWavesRef))
	455	+	then {
	456	+	let globalStawPL = _getIV(_totalStawLP)
	457	+	if ((globalStawPL == globalStawPL))
	458	+	then {
	459	+	let lockId = match _getRegistryEntryValue(lockIdKey) {
	460	+	case t: ByteVector =>
	461	+	t
	462	+	case _ =>
	463	+	throw("failed to get lease id")
	464	+	}
	465	+	if ((lockId == lockId))
	466	+	then {
	467	+	let userTotalWavesLocked = match _getRegistryEntryValue(userTotalWavesLockedKey) {
	468	+	case t: Int =>
	469	+	t
	470	+	case _ =>
	471	+	throw("failed to get total waves locked by this address")
	472	+	}
	473	+	if ((userTotalWavesLocked == userTotalWavesLocked))
	474	+	then {
	475	+	let wavesAmount = match _getRegistryEntryValue(wavesAmountKey) {
	476	+	case t: Int =>
	477	+	t
	478	+	case _ =>
	479	+	throw("failed to get total waves locked")
	480	+	}
	481	+	if ((wavesAmount == wavesAmount))
	482	+	then {
	483	+	let totalWavesClaimed = match _getRegistryEntryValue(totalWavesClaimedKey) {
	484	+	case t: Int =>
	485	+	t
	486	+	case _ =>
	487	+	throw("failed to get total waves claimed")
	488	+	}
	489	+	if ((totalWavesClaimed == totalWavesClaimed))
	490	+	then {
	491	+	let stawLPAmount = match _getRegistryEntryValue(stawLPAmountKey) {
	492	+	case t: Int =>
	493	+	t
	494	+	case _ =>
	495	+	throw("failed to get stawPL")
	496	+	}
	497	+	if ((stawLPAmount == stawLPAmount))
	498	+	then {
	499	+	let lockPeriodInMili = match _getRegistryEntryValue(lockperiodInMiliKey) {

github/deemru/w8io/169f3d6 
37.94 ms ◑