tx · DS9uDiyad2U7oTiENX4LPjXA1viCpPnQ1SYaHjf7gTix

3MpXZvJfzJX8By5CGBqv1DnfVrMFkffJkCs:  -0.01000000 Waves

2021.05.14 19:15 [1525571] smart account 3MpXZvJfzJX8By5CGBqv1DnfVrMFkffJkCs > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DS9uDiyad2U7oTiENX4LPjXA1viCpPnQ1SYaHjf7gTix",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1621008962128,
    "version": 1,
    "sender": "3MpXZvJfzJX8By5CGBqv1DnfVrMFkffJkCs",
    "senderPublicKey": "9WfBnw3wynZ1QZw2DADaa8cXN2V1fqUTUsbs7bQn6YCk",
    "proofs": [
        "hPFEd2admiBmXzy98ZbuiVXJTpLfrU3LTmJP5Y8sbqxUmmRgEiSWNRUCatBeqbPfFrzr3KUS4JiCYcyTcMsRnTp"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1525571,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 4 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "__"
5+
6+func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
7+
8+
9+func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
10+
11+
12+func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), ("No data for this.key=" + key))
13+
14+
15+func IntE (key,val) = IntegerEntry(key, val)
16+
17+
18+func StrE (key,val) = StringEntry(key, val)
19+
20+
21+func failExecuteGet (msg,baseAssetStr,userAddressStr,submitTxIdStr,operationType) = throw(((((((((msg + ": baseAsset=") + baseAssetStr) + " userAddress=") + userAddressStr) + " submitTxId=") + submitTxIdStr) + " operation=") + operationType))
22+
23+
24+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)))
25+
26+
27+func failTopupManagerOnly (topupManagerAddress) = throw((("opertion denied: only topUpManager=" + topupManagerAddress) + " can send such transactions"))
28+
29+
30+func convertShare2Base (shareAmount,price,priceMult) = fraction(shareAmount, price, priceMult)
31+
32+
33+func convertBase2Share (baseAmount,price,priceMult) = fraction(baseAmount, priceMult, price)
34+
35+
36+func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
37+
38+
39+func keyNextInternalAssetId () = "%s__nextInternalAssetId"
40+
41+
42+func keyPriceLast (internalBasetAssetStr) = ("%s%s%d__price__last__" + internalBasetAssetStr)
43+
44+
45+func keyPriceATH (internalBasetAssetStr) = ("%s%s%d__price__ath__" + internalBasetAssetStr)
46+
47+
48+func keyPriceByTopUpIdx (internalBaseAssetStr,topUpIdx) = makeString(["%s%s%d%d__price__byTopUpIdx", internalBaseAssetStr, toString(topUpIdx)], SEP)
49+
50+
51+func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
52+
53+
54+func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
55+
56+
57+func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
58+
59+
60+func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
61+
62+
63+func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
64+
65+
66+func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
67+
68+
69+func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
70+
71+
72+func keyShutdownSubmitOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__submit__" + internalBaseAssetStr)
73+
74+
75+func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
76+
77+
78+func keyTopUpCurrentIdx (internalBaseAssetStr) = ("%s%s%d__topup__currentIdx__" + internalBaseAssetStr)
79+
80+
81+func keyTopUpLastHeight (internalBasetAssetStr,sender) = makeString(["%s%s%s%d%s__topup__last__height", internalBasetAssetStr, sender], SEP)
82+
83+
84+func keyTopupMutext (internalBasetAssetStr) = ("%s%s%d__topup__mutex__" + internalBasetAssetStr)
85+
86+
87+func keyTopupLastTimestamp (internalBasetAssetStr) = ("%s%s%s%d__topup__last__timestamp__" + internalBasetAssetStr)
88+
89+
90+func keyTopupHistory (internalBasetAssetStr,topupIdx) = makeString(["%s%s%d%d__topup__history", internalBasetAssetStr, toString(topupIdx)], SEP)
91+
92+
93+func keyLimitsRemaining (internalBasetAssetStr) = ("%s%s%d__limits__remaining__" + internalBasetAssetStr)
94+
95+
96+let IdxCfgShareAssetId = 1
97+
98+let IdxCfgInternalBaseAsset = 2
99+
100+let IdxCfgDecimalsMultBothAssets = 3
101+
102+let IdxCfgDecimalsMultPrice = 4
103+
104+let IdxCfgGetDelayBlocks = 5
105+
106+let IdxCfgTopupIntervalInBlocks = 6
107+
108+let IdxCfgTopupMaxNegativePart = 7
109+
110+let IdxCfgTopupManagerAddress = 8
111+
112+let IdxCfgSubmitLimitsBaseMax = 9
113+
114+let IdxCfgSubmitLimitsBaseReset = 10
115+
116+let IdxCfgSubmitLimitsShareMax = 11
117+
118+let IdxCfgSubmitLimitsShareReset = 12
119+
120+let IdxCfgAdminAddress = 13
121+
122+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)
123+
124+
125+let IdxTotalLockedInShare = 1
126+
127+let IdxTotalLockedOutBase = 2
128+
129+let IdxTotalLockedInBase = 3
130+
131+let IdxTotalLockedOutShare = 4
132+
133+func dataTotalLocked (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = makeString(["%d%d%d%d", toString(inShareAmount), toString(outBaseAmount), toString(inBaseAmount), toString(outShareAmount)], SEP)
134+
135+
136+func dataTotalLockedInt (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = [-1, inShareAmount, outBaseAmount, inBaseAmount, outShareAmount]
137+
138+
139+func readTotalLocked (key) = {
140+    let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0, 0, 0)), SEP)
141+    dataTotalLockedInt(parseIntValue(totalLockedArray[IdxTotalLockedInShare]), parseIntValue(totalLockedArray[IdxTotalLockedOutBase]), parseIntValue(totalLockedArray[IdxTotalLockedInBase]), parseIntValue(totalLockedArray[IdxTotalLockedOutShare]))
142+    }
143+
144+
145+func calcTotalLockedDiff (direction,operationType,internalBaseAssetStr,price,priceMult,inAmount,baseAssetId,shareAssetId) = {
146+    let t = (direction + operationType)
147+    if ((t == "submitP"))
148+        then {
149+            let totalDiff = dataTotalLockedInt(0, 0, inAmount, 0)
150+            let userDiff = totalDiff
151+            $Tuple4(totalDiff, userDiff, 0, fromBase58String(""))
152+            }
153+        else if ((t == "submitG"))
154+            then {
155+                let totalDiff = dataTotalLockedInt(inAmount, 0, 0, 0)
156+                let userDiff = totalDiff
157+                $Tuple4(totalDiff, userDiff, 0, fromBase58String(""))
158+                }
159+            else if ((t == "executeP"))
160+                then {
161+                    let outAmount = convertBase2Share(inAmount, price, priceMult)
162+                    let totalDiff = dataTotalLockedInt(0, 0, 0, outAmount)
163+                    let userDiff = dataTotalLockedInt(0, 0, inAmount, 0)
164+                    $Tuple4(totalDiff, userDiff, outAmount, shareAssetId)
165+                    }
166+                else if ((t == "executeG"))
167+                    then {
168+                        let outAmount = convertShare2Base(inAmount, price, priceMult)
169+                        let totalDiff = dataTotalLockedInt(0, outAmount, 0, 0)
170+                        let userDiff = dataTotalLockedInt(inAmount, 0, 0, 0)
171+                        $Tuple4(totalDiff, userDiff, outAmount, baseAssetId)
172+                        }
173+                    else if ((t == "topup"))
174+                        then {
175+                            let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
176+                            let totalLockedInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
177+                            let totalLockedInShareAmount = totalLockedArray[IdxTotalLockedInShare]
178+                            let totalDiff = dataTotalLockedInt(totalLockedInShareAmount, (-1 * convertShare2Base(totalLockedInShareAmount, price, priceMult)), totalLockedInBaseAmount, (-1 * convertBase2Share(totalLockedInBaseAmount, price, priceMult)))
179+                            $Tuple4(totalDiff, nil, 0, fromBase58String(""))
180+                            }
181+                        else throw(("Unsupported Type " + t))
182+    }
183+
184+
185+func TotalLockedStringEntry (action,key,diff) = {
186+    func UPDATE (a,b) =     if ((action == "INCREMENT"))
187+        then (a + b)
188+        else if ((action == "DECREMENT"))
189+            then (a - b)
190+            else throw(("Unsupported action " + action))
191+
192+    let dataArray = readTotalLocked(key)
193+    StrE(key, dataTotalLocked(UPDATE(dataArray[IdxTotalLockedInShare], diff[IdxTotalLockedInShare]), UPDATE(dataArray[IdxTotalLockedOutBase], diff[IdxTotalLockedOutBase]), UPDATE(dataArray[IdxTotalLockedInBase], diff[IdxTotalLockedInBase]), UPDATE(dataArray[IdxTotalLockedOutShare], diff[IdxTotalLockedOutShare])))
194+    }
195+
196+
197+func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
198+
199+
200+let IdxOperStatus = 1
201+
202+let IdxOperInAmount = 2
203+
204+let IdxOperPrice = 3
205+
206+let IdxOperOutAmount = 4
207+
208+let IdxOperStartHeight = 5
209+
210+let IdxOperStartTimestamp = 6
211+
212+let IdxOperEndHeight = 7
213+
214+let IdxOperEndTimestamp = 8
215+
216+let IdxOperTopupUnlockIdx = 9
217+
218+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)
219+
220+
221+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))
222+
223+
224+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])
225+
226+
227+func readAssetCfgOrFail (baseAssetStr) = {
228+    let key = keyAssetCfg(baseAssetStr)
229+    split(getStringOrFail(key), SEP)
230+    }
231+
232+
233+let IdxLimitsRemainingBase = 1
234+
235+let IdxLimitsRemainingShare = 2
236+
237+func RemainingLimitsStringEntry (key,baseRemainingLimit,shareRemainingLimit) = StrE(key, makeString(["%d%d", toString(baseRemainingLimit), toString(shareRemainingLimit)], SEP))
238+
239+
240+func TopupMutexIntEntry (internalBaseAssetStr,acquiredHeight) = IntE(keyTopupMutext(internalBaseAssetStr), acquiredHeight)
241+
242+
243+func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultPrice) = {
244+    let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
245+    let totalLockedOutBaseAmount = totalLockedArray[IdxTotalLockedOutBase]
246+    let currIterTotalInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
247+    let baseAssetBalance = assetBalance(this, baseAssetId)
248+    let baseAssetBalanceWCO = (((baseAssetBalance + topUpBaseAmount) - currIterTotalInBaseAmount) - totalLockedOutBaseAmount)
249+    let totalLockedOutShareAmount = totalLockedArray[IdxTotalLockedOutShare]
250+    let currIterTotalInShareAmount = totalLockedArray[IdxTotalLockedInShare]
251+    let shareEmission = value(assetInfo(shareAssetId)).quantity
252+    if ((0 > baseAssetBalanceWCO))
253+        then throw(((("baseAssetBalanceWco < 0: baseAssettBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceWco=") + toString(baseAssetBalanceWCO)))
254+        else {
255+            let lastPrice = getIntOrFail(keyPriceLast(internalBaseAssetStr))
256+            let price = if ((shareEmission == 0))
257+                then lastPrice
258+                else fraction(baseAssetBalanceWCO, decimalsMultPrice, shareEmission)
259+            $Tuple9(price, baseAssetBalance, -1, baseAssetBalanceWCO, shareEmission, currIterTotalInBaseAmount, currIterTotalInShareAmount, totalLockedOutBaseAmount, totalLockedOutShareAmount)
260+            }
261+    }
262+
263+
264+func calcPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultPrice) = genericCalcPrice(internalBaseAssetStr, baseAssetId, 0, shareAssetId, decimalsMultPrice)
265+
266+
267+func commonSubmit (operationType,i,inAmount,inAssetId,baseAssetStr) = {
268+    let inAssetStr = toBase58String(inAssetId)
269+    let userAddressStr = toString(i.caller)
270+    let baseAssetId = fromBase58String(baseAssetStr)
271+    let cfgArray = readAssetCfgOrFail(baseAssetStr)
272+    let shareAssetStr = cfgArray[IdxCfgShareAssetId]
273+    let shareAssetId = fromBase58String(shareAssetStr)
274+    let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
275+    let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
276+    let limitsKEY = keyLimitsRemaining(internalBaseAssetStr)
277+    let limitsCfgArray = split(getStringOrFail(limitsKEY), SEP)
278+    let limitsRemainingBase = parseIntValue(limitsCfgArray[IdxLimitsRemainingBase])
279+    let limitsRemainingShare = parseIntValue(limitsCfgArray[IdxLimitsRemainingShare])
280+    let isSubmitBlocked = valueOrElse(getBoolean(this, keyShutdownSubmitOperation(internalBaseAssetStr)), false)
281+    if (isSubmitBlocked)
282+        then throw("submit operation is blocked")
283+        else {
284+            let operationsMutex = valueOrElse(getInteger(this, keyTopupMutext(internalBaseAssetStr)), 0)
285+            if (((operationsMutex + 60) > height))
286+                then throw("submit operations are blocked by topup manager")
287+                else {
288+                    let diffTuple = calcTotalLockedDiff("submit", operationType, internalBaseAssetStr, 0, 0, inAmount, baseAssetId, shareAssetId)
289+                    let limitsRemainingBaseNew = (limitsRemainingBase - diffTuple._2[IdxTotalLockedInBase])
290+                    let limitsRemainingShareNew = (limitsRemainingShare - diffTuple._2[IdxTotalLockedInShare])
291+                    if (if ((0 > limitsRemainingBaseNew))
292+                        then true
293+                        else (0 > limitsRemainingShareNew))
294+                        then failSubmitLimitsExceeds(limitsRemainingBase, limitsRemainingShare, limitsRemainingBaseNew, limitsRemainingShareNew)
295+                        else {
296+                            let topUpCurrentIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
297+                            ((([StrE(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))
298+                            }
299+                    }
300+            }
301+    }
302+
303+
304+func commonExecute (operationType,baseAssetStr,userAddressStr,submitTxIdStr) = {
305+    let userAddress = addressFromStringValue(userAddressStr)
306+    let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
307+    let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
308+    let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
309+    let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
310+    let baseAssetId = fromBase58String(baseAssetStr)
311+    let opKey = keyOperation(operationType, internalBaseAssetStr, userAddressStr, submitTxIdStr)
312+    let opArray = split(getStringOrFail(opKey), SEP)
313+    let status = opArray[IdxOperStatus]
314+    let inAmount = parseIntValue(opArray[IdxOperInAmount])
315+    let topupUnlockIdx = parseIntValue(opArray[IdxOperTopupUnlockIdx])
316+    let currTopUpIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
317+    let priceByTopUpId = getIntOrFail(keyPriceByTopUpIdx(internalBaseAssetStr, topupUnlockIdx))
318+    if ((status != "PENDING"))
319+        then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, submitTxIdStr, operationType)
320+        else if ((topupUnlockIdx > currTopUpIdx))
321+            then failExecuteGet(((("OperLock[" + toString(topupUnlockIdx)) + "] > ") + toString(currTopUpIdx)), baseAssetStr, userAddressStr, submitTxIdStr, operationType)
322+            else {
323+                let diffTuple = calcTotalLockedDiff("execute", operationType, internalBaseAssetStr, priceByTopUpId, decimalsMultPrice, inAmount, baseAssetId, shareAssetId)
324+                let outAmount = diffTuple._3
325+                let outTransferData = if ((diffTuple._4 == baseAssetId))
326+                    then [ScriptTransfer(userAddress, outAmount, baseAssetId)]
327+                    else [ScriptTransfer(userAddress, outAmount, shareAssetId)]
328+                (((outTransferData :+ StrE(opKey, dataOperationExecutionUpdate(opArray, "FINISHED", priceByTopUpId, outAmount))) :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), diffTuple._1)) :+ TotalLockedStringEntry("DECREMENT", keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), diffTuple._2))
329+                }
330+    }
331+
332+
333+func privateCurrentSysParamsREST (baseAssetStr) = {
334+    let baseAssetId = fromBase58String(baseAssetStr)
335+    let cfgArray = readAssetCfgOrFail(baseAssetStr)
336+    let shareAssetStr = cfgArray[IdxCfgShareAssetId]
337+    let shareAssetId = fromBase58String(shareAssetStr)
338+    let decimalsMultBothAssetsVal = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
339+    let decimalsMultPriceVal = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
340+    let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
341+    let priceAthKEY = keyPriceATH(internalBaseAssetStr)
342+    let priceAthVal = valueOrElse(getInteger(this, priceAthKEY), 0)
343+    let priceLastKEY = keyPriceLast(internalBaseAssetStr)
344+    let priceLastVal = valueOrElse(getInteger(this, priceLastKEY), 0)
345+    let topupLastTimeKEY = keyTopupLastTimestamp(internalBaseAssetStr)
346+    let topupLastTimeVal = valueOrElse(getInteger(this, topupLastTimeKEY), 0)
347+    let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPriceVal)
348+    $Tuple14(IntE("price", priceLastVal), IntE("decimalsMultPrice", decimalsMultPriceVal), IntE("baseAssetBalance", sysState._2), IntE("-1", sysState._3), IntE("baseAssetBalanceWCO", sysState._4), IntE("shareEmission", sysState._5), IntE("currIterTotalInBaseAmount", sysState._6), IntE("currIterTotalInShareAmount", sysState._7), IntE("totalLockedOutBaseAmount", sysState._8), IntE("totalLockedOutShareAmount", sysState._9), IntE("decimalsMultBothAssets", decimalsMultBothAssetsVal), IntE("priceATH", priceAthVal), IntE("priceRecalculated", sysState._1), IntE("topupLastTimestamp", topupLastTimeVal))
349+    }
350+
351+
352+@Callable(i)
353+func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress,startPrice,topupIntervalInBlocks,topupMaxNegativePart,topupManagerAddress,submitLimitsBaseMax,submitLimitsBaseReset,submitLimitsShareMax,submitLimitsShareReset,adminAddress) = {
354+    let baseAssetId = fromBase58String(baseAssetStr)
355+    let bothAssetsDecimals = value(assetInfo(baseAssetId)).decimals
356+    let decimalsMultBothAssets = pow(10, 0, bothAssetsDecimals, 0, 0, DOWN)
357+    let decimalsMultPrice = ((100 * 1000) * 1000)
358+    let topupMaxNegativePercents = fraction(topupMaxNegativePart, 100, decimalsMultBothAssets)
359+    let baseAssetBalance = assetBalance(this, baseAssetId)
360+    if ((i.caller != this))
361+        then throw("permissions denied")
362+        else if ((baseAssetBalance == 0))
363+            then throw(((toString(this) + " must have any initial balance of ") + baseAssetStr))
364+            else if (isDefined(getString(this, keyAssetCfg(baseAssetStr))))
365+                then throw((baseAssetStr + " has been already registered"))
366+                else if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
367+                    then throw("invalid shutdownManagerAddress")
368+                    else if ((toString(addressFromStringValue(topupManagerAddress)) != topupManagerAddress))
369+                        then throw("invalid topupManagerAddress")
370+                        else if ((0 > getDelayinBlocks))
371+                            then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
372+                            else if (if ((0 >= topupMaxNegativePercents))
373+                                then true
374+                                else (topupMaxNegativePercents >= 99))
375+                                then throw("invalid topupMaxNegativePart parameter")
376+                                else {
377+                                    let shareInitAmount = convertBase2Share(baseAssetBalance, startPrice, decimalsMultPrice)
378+                                    let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, shareInitAmount, bothAssetsDecimals, true)
379+                                    let shareAssetId = calculateAssetId(shareAssetIssueAction)
380+                                    let shareAssetStr = toBase58String(shareAssetId)
381+                                    let internalBaseAssetId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
382+                                    let internalBaseAssetStr = toString(internalBaseAssetId)
383+[StrE(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks, topupIntervalInBlocks, topupMaxNegativePart, topupManagerAddress, submitLimitsBaseMax, submitLimitsBaseReset, submitLimitsShareMax, submitLimitsShareReset, adminAddress)), StrE(keyMappingsInternal2baseAssetId(internalBaseAssetId), baseAssetStr), StrE(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StrE(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StrE(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownSubmitOperation(internalBaseAssetStr), false), StrE(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntE(keyNextInternalAssetId(), (internalBaseAssetId + 1)), IntE(keyPriceLast(internalBaseAssetStr), startPrice), IntE(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), IntE(keyTopUpCurrentIdx(internalBaseAssetStr), 0), RemainingLimitsStringEntry(keyLimitsRemaining(internalBaseAssetStr), submitLimitsBaseMax, submitLimitsShareMax), shareAssetIssueAction, ScriptTransfer(addressFromStringValue(topupManagerAddress), shareInitAmount, shareAssetId)]
384+                                    }
385+    }
386+
387+
388+
389+@Callable(i)
390+func shutdownSubmits (internalBaseAssetId) = {
391+    let internalBaseAssetIdStr = toString(internalBaseAssetId)
392+    let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
393+    let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
394+    if ((1 > size(baseAssetIdStr)))
395+        then throw("invalid internalBaseAssetId")
396+        else if ((toString(i.caller) != shutdownManagerAddress))
397+            then throw("access denied")
398+            else [BooleanEntry(keyShutdownSubmitOperation(toString(internalBaseAssetId)), true)]
399+    }
400+
401+
402+
403+@Callable(i)
404+func submitPut () = {
405+    let pmt = value(i.payments[0])
406+    let inAmount = pmt.amount
407+    let inAssetId = value(pmt.assetId)
408+    let baseAssetStr = toBase58String(inAssetId)
409+    commonSubmit("P", i, inAmount, inAssetId, baseAssetStr)
410+    }
411+
412+
413+
414+@Callable(i)
415+func submitGet () = {
416+    let pmt = value(i.payments[0])
417+    let inAmount = pmt.amount
418+    let inAssetId = value(pmt.assetId)
419+    let shareAssetStr = toBase58String(inAssetId)
420+    let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
421+    commonSubmit("G", i, inAmount, inAssetId, baseAssetStr)
422+    }
423+
424+
425+
426+@Callable(i)
427+func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = commonExecute("P", baseAssetStr, userAddressStr, submitTxIdStr)
428+
429+
430+
431+@Callable(i)
432+func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = commonExecute("G", baseAssetStr, userAddressStr, submitTxIdStr)
433+
434+
435+
436+@Callable(i)
437+func operationsMutex (baseAssetStr) = {
438+    let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
439+    let topUpManagerAddressStr = assetCfgArray[IdxCfgTopupManagerAddress]
440+    let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
441+    if ((toString(i.caller) != topUpManagerAddressStr))
442+        then failTopupManagerOnly(topUpManagerAddressStr)
443+        else [TopupMutexIntEntry(internalBaseAssetStr, height)]
444+    }
445+
446+
447+
448+@Callable(i)
449+func topUpBalance (baseAssetStr,income) = {
450+    let baseAssetId = fromBase58String(baseAssetStr)
451+    let cfg = readAssetCfgOrFail(baseAssetStr)
452+    let shareAssetId = fromBase58String(cfg[IdxCfgShareAssetId])
453+    let priceMult = parseIntValue(cfg[IdxCfgDecimalsMultPrice])
454+    let bothAssetMult = parseIntValue(cfg[IdxCfgDecimalsMultBothAssets])
455+    let topupIntervalInBlocks = parseIntValue(cfg[IdxCfgTopupIntervalInBlocks])
456+    let topupMaxNegativePart = parseIntValue(cfg[IdxCfgTopupMaxNegativePart])
457+    let internalBaseAssetStr = cfg[IdxCfgInternalBaseAsset]
458+    let topUpManagerAddressStr = cfg[IdxCfgTopupManagerAddress]
459+    let submitLimitsBaseMax = parseIntValue(cfg[IdxCfgSubmitLimitsBaseMax])
460+    let submitLimitsShareMax = parseIntValue(cfg[IdxCfgSubmitLimitsShareMax])
461+    let topUpCurrentIdxKEY = keyTopUpCurrentIdx(internalBaseAssetStr)
462+    let prevTopUpIdx = getIntOrFail(topUpCurrentIdxKEY)
463+    let currentTopUpIdx = (prevTopUpIdx + 1)
464+    let valid = if ((income > 0))
465+        then {
466+            let pmt = value(i.payments[0])
467+            let pmtAssetId = value(pmt.assetId)
468+            if ((baseAssetId != pmtAssetId))
469+                then throw("attached payment's asset id is NOT matched passed baseAssetStr")
470+                else if ((size(i.payments) > 1))
471+                    then throw("only one payment can be attached")
472+                    else if ((pmt.amount != income))
473+                        then throw("attached payment.amount is NOT matched passed income argument")
474+                        else true
475+            }
476+        else if ((0 > income))
477+            then {
478+                let baseBalance = assetBalance(this, baseAssetId)
479+                let allowedAmount = fraction(topupMaxNegativePart, baseBalance, bothAssetMult)
480+                if ((-(income) > allowedAmount))
481+                    then throw(("topup negative income couldn't be greater than " + toString(allowedAmount)))
482+                    else true
483+                }
484+            else throw("zero income is not allowed")
485+    let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
486+    let topUpLastHeight = (height - 100)
487+    if ((toString(i.caller) != topUpManagerAddressStr))
488+        then failTopupManagerOnly(topUpManagerAddressStr)
489+        else if (!(valid))
490+            then throw("validation failed")
491+            else if ((topupIntervalInBlocks > (height - topUpLastHeight)))
492+                then throw((("1 topup per " + toString(topupIntervalInBlocks)) + " blocks from the same address is allowed"))
493+                else {
494+                    let price = genericCalcPrice(internalBaseAssetStr, baseAssetId, income, shareAssetId, priceMult)._1
495+                    let diffTuple = calcTotalLockedDiff("topup", "", internalBaseAssetStr, price, priceMult, 0, baseAssetId, shareAssetId)
496+                    let topupTotalDiff = diffTuple._1
497+                    let priceAthKEY = keyPriceATH(internalBaseAssetStr)
498+                    let prevPriceATH = valueOrElse(getInteger(this, priceAthKEY), 0)
499+                    ((((((([IntE(keyPriceLast(internalBaseAssetStr), price), IntE(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntE(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntE(topUpCurrentIdxKEY, currentTopUpIdx), IntE(priceAthKEY, if ((price > prevPriceATH))
500+                        then price
501+                        else prevPriceATH), IntE(topUpLastHeightKEY, height)] :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), topupTotalDiff)) :+ TopupMutexIntEntry(internalBaseAssetStr, 0)) :+ IntE(keyTopupLastTimestamp(internalBaseAssetStr), lastBlock.timestamp)) :+ RemainingLimitsStringEntry(keyLimitsRemaining(internalBaseAssetStr), submitLimitsBaseMax, submitLimitsShareMax)) :+ Burn(shareAssetId, topupTotalDiff[IdxTotalLockedInShare])) :+ Reissue(shareAssetId, -(topupTotalDiff[IdxTotalLockedOutShare]), true)) ++ (if ((0 > income))
502+                        then [ScriptTransfer(i.caller, -(income), baseAssetId)]
503+                        else nil))
504+                    }
505+    }
506+
507+
508+
509+@Callable(i)
510+func currentSysParamsREST (baseAssetStr) = {
511+    let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
512+    let price = sysStateTuple._1.value
513+    let decimalsMultPrice = sysStateTuple._2.value
514+    let baseAssetBalance = sysStateTuple._3.value
515+    let totalLockedBaseAmount = sysStateTuple._4.value
516+    let baseAssetBalanceWCO = sysStateTuple._5.value
517+    let shareEmission = sysStateTuple._6.value
518+    let currIterTotalInBaseAmount = sysStateTuple._7.value
519+    let currIterTotalInShareAmount = sysStateTuple._8.value
520+    let totalLockedOutBaseAmount = sysStateTuple._9.value
521+    let totalLockedOutShareAmount = sysStateTuple._10.value
522+    let decimalsMultBothAssets = sysStateTuple._11.value
523+    let priceATH = sysStateTuple._12.value
524+    let priceRecalculated = sysStateTuple._13.value
525+    let topupLastTime = sysStateTuple._14.value
526+    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), toString(topupLastTime), "endCurrentSysParamsREST"], SEP)
527+    throw(restData)
528+    }
529+
530+
github/deemru/w8io/026f985 
52.42 ms ◑