tx · 3xZwWbTUY6MN6vh3f2kdtYyrd9JKcXBZt5e2c9jNuuiZ

3PKaRXj6pBb23A8k965eEgBAhhJ4FSDKS5e:  -0.01400000 Waves

2021.03.31 12:48 [2526400] smart account 3PKaRXj6pBb23A8k965eEgBAhhJ4FSDKS5e > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "3xZwWbTUY6MN6vh3f2kdtYyrd9JKcXBZt5e2c9jNuuiZ",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1617184158888,
    "version": 1,
    "sender": "3PKaRXj6pBb23A8k965eEgBAhhJ4FSDKS5e",
    "senderPublicKey": "7AkYRHYaiaxocnoA7YJv29kujpmkVBJxFppUkasDe4Ej",
    "proofs": [
        "u4t7crnFFfQJtZq256EaHiavEiNe2B9nn3EPkJTxpKiUtM8KQjYEs1ek8ACHiVdP2x27EpojzKapvVtpycsu3Es"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2526400,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: Ev18uBsv3orEJ47V911y1aWvZa9YU2Ui8eMBws88ixak
Next: DNm57vSazUmsjJRKZgBRvoef3V95CSyotzdqMgcHT6G2

Diff: 

OldNewDifferences
1212 func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), ("No data for this.key=" + key))
1313 
1414 
15-func failExecuteGet (msg,baseAssetStr,userAddressStr,submitTxIdStr,operationType) = throw(((((((((msg + ": baseAssetStr=") + baseAssetStr) + " userAddressStr=") + userAddressStr) + " submitTxIdStr=") + submitTxIdStr) + " operationType=") + operationType))
15+func failExecuteGet (msg,baseAssetStr,userAddressStr,submitTxIdStr,operationType) = throw(((((((((msg + ": baseAsset=") + baseAssetStr) + " userAddress=") + userAddressStr) + " submitTxId=") + submitTxIdStr) + " operation=") + operationType))
1616 
1717 
18-func failSubmitLimitsExceeds (remainingBase,remainingShare,newRemainingBase,newRemainingShare) = throw((((((((("submit operation limits have been reached: " + " remainingBase=") + toString(remainingBase)) + " remainingShare=") + toString(remainingShare)) + " newRemainingBase=") + toString(newRemainingBase)) + " newRemainingShare=") + toString(newRemainingShare)))
18+func failSubmitLimitsExceeds (remainingBase,remainingShare,newRemainingBase,newRemainingShare) = throw((((((((("submit operation limits have been reached: " + " remainingBaseVal=") + toString(remainingBase)) + " remainingShareVal=") + toString(remainingShare)) + " newRemainingBaseVal=") + toString(newRemainingBase)) + " newRemainingShareVal=") + toString(newRemainingShare)))
1919 
2020 
2121 func failTopupManagerOnly (topupManagerAddress) = throw((("opertion denied: only topUpManager=" + topupManagerAddress) + " can send such transactions"))
6363 func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
6464 
6565 
66-func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
66+func keyShutdownSubmitOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__submit__" + internalBaseAssetStr)
6767 
6868 
6969 func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
231231 func TopupMutexIntEntry (internalBaseAssetStr,acquiredHeight) = IntegerEntry(keyTopupMutext(internalBaseAssetStr), acquiredHeight)
232232 
233233 
234-func TopupHistoryEntry (internalBaseAssetStr,topupIdx) = ""
235-
236-
237234 func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultPrice) = {
238235     let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
239236     let totalLockedOutBaseAmount = totalLockedArray[IdxTotalLockedOutBase]
244241     let currIterTotalInShareAmount = totalLockedArray[IdxTotalLockedInShare]
245242     let shareEmission = value(assetInfo(shareAssetId)).quantity
246243     if ((0 > baseAssetBalanceWCO))
247-        then throw(((("baseAssetBalanceWCO < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceWCO=") + toString(baseAssetBalanceWCO)))
244+        then throw(((("baseAssetBalanceWco < 0: baseAssettBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceWco=") + toString(baseAssetBalanceWCO)))
248245         else {
249246             let lastPrice = getIntOrFail(keyPriceLast(internalBaseAssetStr))
250247             let price = if ((shareEmission == 0))
258255 func calcPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultPrice) = genericCalcPrice(internalBaseAssetStr, baseAssetId, 0, shareAssetId, decimalsMultPrice)
259256 
260257 
261-func submit (operationType,i,inAmount,inAssetId,baseAssetStr) = {
258+func commonSubmit (operationType,i,inAmount,inAssetId,baseAssetStr) = {
262259     let inAssetStr = toBase58String(inAssetId)
263260     let userAddressStr = toString(i.caller)
264261     let baseAssetId = fromBase58String(baseAssetStr)
271268     let limitsCfgArray = split(getStringOrFail(limitsKEY), SEP)
272269     let limitsRemainingBase = parseIntValue(limitsCfgArray[IdxLimitsRemainingBase])
273270     let limitsRemainingShare = parseIntValue(limitsCfgArray[IdxLimitsRemainingShare])
274-    let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
275-    if (isPutBlocked)
276-        then throw("put operation is blocked")
271+    let isSubmitBlocked = valueOrElse(getBoolean(this, keyShutdownSubmitOperation(internalBaseAssetStr)), false)
272+    if (isSubmitBlocked)
273+        then throw("submit operation is blocked")
277274         else {
278275             let operationsMutex = valueOrElse(getInteger(this, keyTopupMutext(internalBaseAssetStr)), 0)
279276             if (((operationsMutex + 60) > height))
295292     }
296293 
297294 
298-func execute (operationType,baseAssetStr,userAddressStr,submitTxIdStr) = {
295+func commonExecute (operationType,baseAssetStr,userAddressStr,submitTxIdStr) = {
299296     let userAddress = addressFromStringValue(userAddressStr)
300297     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
301298     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
308305     let inAmount = parseIntValue(operationArray[IdxOperInAmount])
309306     let topupUnlockIdx = parseIntValue(operationArray[IdxOperTopupUnlockIdx])
310307     let currTopUpIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
311-    let priceByTopUpId = getIntOrFail(keyPriceByTopUpIdx(internalBaseAssetStr, currTopUpIdx))
308+    let priceByTopUpId = getIntOrFail(keyPriceByTopUpIdx(internalBaseAssetStr, topupUnlockIdx))
312309     if ((status != "PENDING"))
313310         then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, submitTxIdStr, operationType)
314311         else if ((topupUnlockIdx > currTopUpIdx))
329326     let cfgArray = readAssetCfgOrFail(baseAssetStr)
330327     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
331328     let shareAssetId = fromBase58String(shareAssetStr)
332-    let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
333-    let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
329+    let decimalsMultBothAssetsVal = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
330+    let decimalsMultPriceVal = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
334331     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
335332     let priceAthKEY = keyPriceATH(internalBaseAssetStr)
336-    let priceATH = valueOrElse(getInteger(this, priceAthKEY), 0)
337-    let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPrice)
338-    $Tuple12(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("-1", sysState._3), IntegerEntry("baseAssetBalanceWCO", sysState._4), IntegerEntry("shareEmission", sysState._5), IntegerEntry("currIterTotalInBaseAmount", sysState._6), IntegerEntry("currIterTotalInShareAmount", sysState._7), IntegerEntry("totalLockedOutBaseAmount", sysState._8), IntegerEntry("totalLockedOutShareAmount", sysState._9), IntegerEntry("decimalsMultBothAssets", decimalsMultBothAssets), IntegerEntry("priceATH", priceATH))
333+    let priceAthVal = valueOrElse(getInteger(this, priceAthKEY), 0)
334+    let priceLastKEY = keyPriceLast(internalBaseAssetStr)
335+    let priceLastVal = valueOrElse(getInteger(this, priceLastKEY), 0)
336+    let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPriceVal)
337+    $Tuple13(IntegerEntry("price", priceLastVal), IntegerEntry("decimalsMultPrice", decimalsMultPriceVal), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("-1", sysState._3), IntegerEntry("baseAssetBalanceWCO", sysState._4), IntegerEntry("shareEmission", sysState._5), IntegerEntry("currIterTotalInBaseAmount", sysState._6), IntegerEntry("currIterTotalInShareAmount", sysState._7), IntegerEntry("totalLockedOutBaseAmount", sysState._8), IntegerEntry("totalLockedOutShareAmount", sysState._9), IntegerEntry("decimalsMultBothAssets", decimalsMultBothAssetsVal), IntegerEntry("priceATH", priceAthVal), IntegerEntry("priceRecalculated", sysState._1))
339338     }
340339 
341340 
342341 @Callable(i)
343342 func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress,startPrice,topupIntervalInBlocks,topupMaxNegativePart,topupManagerAddress,submitLimitsBaseMax,submitLimitsBaseReset,submitLimitsShareMax,submitLimitsShareReset,adminAddress) = {
344343     let baseAssetId = fromBase58String(baseAssetStr)
345-    let decimals = value(assetInfo(baseAssetId)).decimals
346-    let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
344+    let bothAssetsDecimals = value(assetInfo(baseAssetId)).decimals
345+    let decimalsMultBothAssets = pow(10, 0, bothAssetsDecimals, 0, 0, DOWN)
347346     let decimalsMultPrice = ((100 * 1000) * 1000)
348347     let topupMaxNegativePercents = fraction(topupMaxNegativePart, 100, decimalsMultBothAssets)
349348     let baseAssetBalance = assetBalance(this, baseAssetId)
365364                                 then throw("invalid topupMaxNegativePart parameter")
366365                                 else {
367366                                     let shareInitAmount = convertBase2Share(baseAssetBalance, startPrice, decimalsMultPrice)
368-                                    let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, shareInitAmount, decimals, true)
367+                                    let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, shareInitAmount, bothAssetsDecimals, true)
369368                                     let shareAssetId = calculateAssetId(shareAssetIssueAction)
370369                                     let shareAssetStr = toBase58String(shareAssetId)
371370                                     let internalBaseAssetId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
372371                                     let internalBaseAssetStr = toString(internalBaseAssetId)
373-[StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks, topupIntervalInBlocks, topupMaxNegativePart, topupManagerAddress, submitLimitsBaseMax, submitLimitsBaseReset, submitLimitsShareMax, submitLimitsShareReset, adminAddress)), StringEntry(keyMappingsInternal2baseAssetId(internalBaseAssetId), baseAssetStr), StringEntry(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StringEntry(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StringEntry(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownPutOperation(internalBaseAssetStr), false), StringEntry(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntegerEntry(keyNextInternalAssetId(), (internalBaseAssetId + 1)), IntegerEntry(keyPriceLast(internalBaseAssetStr), startPrice), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), IntegerEntry(keyTopUpCurrentIdx(internalBaseAssetStr), 0), RemainingLimitsStringEntry(keyLimitsRemaining(internalBaseAssetStr), submitLimitsBaseMax, submitLimitsShareMax), shareAssetIssueAction, ScriptTransfer(addressFromStringValue(topupManagerAddress), shareInitAmount, shareAssetId)]
372+[StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks, topupIntervalInBlocks, topupMaxNegativePart, topupManagerAddress, submitLimitsBaseMax, submitLimitsBaseReset, submitLimitsShareMax, submitLimitsShareReset, adminAddress)), StringEntry(keyMappingsInternal2baseAssetId(internalBaseAssetId), baseAssetStr), StringEntry(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StringEntry(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StringEntry(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownSubmitOperation(internalBaseAssetStr), false), StringEntry(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntegerEntry(keyNextInternalAssetId(), (internalBaseAssetId + 1)), IntegerEntry(keyPriceLast(internalBaseAssetStr), startPrice), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), IntegerEntry(keyTopUpCurrentIdx(internalBaseAssetStr), 0), RemainingLimitsStringEntry(keyLimitsRemaining(internalBaseAssetStr), submitLimitsBaseMax, submitLimitsShareMax), shareAssetIssueAction, ScriptTransfer(addressFromStringValue(topupManagerAddress), shareInitAmount, shareAssetId)]
374373                                     }
375374     }
376375 
377376 
378377 
379378 @Callable(i)
380-func shutdownPut (internalBaseAssetId) = {
379+func shutdownSubmits (internalBaseAssetId) = {
381380     let internalBaseAssetIdStr = toString(internalBaseAssetId)
382381     let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
383382     let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
385384         then throw("invalid internalBaseAssetId")
386385         else if ((toString(i.caller) != shutdownManagerAddress))
387386             then throw("access denied")
388-            else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
387+            else [BooleanEntry(keyShutdownSubmitOperation(toString(internalBaseAssetId)), true)]
389388     }
390389 
391390 
396395     let inAmount = pmt.amount
397396     let inAssetId = value(pmt.assetId)
398397     let baseAssetStr = toBase58String(inAssetId)
399-    submit("P", i, inAmount, inAssetId, baseAssetStr)
398+    commonSubmit("P", i, inAmount, inAssetId, baseAssetStr)
400399     }
401400 
402401 
408407     let inAssetId = value(pmt.assetId)
409408     let shareAssetStr = toBase58String(inAssetId)
410409     let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
411-    submit("G", i, inAmount, inAssetId, baseAssetStr)
410+    commonSubmit("G", i, inAmount, inAssetId, baseAssetStr)
412411     }
413412 
414413 
415414 
416415 @Callable(i)
417-func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = execute("P", baseAssetStr, userAddressStr, submitTxIdStr)
416+func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = commonExecute("P", baseAssetStr, userAddressStr, submitTxIdStr)
418417 
419418 
420419 
421420 @Callable(i)
422-func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = execute("G", baseAssetStr, userAddressStr, submitTxIdStr)
421+func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = commonExecute("G", baseAssetStr, userAddressStr, submitTxIdStr)
423422 
424423 
425424 
436435 
437436 
438437 @Callable(i)
439-func topUpBalance (baseAssetStr,amount) = {
438+func topUpBalance (baseAssetStr,income) = {
440439     let baseAssetId = fromBase58String(baseAssetStr)
441440     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
442441     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
446445     let topupMaxNegativePart = parseIntValue(assetCfgArray[IdxCfgTopupMaxNegativePart])
447446     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
448447     let topUpManagerAddressStr = assetCfgArray[IdxCfgTopupManagerAddress]
448+    let submitLimitsBaseMax = parseIntValue(assetCfgArray[IdxCfgSubmitLimitsBaseMax])
449+    let submitLimitsShareMax = parseIntValue(assetCfgArray[IdxCfgSubmitLimitsShareMax])
449450     let topUpCurrentIdxKEY = keyTopUpCurrentIdx(internalBaseAssetStr)
450451     let prevTopUpIdx = getIntOrFail(topUpCurrentIdxKEY)
451452     let currentTopUpIdx = (prevTopUpIdx + 1)
452-    let valid = if ((amount > 0))
453+    let valid = if ((income > 0))
453454         then {
454455             let pmt = value(i.payments[0])
455456             let pmtAssetId = value(pmt.assetId)
457458                 then throw("attached payment's asset id is NOT matched passed baseAssetStr")
458459                 else if ((size(i.payments) > 1))
459460                     then throw("only one payment can be attached")
460-                    else if ((pmt.amount != amount))
461-                        then throw("attached payment.amount is NOT matched passed amount argument")
461+                    else if ((pmt.amount != income))
462+                        then throw("attached payment.amount is NOT matched passed income argument")
462463                         else true
463464             }
464-        else if ((0 > amount))
465+        else if ((0 > income))
465466             then {
466467                 let baseBalance = assetBalance(this, baseAssetId)
467468                 let allowedAmount = fraction(topupMaxNegativePart, baseBalance, bothAssetMult)
468-                if ((-(amount) > allowedAmount))
469-                    then throw(("topup negative amount couldn't be greater than " + toString(allowedAmount)))
469+                if ((-(income) > allowedAmount))
470+                    then throw(("topup negative income couldn't be greater than " + toString(allowedAmount)))
470471                     else true
471472                 }
472-            else throw("zero amount is not allowed")
473+            else throw("zero income is not allowed")
473474     let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
474475     let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
475476     if ((toString(i.caller) != topUpManagerAddressStr))
479480             else if ((topupIntervalInBlocks > (height - topUpLastHeight)))
480481                 then throw((("1 topup per " + toString(topupIntervalInBlocks)) + " blocks from the same address is allowed"))
481482                 else {
482-                    let price = genericCalcPrice(internalBaseAssetStr, baseAssetId, amount, shareAssetId, priceMult)._1
483+                    let price = genericCalcPrice(internalBaseAssetStr, baseAssetId, income, shareAssetId, priceMult)._1
483484                     let diffTuple = calcTotalLockedDiff("topup", "", internalBaseAssetStr, price, priceMult, 0, baseAssetId, shareAssetId)
484485                     let topupTotalDiff = diffTuple._1
485486                     let priceAthKEY = keyPriceATH(internalBaseAssetStr)
486487                     let prevPriceATH = valueOrElse(getInteger(this, priceAthKEY), 0)
487-                    ((((([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx), IntegerEntry(priceAthKEY, if ((price > prevPriceATH))
488+                    (((((([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx), IntegerEntry(priceAthKEY, if ((price > prevPriceATH))
488489                         then price
489-                        else prevPriceATH), IntegerEntry(topUpLastHeightKEY, height)] :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), topupTotalDiff)) :+ TopupMutexIntEntry(internalBaseAssetStr, 0)) :+ Burn(shareAssetId, topupTotalDiff[IdxTotalLockedInShare])) :+ Reissue(shareAssetId, -(topupTotalDiff[IdxTotalLockedOutShare]), true)) ++ (if ((0 > amount))
490-                        then [ScriptTransfer(i.caller, -(amount), baseAssetId)]
490+                        else prevPriceATH), IntegerEntry(topUpLastHeightKEY, height)] :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), topupTotalDiff)) :+ TopupMutexIntEntry(internalBaseAssetStr, 0)) :+ RemainingLimitsStringEntry(keyLimitsRemaining(internalBaseAssetStr), submitLimitsBaseMax, submitLimitsShareMax)) :+ Burn(shareAssetId, topupTotalDiff[IdxTotalLockedInShare])) :+ Reissue(shareAssetId, -(topupTotalDiff[IdxTotalLockedOutShare]), true)) ++ (if ((0 > income))
491+                        then [ScriptTransfer(i.caller, -(income), baseAssetId)]
491492                         else nil))
492493                     }
493494     }
509510     let totalLockedOutShareAmount = sysStateTuple._10.value
510511     let decimalsMultBothAssets = sysStateTuple._11.value
511512     let priceATH = sysStateTuple._12.value
512-    let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceWCO), toString(shareEmission), toString(currIterTotalInBaseAmount), toString(currIterTotalInShareAmount), toString(totalLockedOutBaseAmount), toString(totalLockedOutShareAmount), toString(decimalsMultBothAssets), toString(priceATH), "endCurrentSysParamsREST"], SEP)
513+    let priceRecalculated = sysStateTuple._13.value
514+    let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceWCO), toString(shareEmission), toString(currIterTotalInBaseAmount), toString(currIterTotalInShareAmount), toString(totalLockedOutBaseAmount), toString(totalLockedOutShareAmount), toString(decimalsMultBothAssets), toString(priceATH), toString(priceRecalculated), "endCurrentSysParamsREST"], SEP)
513515     throw(restData)
514516     }
515517 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 4 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "__"
55 
66 func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
77 
88 
99 func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
1010 
1111 
1212 func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), ("No data for this.key=" + key))
1313 
1414 
15-func failExecuteGet (msg,baseAssetStr,userAddressStr,submitTxIdStr,operationType) = throw(((((((((msg + ": baseAssetStr=") + baseAssetStr) + " userAddressStr=") + userAddressStr) + " submitTxIdStr=") + submitTxIdStr) + " operationType=") + operationType))
15+func failExecuteGet (msg,baseAssetStr,userAddressStr,submitTxIdStr,operationType) = throw(((((((((msg + ": baseAsset=") + baseAssetStr) + " userAddress=") + userAddressStr) + " submitTxId=") + submitTxIdStr) + " operation=") + operationType))
1616 
1717 
18-func failSubmitLimitsExceeds (remainingBase,remainingShare,newRemainingBase,newRemainingShare) = throw((((((((("submit operation limits have been reached: " + " remainingBase=") + toString(remainingBase)) + " remainingShare=") + toString(remainingShare)) + " newRemainingBase=") + toString(newRemainingBase)) + " newRemainingShare=") + toString(newRemainingShare)))
18+func failSubmitLimitsExceeds (remainingBase,remainingShare,newRemainingBase,newRemainingShare) = throw((((((((("submit operation limits have been reached: " + " remainingBaseVal=") + toString(remainingBase)) + " remainingShareVal=") + toString(remainingShare)) + " newRemainingBaseVal=") + toString(newRemainingBase)) + " newRemainingShareVal=") + toString(newRemainingShare)))
1919 
2020 
2121 func failTopupManagerOnly (topupManagerAddress) = throw((("opertion denied: only topUpManager=" + topupManagerAddress) + " can send such transactions"))
2222 
2323 
2424 func convertShare2Base (shareAmount,price,priceMult) = fraction(shareAmount, price, priceMult)
2525 
2626 
2727 func convertBase2Share (baseAmount,price,priceMult) = fraction(baseAmount, priceMult, price)
2828 
2929 
3030 func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
3131 
3232 
3333 func keyNextInternalAssetId () = "%s__nextInternalAssetId"
3434 
3535 
3636 func keyPriceLast (internalBasetAssetStr) = ("%s%s%d__price__last__" + internalBasetAssetStr)
3737 
3838 
3939 func keyPriceATH (internalBasetAssetStr) = ("%s%s%d__price__ath__" + internalBasetAssetStr)
4040 
4141 
4242 func keyPriceByTopUpIdx (internalBaseAssetStr,topUpIdx) = makeString(["%s%s%d%d__price__byTopUpIdx", internalBaseAssetStr, toString(topUpIdx)], SEP)
4343 
4444 
4545 func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
4646 
4747 
4848 func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
4949 
5050 
5151 func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
5252 
5353 
5454 func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
5555 
5656 
5757 func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
5858 
5959 
6060 func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
6161 
6262 
6363 func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
6464 
6565 
66-func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
66+func keyShutdownSubmitOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__submit__" + internalBaseAssetStr)
6767 
6868 
6969 func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
7070 
7171 
7272 func keyTopUpCurrentIdx (internalBaseAssetStr) = ("%s%s%d__topup__currentIdx__" + internalBaseAssetStr)
7373 
7474 
7575 func keyTopUpLastHeight (internalBasetAssetStr,sender) = makeString(["%s%s%s%d%s__topup__last__height", internalBasetAssetStr, sender], SEP)
7676 
7777 
7878 func keyTopupMutext (internalBasetAssetStr) = ("%s%s%d__topup__mutex__" + internalBasetAssetStr)
7979 
8080 
8181 func keyTopupHistory (internalBasetAssetStr,topupIdx) = makeString(["%s%s%d%d__topup__history", internalBasetAssetStr, toString(topupIdx)], SEP)
8282 
8383 
8484 func keyLimitsRemaining (internalBasetAssetStr) = ("%s%s%d__limits__remaining__" + internalBasetAssetStr)
8585 
8686 
8787 let IdxCfgShareAssetId = 1
8888 
8989 let IdxCfgInternalBaseAsset = 2
9090 
9191 let IdxCfgDecimalsMultBothAssets = 3
9292 
9393 let IdxCfgDecimalsMultPrice = 4
9494 
9595 let IdxCfgGetDelayBlocks = 5
9696 
9797 let IdxCfgTopupIntervalInBlocks = 6
9898 
9999 let IdxCfgTopupMaxNegativePart = 7
100100 
101101 let IdxCfgTopupManagerAddress = 8
102102 
103103 let IdxCfgSubmitLimitsBaseMax = 9
104104 
105105 let IdxCfgSubmitLimitsBaseReset = 10
106106 
107107 let IdxCfgSubmitLimitsShareMax = 11
108108 
109109 let IdxCfgSubmitLimitsShareReset = 12
110110 
111111 let IdxCfgAdminAddress = 13
112112 
113113 func dataAssetCfg (shareAssetStr,internalBaseAssetStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks,topupIntervalInBlocks,topupMaxNegativePart,topupManagerAddress,submitLimitsBaseMax,submitLimitsBaseReset,submitLimitsShareMax,submitLimitsShareReset,adminAddress) = makeString(["%s%d%d%d%d%d%d%s%d%d%d%d", shareAssetStr, internalBaseAssetStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks), toString(topupIntervalInBlocks), toString(topupMaxNegativePart), topupManagerAddress, toString(submitLimitsBaseMax), toString(submitLimitsBaseReset), toString(submitLimitsShareMax), toString(submitLimitsShareReset), adminAddress], SEP)
114114 
115115 
116116 let IdxTotalLockedInShare = 1
117117 
118118 let IdxTotalLockedOutBase = 2
119119 
120120 let IdxTotalLockedInBase = 3
121121 
122122 let IdxTotalLockedOutShare = 4
123123 
124124 func dataTotalLocked (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = makeString(["%d%d%d%d", toString(inShareAmount), toString(outBaseAmount), toString(inBaseAmount), toString(outShareAmount)], SEP)
125125 
126126 
127127 func dataTotalLockedInt (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = [-1, inShareAmount, outBaseAmount, inBaseAmount, outShareAmount]
128128 
129129 
130130 func readTotalLocked (key) = {
131131     let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0, 0, 0)), SEP)
132132     dataTotalLockedInt(parseIntValue(totalLockedArray[IdxTotalLockedInShare]), parseIntValue(totalLockedArray[IdxTotalLockedOutBase]), parseIntValue(totalLockedArray[IdxTotalLockedInBase]), parseIntValue(totalLockedArray[IdxTotalLockedOutShare]))
133133     }
134134 
135135 
136136 func calcTotalLockedDiff (direction,operationType,internalBaseAssetStr,price,priceMult,inAmount,baseAssetId,shareAssetId) = {
137137     let t = (direction + operationType)
138138     if ((t == "submitP"))
139139         then {
140140             let totalDiff = dataTotalLockedInt(0, 0, inAmount, 0)
141141             let userDiff = totalDiff
142142             $Tuple4(totalDiff, userDiff, 0, fromBase58String(""))
143143             }
144144         else if ((t == "submitG"))
145145             then {
146146                 let totalDiff = dataTotalLockedInt(inAmount, 0, 0, 0)
147147                 let userDiff = totalDiff
148148                 $Tuple4(totalDiff, userDiff, 0, fromBase58String(""))
149149                 }
150150             else if ((t == "executeP"))
151151                 then {
152152                     let outAmount = convertBase2Share(inAmount, price, priceMult)
153153                     let totalDiff = dataTotalLockedInt(0, 0, 0, outAmount)
154154                     let userDiff = dataTotalLockedInt(0, 0, inAmount, 0)
155155                     $Tuple4(totalDiff, userDiff, outAmount, shareAssetId)
156156                     }
157157                 else if ((t == "executeG"))
158158                     then {
159159                         let outAmount = convertShare2Base(inAmount, price, priceMult)
160160                         let totalDiff = dataTotalLockedInt(0, outAmount, 0, 0)
161161                         let userDiff = dataTotalLockedInt(inAmount, 0, 0, 0)
162162                         $Tuple4(totalDiff, userDiff, outAmount, baseAssetId)
163163                         }
164164                     else if ((t == "topup"))
165165                         then {
166166                             let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
167167                             let totalLockedInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
168168                             let totalLockedInShareAmount = totalLockedArray[IdxTotalLockedInShare]
169169                             let totalDiff = dataTotalLockedInt(totalLockedInShareAmount, (-1 * convertShare2Base(totalLockedInShareAmount, price, priceMult)), totalLockedInBaseAmount, (-1 * convertBase2Share(totalLockedInBaseAmount, price, priceMult)))
170170                             $Tuple4(totalDiff, nil, 0, fromBase58String(""))
171171                             }
172172                         else throw(("Unsupported Type " + t))
173173     }
174174 
175175 
176176 func TotalLockedStringEntry (action,key,diff) = {
177177     func UPDATE (a,b) =     if ((action == "INCREMENT"))
178178         then (a + b)
179179         else if ((action == "DECREMENT"))
180180             then (a - b)
181181             else throw(("Unsupported action " + action))
182182 
183183     let dataArray = readTotalLocked(key)
184184     StringEntry(key, dataTotalLocked(UPDATE(dataArray[IdxTotalLockedInShare], diff[IdxTotalLockedInShare]), UPDATE(dataArray[IdxTotalLockedOutBase], diff[IdxTotalLockedOutBase]), UPDATE(dataArray[IdxTotalLockedInBase], diff[IdxTotalLockedInBase]), UPDATE(dataArray[IdxTotalLockedOutShare], diff[IdxTotalLockedOutShare])))
185185     }
186186 
187187 
188188 func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
189189 
190190 
191191 let IdxOperStatus = 1
192192 
193193 let IdxOperInAmount = 2
194194 
195195 let IdxOperPrice = 3
196196 
197197 let IdxOperOutAmount = 4
198198 
199199 let IdxOperStartHeight = 5
200200 
201201 let IdxOperStartTimestamp = 6
202202 
203203 let IdxOperEndHeight = 7
204204 
205205 let IdxOperEndTimestamp = 8
206206 
207207 let IdxOperTopupUnlockIdx = 9
208208 
209209 func privateDataOperationAllStrings (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp,lock) = makeString(["%s%d%d%d%d%d%d%d%d", status, inAssetAmount, price, outAssetAmount, startHeight, startTimestamp, endHeight, endTimestamp, lock], SEP)
210210 
211211 
212212 func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp,topupUnlockIdx) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp), toString(topupUnlockIdx))
213213 
214214 
215215 func dataOperationExecutionUpdate (currOperArray,newStatus,newPrice,newOutAmount) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], toString(newPrice), toString(newOutAmount), currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], toString(height), toString(lastBlock.timestamp), currOperArray[IdxOperTopupUnlockIdx])
216216 
217217 
218218 func readAssetCfgOrFail (baseAssetStr) = {
219219     let key = keyAssetCfg(baseAssetStr)
220220     split(getStringOrFail(key), SEP)
221221     }
222222 
223223 
224224 let IdxLimitsRemainingBase = 1
225225 
226226 let IdxLimitsRemainingShare = 2
227227 
228228 func RemainingLimitsStringEntry (key,baseRemainingLimit,shareRemainingLimit) = StringEntry(key, makeString(["%d%d", toString(baseRemainingLimit), toString(shareRemainingLimit)], SEP))
229229 
230230 
231231 func TopupMutexIntEntry (internalBaseAssetStr,acquiredHeight) = IntegerEntry(keyTopupMutext(internalBaseAssetStr), acquiredHeight)
232232 
233233 
234-func TopupHistoryEntry (internalBaseAssetStr,topupIdx) = ""
235-
236-
237234 func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultPrice) = {
238235     let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
239236     let totalLockedOutBaseAmount = totalLockedArray[IdxTotalLockedOutBase]
240237     let currIterTotalInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
241238     let baseAssetBalance = assetBalance(this, baseAssetId)
242239     let baseAssetBalanceWCO = (((baseAssetBalance + topUpBaseAmount) - currIterTotalInBaseAmount) - totalLockedOutBaseAmount)
243240     let totalLockedOutShareAmount = totalLockedArray[IdxTotalLockedOutShare]
244241     let currIterTotalInShareAmount = totalLockedArray[IdxTotalLockedInShare]
245242     let shareEmission = value(assetInfo(shareAssetId)).quantity
246243     if ((0 > baseAssetBalanceWCO))
247-        then throw(((("baseAssetBalanceWCO < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceWCO=") + toString(baseAssetBalanceWCO)))
244+        then throw(((("baseAssetBalanceWco < 0: baseAssettBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceWco=") + toString(baseAssetBalanceWCO)))
248245         else {
249246             let lastPrice = getIntOrFail(keyPriceLast(internalBaseAssetStr))
250247             let price = if ((shareEmission == 0))
251248                 then lastPrice
252249                 else fraction(baseAssetBalanceWCO, decimalsMultPrice, shareEmission)
253250             $Tuple9(price, baseAssetBalance, -1, baseAssetBalanceWCO, shareEmission, currIterTotalInBaseAmount, currIterTotalInShareAmount, totalLockedOutBaseAmount, totalLockedOutShareAmount)
254251             }
255252     }
256253 
257254 
258255 func calcPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultPrice) = genericCalcPrice(internalBaseAssetStr, baseAssetId, 0, shareAssetId, decimalsMultPrice)
259256 
260257 
261-func submit (operationType,i,inAmount,inAssetId,baseAssetStr) = {
258+func commonSubmit (operationType,i,inAmount,inAssetId,baseAssetStr) = {
262259     let inAssetStr = toBase58String(inAssetId)
263260     let userAddressStr = toString(i.caller)
264261     let baseAssetId = fromBase58String(baseAssetStr)
265262     let cfgArray = readAssetCfgOrFail(baseAssetStr)
266263     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
267264     let shareAssetId = fromBase58String(shareAssetStr)
268265     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
269266     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
270267     let limitsKEY = keyLimitsRemaining(internalBaseAssetStr)
271268     let limitsCfgArray = split(getStringOrFail(limitsKEY), SEP)
272269     let limitsRemainingBase = parseIntValue(limitsCfgArray[IdxLimitsRemainingBase])
273270     let limitsRemainingShare = parseIntValue(limitsCfgArray[IdxLimitsRemainingShare])
274-    let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
275-    if (isPutBlocked)
276-        then throw("put operation is blocked")
271+    let isSubmitBlocked = valueOrElse(getBoolean(this, keyShutdownSubmitOperation(internalBaseAssetStr)), false)
272+    if (isSubmitBlocked)
273+        then throw("submit operation is blocked")
277274         else {
278275             let operationsMutex = valueOrElse(getInteger(this, keyTopupMutext(internalBaseAssetStr)), 0)
279276             if (((operationsMutex + 60) > height))
280277                 then throw("submit operations are blocked by topup manager")
281278                 else {
282279                     let diffTuple = calcTotalLockedDiff("submit", operationType, internalBaseAssetStr, 0, 0, inAmount, baseAssetId, shareAssetId)
283280                     let limitsRemainingBaseNew = (limitsRemainingBase - diffTuple._2[IdxTotalLockedInBase])
284281                     let limitsRemainingShareNew = (limitsRemainingShare - diffTuple._2[IdxTotalLockedInShare])
285282                     if (if ((0 > limitsRemainingBaseNew))
286283                         then true
287284                         else (0 > limitsRemainingShareNew))
288285                         then failSubmitLimitsExceeds(limitsRemainingBase, limitsRemainingShare, limitsRemainingBaseNew, limitsRemainingShareNew)
289286                         else {
290287                             let topUpCurrentIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
291288                             ((([StringEntry(keyOperation(operationType, internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("PENDING", inAmount, 0, 0, height, lastBlock.timestamp, 0, 0, (topUpCurrentIdx + 1)))] :+ TotalLockedStringEntry("INCREMENT", keyTotalLocked(internalBaseAssetStr), diffTuple._1)) :+ TotalLockedStringEntry("INCREMENT", keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), diffTuple._2)) :+ RemainingLimitsStringEntry(limitsKEY, limitsRemainingBaseNew, limitsRemainingShareNew))
292289                             }
293290                     }
294291             }
295292     }
296293 
297294 
298-func execute (operationType,baseAssetStr,userAddressStr,submitTxIdStr) = {
295+func commonExecute (operationType,baseAssetStr,userAddressStr,submitTxIdStr) = {
299296     let userAddress = addressFromStringValue(userAddressStr)
300297     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
301298     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
302299     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
303300     let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
304301     let baseAssetId = fromBase58String(baseAssetStr)
305302     let operationKey = keyOperation(operationType, internalBaseAssetStr, userAddressStr, submitTxIdStr)
306303     let operationArray = split(getStringOrFail(operationKey), SEP)
307304     let status = operationArray[IdxOperStatus]
308305     let inAmount = parseIntValue(operationArray[IdxOperInAmount])
309306     let topupUnlockIdx = parseIntValue(operationArray[IdxOperTopupUnlockIdx])
310307     let currTopUpIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
311-    let priceByTopUpId = getIntOrFail(keyPriceByTopUpIdx(internalBaseAssetStr, currTopUpIdx))
308+    let priceByTopUpId = getIntOrFail(keyPriceByTopUpIdx(internalBaseAssetStr, topupUnlockIdx))
312309     if ((status != "PENDING"))
313310         then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, submitTxIdStr, operationType)
314311         else if ((topupUnlockIdx > currTopUpIdx))
315312             then failExecuteGet(((("OperLock[" + toString(topupUnlockIdx)) + "] > ") + toString(currTopUpIdx)), baseAssetStr, userAddressStr, submitTxIdStr, operationType)
316313             else {
317314                 let diffTuple = calcTotalLockedDiff("execute", operationType, internalBaseAssetStr, priceByTopUpId, decimalsMultPrice, inAmount, baseAssetId, shareAssetId)
318315                 let outAmount = diffTuple._3
319316                 let outTransferData = if ((diffTuple._4 == baseAssetId))
320317                     then [ScriptTransfer(userAddress, outAmount, baseAssetId)]
321318                     else [ScriptTransfer(userAddress, outAmount, shareAssetId)]
322319                 (((outTransferData :+ StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", priceByTopUpId, outAmount))) :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), diffTuple._1)) :+ TotalLockedStringEntry("DECREMENT", keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), diffTuple._2))
323320                 }
324321     }
325322 
326323 
327324 func privateCurrentSysParamsREST (baseAssetStr) = {
328325     let baseAssetId = fromBase58String(baseAssetStr)
329326     let cfgArray = readAssetCfgOrFail(baseAssetStr)
330327     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
331328     let shareAssetId = fromBase58String(shareAssetStr)
332-    let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
333-    let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
329+    let decimalsMultBothAssetsVal = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
330+    let decimalsMultPriceVal = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
334331     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
335332     let priceAthKEY = keyPriceATH(internalBaseAssetStr)
336-    let priceATH = valueOrElse(getInteger(this, priceAthKEY), 0)
337-    let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPrice)
338-    $Tuple12(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("-1", sysState._3), IntegerEntry("baseAssetBalanceWCO", sysState._4), IntegerEntry("shareEmission", sysState._5), IntegerEntry("currIterTotalInBaseAmount", sysState._6), IntegerEntry("currIterTotalInShareAmount", sysState._7), IntegerEntry("totalLockedOutBaseAmount", sysState._8), IntegerEntry("totalLockedOutShareAmount", sysState._9), IntegerEntry("decimalsMultBothAssets", decimalsMultBothAssets), IntegerEntry("priceATH", priceATH))
333+    let priceAthVal = valueOrElse(getInteger(this, priceAthKEY), 0)
334+    let priceLastKEY = keyPriceLast(internalBaseAssetStr)
335+    let priceLastVal = valueOrElse(getInteger(this, priceLastKEY), 0)
336+    let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPriceVal)
337+    $Tuple13(IntegerEntry("price", priceLastVal), IntegerEntry("decimalsMultPrice", decimalsMultPriceVal), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("-1", sysState._3), IntegerEntry("baseAssetBalanceWCO", sysState._4), IntegerEntry("shareEmission", sysState._5), IntegerEntry("currIterTotalInBaseAmount", sysState._6), IntegerEntry("currIterTotalInShareAmount", sysState._7), IntegerEntry("totalLockedOutBaseAmount", sysState._8), IntegerEntry("totalLockedOutShareAmount", sysState._9), IntegerEntry("decimalsMultBothAssets", decimalsMultBothAssetsVal), IntegerEntry("priceATH", priceAthVal), IntegerEntry("priceRecalculated", sysState._1))
339338     }
340339 
341340 
342341 @Callable(i)
343342 func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress,startPrice,topupIntervalInBlocks,topupMaxNegativePart,topupManagerAddress,submitLimitsBaseMax,submitLimitsBaseReset,submitLimitsShareMax,submitLimitsShareReset,adminAddress) = {
344343     let baseAssetId = fromBase58String(baseAssetStr)
345-    let decimals = value(assetInfo(baseAssetId)).decimals
346-    let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
344+    let bothAssetsDecimals = value(assetInfo(baseAssetId)).decimals
345+    let decimalsMultBothAssets = pow(10, 0, bothAssetsDecimals, 0, 0, DOWN)
347346     let decimalsMultPrice = ((100 * 1000) * 1000)
348347     let topupMaxNegativePercents = fraction(topupMaxNegativePart, 100, decimalsMultBothAssets)
349348     let baseAssetBalance = assetBalance(this, baseAssetId)
350349     if ((i.caller != this))
351350         then throw("permissions denied")
352351         else if ((baseAssetBalance == 0))
353352             then throw(((toString(this) + " must have any initial balance of ") + baseAssetStr))
354353             else if (isDefined(getString(this, keyAssetCfg(baseAssetStr))))
355354                 then throw((baseAssetStr + " has been already registered"))
356355                 else if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
357356                     then throw("invalid shutdownManagerAddress")
358357                     else if ((toString(addressFromStringValue(topupManagerAddress)) != topupManagerAddress))
359358                         then throw("invalid topupManagerAddress")
360359                         else if ((0 > getDelayinBlocks))
361360                             then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
362361                             else if (if ((0 >= topupMaxNegativePercents))
363362                                 then true
364363                                 else (topupMaxNegativePercents >= 99))
365364                                 then throw("invalid topupMaxNegativePart parameter")
366365                                 else {
367366                                     let shareInitAmount = convertBase2Share(baseAssetBalance, startPrice, decimalsMultPrice)
368-                                    let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, shareInitAmount, decimals, true)
367+                                    let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, shareInitAmount, bothAssetsDecimals, true)
369368                                     let shareAssetId = calculateAssetId(shareAssetIssueAction)
370369                                     let shareAssetStr = toBase58String(shareAssetId)
371370                                     let internalBaseAssetId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
372371                                     let internalBaseAssetStr = toString(internalBaseAssetId)
373-[StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks, topupIntervalInBlocks, topupMaxNegativePart, topupManagerAddress, submitLimitsBaseMax, submitLimitsBaseReset, submitLimitsShareMax, submitLimitsShareReset, adminAddress)), StringEntry(keyMappingsInternal2baseAssetId(internalBaseAssetId), baseAssetStr), StringEntry(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StringEntry(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StringEntry(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownPutOperation(internalBaseAssetStr), false), StringEntry(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntegerEntry(keyNextInternalAssetId(), (internalBaseAssetId + 1)), IntegerEntry(keyPriceLast(internalBaseAssetStr), startPrice), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), IntegerEntry(keyTopUpCurrentIdx(internalBaseAssetStr), 0), RemainingLimitsStringEntry(keyLimitsRemaining(internalBaseAssetStr), submitLimitsBaseMax, submitLimitsShareMax), shareAssetIssueAction, ScriptTransfer(addressFromStringValue(topupManagerAddress), shareInitAmount, shareAssetId)]
372+[StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks, topupIntervalInBlocks, topupMaxNegativePart, topupManagerAddress, submitLimitsBaseMax, submitLimitsBaseReset, submitLimitsShareMax, submitLimitsShareReset, adminAddress)), StringEntry(keyMappingsInternal2baseAssetId(internalBaseAssetId), baseAssetStr), StringEntry(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StringEntry(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StringEntry(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownSubmitOperation(internalBaseAssetStr), false), StringEntry(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntegerEntry(keyNextInternalAssetId(), (internalBaseAssetId + 1)), IntegerEntry(keyPriceLast(internalBaseAssetStr), startPrice), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), IntegerEntry(keyTopUpCurrentIdx(internalBaseAssetStr), 0), RemainingLimitsStringEntry(keyLimitsRemaining(internalBaseAssetStr), submitLimitsBaseMax, submitLimitsShareMax), shareAssetIssueAction, ScriptTransfer(addressFromStringValue(topupManagerAddress), shareInitAmount, shareAssetId)]
374373                                     }
375374     }
376375 
377376 
378377 
379378 @Callable(i)
380-func shutdownPut (internalBaseAssetId) = {
379+func shutdownSubmits (internalBaseAssetId) = {
381380     let internalBaseAssetIdStr = toString(internalBaseAssetId)
382381     let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
383382     let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
384383     if ((1 > size(baseAssetIdStr)))
385384         then throw("invalid internalBaseAssetId")
386385         else if ((toString(i.caller) != shutdownManagerAddress))
387386             then throw("access denied")
388-            else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
387+            else [BooleanEntry(keyShutdownSubmitOperation(toString(internalBaseAssetId)), true)]
389388     }
390389 
391390 
392391 
393392 @Callable(i)
394393 func submitPut () = {
395394     let pmt = value(i.payments[0])
396395     let inAmount = pmt.amount
397396     let inAssetId = value(pmt.assetId)
398397     let baseAssetStr = toBase58String(inAssetId)
399-    submit("P", i, inAmount, inAssetId, baseAssetStr)
398+    commonSubmit("P", i, inAmount, inAssetId, baseAssetStr)
400399     }
401400 
402401 
403402 
404403 @Callable(i)
405404 func submitGet () = {
406405     let pmt = value(i.payments[0])
407406     let inAmount = pmt.amount
408407     let inAssetId = value(pmt.assetId)
409408     let shareAssetStr = toBase58String(inAssetId)
410409     let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
411-    submit("G", i, inAmount, inAssetId, baseAssetStr)
410+    commonSubmit("G", i, inAmount, inAssetId, baseAssetStr)
412411     }
413412 
414413 
415414 
416415 @Callable(i)
417-func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = execute("P", baseAssetStr, userAddressStr, submitTxIdStr)
416+func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = commonExecute("P", baseAssetStr, userAddressStr, submitTxIdStr)
418417 
419418 
420419 
421420 @Callable(i)
422-func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = execute("G", baseAssetStr, userAddressStr, submitTxIdStr)
421+func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = commonExecute("G", baseAssetStr, userAddressStr, submitTxIdStr)
423422 
424423 
425424 
426425 @Callable(i)
427426 func operationsMutex (baseAssetStr) = {
428427     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
429428     let topUpManagerAddressStr = assetCfgArray[IdxCfgTopupManagerAddress]
430429     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
431430     if ((toString(i.caller) != topUpManagerAddressStr))
432431         then failTopupManagerOnly(topUpManagerAddressStr)
433432         else [TopupMutexIntEntry(internalBaseAssetStr, height)]
434433     }
435434 
436435 
437436 
438437 @Callable(i)
439-func topUpBalance (baseAssetStr,amount) = {
438+func topUpBalance (baseAssetStr,income) = {
440439     let baseAssetId = fromBase58String(baseAssetStr)
441440     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
442441     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
443442     let priceMult = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
444443     let bothAssetMult = parseIntValue(assetCfgArray[IdxCfgDecimalsMultBothAssets])
445444     let topupIntervalInBlocks = parseIntValue(assetCfgArray[IdxCfgTopupIntervalInBlocks])
446445     let topupMaxNegativePart = parseIntValue(assetCfgArray[IdxCfgTopupMaxNegativePart])
447446     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
448447     let topUpManagerAddressStr = assetCfgArray[IdxCfgTopupManagerAddress]
448+    let submitLimitsBaseMax = parseIntValue(assetCfgArray[IdxCfgSubmitLimitsBaseMax])
449+    let submitLimitsShareMax = parseIntValue(assetCfgArray[IdxCfgSubmitLimitsShareMax])
449450     let topUpCurrentIdxKEY = keyTopUpCurrentIdx(internalBaseAssetStr)
450451     let prevTopUpIdx = getIntOrFail(topUpCurrentIdxKEY)
451452     let currentTopUpIdx = (prevTopUpIdx + 1)
452-    let valid = if ((amount > 0))
453+    let valid = if ((income > 0))
453454         then {
454455             let pmt = value(i.payments[0])
455456             let pmtAssetId = value(pmt.assetId)
456457             if ((baseAssetId != pmtAssetId))
457458                 then throw("attached payment's asset id is NOT matched passed baseAssetStr")
458459                 else if ((size(i.payments) > 1))
459460                     then throw("only one payment can be attached")
460-                    else if ((pmt.amount != amount))
461-                        then throw("attached payment.amount is NOT matched passed amount argument")
461+                    else if ((pmt.amount != income))
462+                        then throw("attached payment.amount is NOT matched passed income argument")
462463                         else true
463464             }
464-        else if ((0 > amount))
465+        else if ((0 > income))
465466             then {
466467                 let baseBalance = assetBalance(this, baseAssetId)
467468                 let allowedAmount = fraction(topupMaxNegativePart, baseBalance, bothAssetMult)
468-                if ((-(amount) > allowedAmount))
469-                    then throw(("topup negative amount couldn't be greater than " + toString(allowedAmount)))
469+                if ((-(income) > allowedAmount))
470+                    then throw(("topup negative income couldn't be greater than " + toString(allowedAmount)))
470471                     else true
471472                 }
472-            else throw("zero amount is not allowed")
473+            else throw("zero income is not allowed")
473474     let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
474475     let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
475476     if ((toString(i.caller) != topUpManagerAddressStr))
476477         then failTopupManagerOnly(topUpManagerAddressStr)
477478         else if (!(valid))
478479             then throw("validation failed")
479480             else if ((topupIntervalInBlocks > (height - topUpLastHeight)))
480481                 then throw((("1 topup per " + toString(topupIntervalInBlocks)) + " blocks from the same address is allowed"))
481482                 else {
482-                    let price = genericCalcPrice(internalBaseAssetStr, baseAssetId, amount, shareAssetId, priceMult)._1
483+                    let price = genericCalcPrice(internalBaseAssetStr, baseAssetId, income, shareAssetId, priceMult)._1
483484                     let diffTuple = calcTotalLockedDiff("topup", "", internalBaseAssetStr, price, priceMult, 0, baseAssetId, shareAssetId)
484485                     let topupTotalDiff = diffTuple._1
485486                     let priceAthKEY = keyPriceATH(internalBaseAssetStr)
486487                     let prevPriceATH = valueOrElse(getInteger(this, priceAthKEY), 0)
487-                    ((((([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx), IntegerEntry(priceAthKEY, if ((price > prevPriceATH))
488+                    (((((([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx), IntegerEntry(priceAthKEY, if ((price > prevPriceATH))
488489                         then price
489-                        else prevPriceATH), IntegerEntry(topUpLastHeightKEY, height)] :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), topupTotalDiff)) :+ TopupMutexIntEntry(internalBaseAssetStr, 0)) :+ Burn(shareAssetId, topupTotalDiff[IdxTotalLockedInShare])) :+ Reissue(shareAssetId, -(topupTotalDiff[IdxTotalLockedOutShare]), true)) ++ (if ((0 > amount))
490-                        then [ScriptTransfer(i.caller, -(amount), baseAssetId)]
490+                        else prevPriceATH), IntegerEntry(topUpLastHeightKEY, height)] :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), topupTotalDiff)) :+ TopupMutexIntEntry(internalBaseAssetStr, 0)) :+ RemainingLimitsStringEntry(keyLimitsRemaining(internalBaseAssetStr), submitLimitsBaseMax, submitLimitsShareMax)) :+ Burn(shareAssetId, topupTotalDiff[IdxTotalLockedInShare])) :+ Reissue(shareAssetId, -(topupTotalDiff[IdxTotalLockedOutShare]), true)) ++ (if ((0 > income))
491+                        then [ScriptTransfer(i.caller, -(income), baseAssetId)]
491492                         else nil))
492493                     }
493494     }
494495 
495496 
496497 
497498 @Callable(i)
498499 func currentSysParamsREST (baseAssetStr) = {
499500     let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
500501     let price = sysStateTuple._1.value
501502     let decimalsMultPrice = sysStateTuple._2.value
502503     let baseAssetBalance = sysStateTuple._3.value
503504     let totalLockedBaseAmount = sysStateTuple._4.value
504505     let baseAssetBalanceWCO = sysStateTuple._5.value
505506     let shareEmission = sysStateTuple._6.value
506507     let currIterTotalInBaseAmount = sysStateTuple._7.value
507508     let currIterTotalInShareAmount = sysStateTuple._8.value
508509     let totalLockedOutBaseAmount = sysStateTuple._9.value
509510     let totalLockedOutShareAmount = sysStateTuple._10.value
510511     let decimalsMultBothAssets = sysStateTuple._11.value
511512     let priceATH = sysStateTuple._12.value
512-    let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceWCO), toString(shareEmission), toString(currIterTotalInBaseAmount), toString(currIterTotalInShareAmount), toString(totalLockedOutBaseAmount), toString(totalLockedOutShareAmount), toString(decimalsMultBothAssets), toString(priceATH), "endCurrentSysParamsREST"], SEP)
513+    let priceRecalculated = sysStateTuple._13.value
514+    let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceWCO), toString(shareEmission), toString(currIterTotalInBaseAmount), toString(currIterTotalInShareAmount), toString(totalLockedOutBaseAmount), toString(totalLockedOutShareAmount), toString(decimalsMultBothAssets), toString(priceATH), toString(priceRecalculated), "endCurrentSysParamsREST"], SEP)
513515     throw(restData)
514516     }
515517 
516518 
github/deemru/w8io/6500d08 
91.30 ms ◑