tx · Es5keHQxj8Temxf8TjGc9o6nuZjG1QDJmFBsCGDEc7FE

3NC9wWawxuFG6a3sZdfckGwoMeVhLFjZFwH:  -0.01400000 Waves

2021.03.30 15:01 [1460469] smart account 3NC9wWawxuFG6a3sZdfckGwoMeVhLFjZFwH > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Es5keHQxj8Temxf8TjGc9o6nuZjG1QDJmFBsCGDEc7FE",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1617105725176,
    "version": 1,
    "sender": "3NC9wWawxuFG6a3sZdfckGwoMeVhLFjZFwH",
    "senderPublicKey": "HoEvP2nFKMAsffQ9PUyAm6auWisyHgusY9HxDeMASrzZ",
    "proofs": [
        "3E8cmHTQFxHJgcEYkg4RoZXk6uYrPKTxZrFC7Zz61Wdnk9qTQC64tWaxHhXFcS62JVnXraLiTfKSGbj3Zdsf4yEc"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1460469,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: DVX22nRt1mjPq68jUi8X8J8fbnrfJexJP7uER6eTwRns
Next: BLbkqpPGTNExpoLzGNZ4nQxGbzkLbLes6u9Ca2VEq9hA

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]
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])
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)
333+    let priceAthVal = valueOrElse(getInteger(this, priceAthKEY), 0)
337334     let priceLastKEY = keyPriceLast(internalBaseAssetStr)
338-    let priceLast = valueOrElse(getInteger(this, priceLastKEY), 0)
339-    let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPrice)
340-    $Tuple13(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), IntegerEntry("priceLast", priceLast))
335+    let priceLastVal = valueOrElse(getInteger(this, priceLastKEY), 0)
336+    let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPriceVal)
337+    $Tuple13(IntegerEntry("price", sysState._1), 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("priceLast", priceLastVal))
341338     }
342339 
343340 
344341 @Callable(i)
345342 func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress,startPrice,topupIntervalInBlocks,topupMaxNegativePart,topupManagerAddress,submitLimitsBaseMax,submitLimitsBaseReset,submitLimitsShareMax,submitLimitsShareReset,adminAddress) = {
346343     let baseAssetId = fromBase58String(baseAssetStr)
347-    let decimals = value(assetInfo(baseAssetId)).decimals
348-    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)
349346     let decimalsMultPrice = ((100 * 1000) * 1000)
350347     let topupMaxNegativePercents = fraction(topupMaxNegativePart, 100, decimalsMultBothAssets)
351348     let baseAssetBalance = assetBalance(this, baseAssetId)
367364                                 then throw("invalid topupMaxNegativePart parameter")
368365                                 else {
369366                                     let shareInitAmount = convertBase2Share(baseAssetBalance, startPrice, decimalsMultPrice)
370-                                    let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, shareInitAmount, decimals, true)
367+                                    let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, shareInitAmount, bothAssetsDecimals, true)
371368                                     let shareAssetId = calculateAssetId(shareAssetIssueAction)
372369                                     let shareAssetStr = toBase58String(shareAssetId)
373370                                     let internalBaseAssetId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
374371                                     let internalBaseAssetStr = toString(internalBaseAssetId)
375-[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)]
376373                                     }
377374     }
378375 
379376 
380377 
381378 @Callable(i)
382-func shutdownPut (internalBaseAssetId) = {
379+func adminUpdateCfg (baseAssetStr,idxCfg,cfgVal) = {
380+    let cfgArray = readAssetCfgOrFail(baseAssetStr)
381+    nil
382+    }
383+
384+
385+
386+@Callable(i)
387+func shutdownSubmits (internalBaseAssetId) = {
383388     let internalBaseAssetIdStr = toString(internalBaseAssetId)
384389     let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
385390     let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
387392         then throw("invalid internalBaseAssetId")
388393         else if ((toString(i.caller) != shutdownManagerAddress))
389394             then throw("access denied")
390-            else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
395+            else [BooleanEntry(keyShutdownSubmitOperation(toString(internalBaseAssetId)), true)]
391396     }
392397 
393398 
398403     let inAmount = pmt.amount
399404     let inAssetId = value(pmt.assetId)
400405     let baseAssetStr = toBase58String(inAssetId)
401-    submit("P", i, inAmount, inAssetId, baseAssetStr)
406+    commonSubmit("P", i, inAmount, inAssetId, baseAssetStr)
402407     }
403408 
404409 
410415     let inAssetId = value(pmt.assetId)
411416     let shareAssetStr = toBase58String(inAssetId)
412417     let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
413-    submit("G", i, inAmount, inAssetId, baseAssetStr)
418+    commonSubmit("G", i, inAmount, inAssetId, baseAssetStr)
414419     }
415420 
416421 
417422 
418423 @Callable(i)
419-func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = execute("P", baseAssetStr, userAddressStr, submitTxIdStr)
424+func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = commonExecute("P", baseAssetStr, userAddressStr, submitTxIdStr)
420425 
421426 
422427 
423428 @Callable(i)
424-func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = execute("G", baseAssetStr, userAddressStr, submitTxIdStr)
429+func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = commonExecute("G", baseAssetStr, userAddressStr, submitTxIdStr)
425430 
426431 
427432 
438443 
439444 
440445 @Callable(i)
441-func topUpBalance (baseAssetStr,amount) = {
446+func topUpBalance (baseAssetStr,income) = {
442447     let baseAssetId = fromBase58String(baseAssetStr)
443448     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
444449     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
453458     let topUpCurrentIdxKEY = keyTopUpCurrentIdx(internalBaseAssetStr)
454459     let prevTopUpIdx = getIntOrFail(topUpCurrentIdxKEY)
455460     let currentTopUpIdx = (prevTopUpIdx + 1)
456-    let valid = if ((amount > 0))
461+    let valid = if ((income > 0))
457462         then {
458463             let pmt = value(i.payments[0])
459464             let pmtAssetId = value(pmt.assetId)
461466                 then throw("attached payment's asset id is NOT matched passed baseAssetStr")
462467                 else if ((size(i.payments) > 1))
463468                     then throw("only one payment can be attached")
464-                    else if ((pmt.amount != amount))
465-                        then throw("attached payment.amount is NOT matched passed amount argument")
469+                    else if ((pmt.amount != income))
470+                        then throw("attached payment.amount is NOT matched passed income argument")
466471                         else true
467472             }
468-        else if ((0 > amount))
473+        else if ((0 > income))
469474             then {
470475                 let baseBalance = assetBalance(this, baseAssetId)
471476                 let allowedAmount = fraction(topupMaxNegativePart, baseBalance, bothAssetMult)
472-                if ((-(amount) > allowedAmount))
473-                    then throw(("topup negative amount couldn't be greater than " + toString(allowedAmount)))
477+                if ((-(income) > allowedAmount))
478+                    then throw(("topup negative income couldn't be greater than " + toString(allowedAmount)))
474479                     else true
475480                 }
476-            else throw("zero amount is not allowed")
481+            else throw("zero income is not allowed")
477482     let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
478483     let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
479484     if ((toString(i.caller) != topUpManagerAddressStr))
483488             else if ((topupIntervalInBlocks > (height - topUpLastHeight)))
484489                 then throw((("1 topup per " + toString(topupIntervalInBlocks)) + " blocks from the same address is allowed"))
485490                 else {
486-                    let price = genericCalcPrice(internalBaseAssetStr, baseAssetId, amount, shareAssetId, priceMult)._1
491+                    let price = genericCalcPrice(internalBaseAssetStr, baseAssetId, income, shareAssetId, priceMult)._1
487492                     let diffTuple = calcTotalLockedDiff("topup", "", internalBaseAssetStr, price, priceMult, 0, baseAssetId, shareAssetId)
488493                     let topupTotalDiff = diffTuple._1
489494                     let priceAthKEY = keyPriceATH(internalBaseAssetStr)
490495                     let prevPriceATH = valueOrElse(getInteger(this, priceAthKEY), 0)
491496                     (((((([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx), IntegerEntry(priceAthKEY, if ((price > prevPriceATH))
492497                         then price
493-                        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 > amount))
494-                        then [ScriptTransfer(i.caller, -(amount), baseAssetId)]
498+                        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))
499+                        then [ScriptTransfer(i.caller, -(income), baseAssetId)]
495500                         else nil))
496501                     }
497502     }

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))
247244         then throw(((("baseAssetBalanceWCO < 0: baseAssetBalance=" + 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))
311308     let priceByTopUpId = getIntOrFail(keyPriceByTopUpIdx(internalBaseAssetStr, currTopUpIdx))
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)
333+    let priceAthVal = valueOrElse(getInteger(this, priceAthKEY), 0)
337334     let priceLastKEY = keyPriceLast(internalBaseAssetStr)
338-    let priceLast = valueOrElse(getInteger(this, priceLastKEY), 0)
339-    let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPrice)
340-    $Tuple13(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), IntegerEntry("priceLast", priceLast))
335+    let priceLastVal = valueOrElse(getInteger(this, priceLastKEY), 0)
336+    let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPriceVal)
337+    $Tuple13(IntegerEntry("price", sysState._1), 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("priceLast", priceLastVal))
341338     }
342339 
343340 
344341 @Callable(i)
345342 func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress,startPrice,topupIntervalInBlocks,topupMaxNegativePart,topupManagerAddress,submitLimitsBaseMax,submitLimitsBaseReset,submitLimitsShareMax,submitLimitsShareReset,adminAddress) = {
346343     let baseAssetId = fromBase58String(baseAssetStr)
347-    let decimals = value(assetInfo(baseAssetId)).decimals
348-    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)
349346     let decimalsMultPrice = ((100 * 1000) * 1000)
350347     let topupMaxNegativePercents = fraction(topupMaxNegativePart, 100, decimalsMultBothAssets)
351348     let baseAssetBalance = assetBalance(this, baseAssetId)
352349     if ((i.caller != this))
353350         then throw("permissions denied")
354351         else if ((baseAssetBalance == 0))
355352             then throw(((toString(this) + " must have any initial balance of ") + baseAssetStr))
356353             else if (isDefined(getString(this, keyAssetCfg(baseAssetStr))))
357354                 then throw((baseAssetStr + " has been already registered"))
358355                 else if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
359356                     then throw("invalid shutdownManagerAddress")
360357                     else if ((toString(addressFromStringValue(topupManagerAddress)) != topupManagerAddress))
361358                         then throw("invalid topupManagerAddress")
362359                         else if ((0 > getDelayinBlocks))
363360                             then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
364361                             else if (if ((0 >= topupMaxNegativePercents))
365362                                 then true
366363                                 else (topupMaxNegativePercents >= 99))
367364                                 then throw("invalid topupMaxNegativePart parameter")
368365                                 else {
369366                                     let shareInitAmount = convertBase2Share(baseAssetBalance, startPrice, decimalsMultPrice)
370-                                    let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, shareInitAmount, decimals, true)
367+                                    let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, shareInitAmount, bothAssetsDecimals, true)
371368                                     let shareAssetId = calculateAssetId(shareAssetIssueAction)
372369                                     let shareAssetStr = toBase58String(shareAssetId)
373370                                     let internalBaseAssetId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
374371                                     let internalBaseAssetStr = toString(internalBaseAssetId)
375-[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)]
376373                                     }
377374     }
378375 
379376 
380377 
381378 @Callable(i)
382-func shutdownPut (internalBaseAssetId) = {
379+func adminUpdateCfg (baseAssetStr,idxCfg,cfgVal) = {
380+    let cfgArray = readAssetCfgOrFail(baseAssetStr)
381+    nil
382+    }
383+
384+
385+
386+@Callable(i)
387+func shutdownSubmits (internalBaseAssetId) = {
383388     let internalBaseAssetIdStr = toString(internalBaseAssetId)
384389     let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
385390     let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
386391     if ((1 > size(baseAssetIdStr)))
387392         then throw("invalid internalBaseAssetId")
388393         else if ((toString(i.caller) != shutdownManagerAddress))
389394             then throw("access denied")
390-            else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
395+            else [BooleanEntry(keyShutdownSubmitOperation(toString(internalBaseAssetId)), true)]
391396     }
392397 
393398 
394399 
395400 @Callable(i)
396401 func submitPut () = {
397402     let pmt = value(i.payments[0])
398403     let inAmount = pmt.amount
399404     let inAssetId = value(pmt.assetId)
400405     let baseAssetStr = toBase58String(inAssetId)
401-    submit("P", i, inAmount, inAssetId, baseAssetStr)
406+    commonSubmit("P", i, inAmount, inAssetId, baseAssetStr)
402407     }
403408 
404409 
405410 
406411 @Callable(i)
407412 func submitGet () = {
408413     let pmt = value(i.payments[0])
409414     let inAmount = pmt.amount
410415     let inAssetId = value(pmt.assetId)
411416     let shareAssetStr = toBase58String(inAssetId)
412417     let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
413-    submit("G", i, inAmount, inAssetId, baseAssetStr)
418+    commonSubmit("G", i, inAmount, inAssetId, baseAssetStr)
414419     }
415420 
416421 
417422 
418423 @Callable(i)
419-func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = execute("P", baseAssetStr, userAddressStr, submitTxIdStr)
424+func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = commonExecute("P", baseAssetStr, userAddressStr, submitTxIdStr)
420425 
421426 
422427 
423428 @Callable(i)
424-func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = execute("G", baseAssetStr, userAddressStr, submitTxIdStr)
429+func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = commonExecute("G", baseAssetStr, userAddressStr, submitTxIdStr)
425430 
426431 
427432 
428433 @Callable(i)
429434 func operationsMutex (baseAssetStr) = {
430435     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
431436     let topUpManagerAddressStr = assetCfgArray[IdxCfgTopupManagerAddress]
432437     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
433438     if ((toString(i.caller) != topUpManagerAddressStr))
434439         then failTopupManagerOnly(topUpManagerAddressStr)
435440         else [TopupMutexIntEntry(internalBaseAssetStr, height)]
436441     }
437442 
438443 
439444 
440445 @Callable(i)
441-func topUpBalance (baseAssetStr,amount) = {
446+func topUpBalance (baseAssetStr,income) = {
442447     let baseAssetId = fromBase58String(baseAssetStr)
443448     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
444449     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
445450     let priceMult = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
446451     let bothAssetMult = parseIntValue(assetCfgArray[IdxCfgDecimalsMultBothAssets])
447452     let topupIntervalInBlocks = parseIntValue(assetCfgArray[IdxCfgTopupIntervalInBlocks])
448453     let topupMaxNegativePart = parseIntValue(assetCfgArray[IdxCfgTopupMaxNegativePart])
449454     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
450455     let topUpManagerAddressStr = assetCfgArray[IdxCfgTopupManagerAddress]
451456     let submitLimitsBaseMax = parseIntValue(assetCfgArray[IdxCfgSubmitLimitsBaseMax])
452457     let submitLimitsShareMax = parseIntValue(assetCfgArray[IdxCfgSubmitLimitsShareMax])
453458     let topUpCurrentIdxKEY = keyTopUpCurrentIdx(internalBaseAssetStr)
454459     let prevTopUpIdx = getIntOrFail(topUpCurrentIdxKEY)
455460     let currentTopUpIdx = (prevTopUpIdx + 1)
456-    let valid = if ((amount > 0))
461+    let valid = if ((income > 0))
457462         then {
458463             let pmt = value(i.payments[0])
459464             let pmtAssetId = value(pmt.assetId)
460465             if ((baseAssetId != pmtAssetId))
461466                 then throw("attached payment's asset id is NOT matched passed baseAssetStr")
462467                 else if ((size(i.payments) > 1))
463468                     then throw("only one payment can be attached")
464-                    else if ((pmt.amount != amount))
465-                        then throw("attached payment.amount is NOT matched passed amount argument")
469+                    else if ((pmt.amount != income))
470+                        then throw("attached payment.amount is NOT matched passed income argument")
466471                         else true
467472             }
468-        else if ((0 > amount))
473+        else if ((0 > income))
469474             then {
470475                 let baseBalance = assetBalance(this, baseAssetId)
471476                 let allowedAmount = fraction(topupMaxNegativePart, baseBalance, bothAssetMult)
472-                if ((-(amount) > allowedAmount))
473-                    then throw(("topup negative amount couldn't be greater than " + toString(allowedAmount)))
477+                if ((-(income) > allowedAmount))
478+                    then throw(("topup negative income couldn't be greater than " + toString(allowedAmount)))
474479                     else true
475480                 }
476-            else throw("zero amount is not allowed")
481+            else throw("zero income is not allowed")
477482     let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
478483     let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
479484     if ((toString(i.caller) != topUpManagerAddressStr))
480485         then failTopupManagerOnly(topUpManagerAddressStr)
481486         else if (!(valid))
482487             then throw("validation failed")
483488             else if ((topupIntervalInBlocks > (height - topUpLastHeight)))
484489                 then throw((("1 topup per " + toString(topupIntervalInBlocks)) + " blocks from the same address is allowed"))
485490                 else {
486-                    let price = genericCalcPrice(internalBaseAssetStr, baseAssetId, amount, shareAssetId, priceMult)._1
491+                    let price = genericCalcPrice(internalBaseAssetStr, baseAssetId, income, shareAssetId, priceMult)._1
487492                     let diffTuple = calcTotalLockedDiff("topup", "", internalBaseAssetStr, price, priceMult, 0, baseAssetId, shareAssetId)
488493                     let topupTotalDiff = diffTuple._1
489494                     let priceAthKEY = keyPriceATH(internalBaseAssetStr)
490495                     let prevPriceATH = valueOrElse(getInteger(this, priceAthKEY), 0)
491496                     (((((([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx), IntegerEntry(priceAthKEY, if ((price > prevPriceATH))
492497                         then price
493-                        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 > amount))
494-                        then [ScriptTransfer(i.caller, -(amount), baseAssetId)]
498+                        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))
499+                        then [ScriptTransfer(i.caller, -(income), baseAssetId)]
495500                         else nil))
496501                     }
497502     }
498503 
499504 
500505 
501506 @Callable(i)
502507 func currentSysParamsREST (baseAssetStr) = {
503508     let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
504509     let price = sysStateTuple._1.value
505510     let decimalsMultPrice = sysStateTuple._2.value
506511     let baseAssetBalance = sysStateTuple._3.value
507512     let totalLockedBaseAmount = sysStateTuple._4.value
508513     let baseAssetBalanceWCO = sysStateTuple._5.value
509514     let shareEmission = sysStateTuple._6.value
510515     let currIterTotalInBaseAmount = sysStateTuple._7.value
511516     let currIterTotalInShareAmount = sysStateTuple._8.value
512517     let totalLockedOutBaseAmount = sysStateTuple._9.value
513518     let totalLockedOutShareAmount = sysStateTuple._10.value
514519     let decimalsMultBothAssets = sysStateTuple._11.value
515520     let priceATH = sysStateTuple._12.value
516521     let priceLast = sysStateTuple._13.value
517522     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(priceLast), "endCurrentSysParamsREST"], SEP)
518523     throw(restData)
519524     }
520525 
521526 
github/deemru/w8io/873ac7e 
146.45 ms ◑