w8 · tx · D5q···Fu3

tx · D5qL8uwXT65K9o4RXtxp9o95sGfhiX271E3mpZscCFu3

3MskRKYtZsMmEnqKt1ikeiR3u2tXy4NL8CM:  -0.01000000 Waves

2021.03.22 12:17 [1448762] smart account 3MskRKYtZsMmEnqKt1ikeiR3u2tXy4NL8CM > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "D5qL8uwXT65K9o4RXtxp9o95sGfhiX271E3mpZscCFu3",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1616404673084,
    "version": 1,
    "sender": "3MskRKYtZsMmEnqKt1ikeiR3u2tXy4NL8CM",
    "senderPublicKey": "AFXqY7iZrKsLJ2hiq5JKA3UGFsaN7QCXUuaK4Bpzswqg",
    "proofs": [
        "5xifx1XPcK1iL4ceJE4gs73D6ZCmZZhLP4kJTEiTDNUWvUTMrQnqyAzZPwFWYwPvtmEzfFNSjquTVg8NAHEjaLug"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1448762,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 
Old New Differences
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 failExecuteGet (msg,baseAssetStr,userAddressStr,submitTxIdStr,operationType) = throw(((((((((msg + ": baseAssetStr=") + baseAssetStr) + " userAddressStr=") + userAddressStr) + " submitTxIdStr=") + submitTxIdStr) + " operationType=") + operationType))
16 + 
17 + 
18 + func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
19 + 
20 + 
21 + func keyNextInternalAssetId () = "%s__nextInternalAssetId"
22 + 
23 + 
24 + func keyPriceLast (internalBasetAssetStr) = ("%s%s%d__price__last__" + internalBasetAssetStr)
25 + 
26 + 
27 + func keyPriceByTopUpIdx (internalBaseAssetStr,topUpIdx) = makeString(["%s%s%d%d__price__byTopUpIdx", internalBaseAssetStr, toString(topUpIdx)], SEP)
28 + 
29 + 
30 + func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
31 + 
32 + 
33 + func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
34 + 
35 + 
36 + func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
37 + 
38 + 
39 + func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
40 + 
41 + 
42 + func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
43 + 
44 + 
45 + func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
46 + 
47 + 
48 + func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
49 + 
50 + 
51 + func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
52 + 
53 + 
54 + func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
55 + 
56 + 
57 + func keyTopUpCurrentIdx (internalBaseAssetStr) = ("%s%s%d__topup__currentIdx__" + internalBaseAssetStr)
58 + 
59 + 
60 + let IdxCfgShareAssetId = 1
61 + 
62 + let IdxCfgInternalBaseAsset = 2
63 + 
64 + let IdxCfgDecimalsMultBothAssets = 3
65 + 
66 + let IdxCfgDecimalsMultPrice = 4
67 + 
68 + let IdxCfgGetDelayBlocks = 5
69 + 
70 + func dataAssetCfg (shareAssetStr,internalBaseAssetStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks) = makeString(["%s%d%d%d%d", shareAssetStr, internalBaseAssetStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks)], SEP)
71 + 
72 + 
73 + let IdxTotalLockedInShare = 1
74 + 
75 + let IdxTotalLockedOutBase = 2
76 + 
77 + let IdxTotalLockedInBase = 3
78 + 
79 + let IdxTotalLockedOutShare = 4
80 + 
81 + func dataTotalLocked (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = makeString(["%d%d%d%d", toString(inShareAmount), toString(outBaseAmount), toString(inBaseAmount), toString(outShareAmount)], SEP)
82 + 
83 + 
84 + func dataTotalLockedInt (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = [-1, inShareAmount, outBaseAmount, inBaseAmount, outShareAmount]
85 + 
86 + 
87 + func readTotalLocked (key) = {
88 +     let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0, 0, 0)), SEP)
89 +     dataTotalLockedInt(parseIntValue(totalLockedArray[IdxTotalLockedInShare]), parseIntValue(totalLockedArray[IdxTotalLockedOutBase]), parseIntValue(totalLockedArray[IdxTotalLockedInBase]), parseIntValue(totalLockedArray[IdxTotalLockedOutShare]))
90 +     }
91 + 
92 + 
93 + func calcLockedAmountsDiff (operationType,inOperationAmount,outOperationAmount) = if ((operationType == "P"))
94 +     then dataTotalLockedInt(0, 0, inOperationAmount, outOperationAmount)
95 +     else if ((operationType == "G"))
96 +         then dataTotalLockedInt(inOperationAmount, outOperationAmount, 0, 0)
97 +         else throw(("Unsupported operationType " + operationType))
98 + 
99 + 
100 + func updateTotalLocked (action,internalBaseAssetStr,userAddress,lockedAmountsDiff) = {
101 +     func UPDATE (a,b) =     if ((action == "INCREMENT"))
102 +         then (a + b)
103 +         else if ((action == "DECREMENT"))
104 +             then (a - b)
105 +             else throw(("Unsupported action " + action))
106 + 
107 +     func TotalLockedStringEntry (key) =     {
108 +         let dataArray = readTotalLocked(key)
109 +         StringEntry(key, dataTotalLocked(UPDATE(dataArray[IdxTotalLockedInShare], lockedAmountsDiff[IdxTotalLockedInShare]), UPDATE(dataArray[IdxTotalLockedOutBase], lockedAmountsDiff[IdxTotalLockedOutBase]), UPDATE(dataArray[IdxTotalLockedInBase], lockedAmountsDiff[IdxTotalLockedInBase]), UPDATE(dataArray[IdxTotalLockedOutShare], lockedAmountsDiff[IdxTotalLockedOutShare])))
110 +         }
111 + 
112 +     ([TotalLockedStringEntry(keyTotalLocked(internalBaseAssetStr))] ++ (if ((userAddress != ""))
113 +         then [TotalLockedStringEntry(keyTotalLockedByUser(internalBaseAssetStr, userAddress))]
114 +         else nil))
115 +     }
116 + 
117 + 
118 + func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
119 + 
120 + 
121 + let IdxOperStatus = 1
122 + 
123 + let IdxOperInAmount = 2
124 + 
125 + let IdxOperPrice = 3
126 + 
127 + let IdxOperOutAmount = 4
128 + 
129 + let IdxOperStartHeight = 5
130 + 
131 + let IdxOperStartTimestamp = 6
132 + 
133 + let IdxOperEndHeight = 7
134 + 
135 + let IdxOperEndTimestamp = 8
136 + 
137 + let IdxOperLock = 9
138 + 
139 + 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)
140 + 
141 + 
142 + func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp,lock) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp), toString(lock))
143 + 
144 + 
145 + func dataOperationExecutionUpdate (currOperArray,newStatus,newEndTimestamp) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], currOperArray[IdxOperPrice], currOperArray[IdxOperOutAmount], currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], currOperArray[IdxOperEndHeight], toString(newEndTimestamp), currOperArray[IdxOperLock])
146 + 
147 + 
148 + func readAssetCfgOrFail (baseAssetStr) = {
149 +     let key = keyAssetCfg(baseAssetStr)
150 +     split(getStringOrFail(key), SEP)
151 +     }
152 + 
153 + 
154 + func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultPrice) = {
155 +     let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
156 +     let totalLockedOutBaseAmount = totalLockedArray[IdxTotalLockedOutBase]
157 +     let totalLockedInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
158 +     let baseAssetBalance = assetBalance(this, baseAssetId)
159 +     let baseAssetBalanceCALC = (((baseAssetBalance + topUpBaseAmount) - totalLockedInBaseAmount) - totalLockedOutBaseAmount)
160 +     let totalLockedOutShareAmount = totalLockedArray[IdxTotalLockedOutShare]
161 +     let totalLockedInShareAmount = totalLockedArray[IdxTotalLockedInShare]
162 +     let shareEmission = value(assetInfo(shareAssetId)).quantity
163 +     let shareEmissionCALC = (shareEmission + totalLockedOutShareAmount)
164 +     if ((0 > baseAssetBalanceCALC))
165 +         then throw(((("baseAssetBalanceCALC < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceCALC=") + toString(baseAssetBalanceCALC)))
166 +         else {
167 +             let price = if ((shareEmission == 0))
168 +                 then (2 * decimalsMultPrice)
169 +                 else fraction(baseAssetBalanceCALC, decimalsMultPrice, shareEmissionCALC)
170 +             $Tuple5(price, baseAssetBalance, totalLockedOutBaseAmount, baseAssetBalanceCALC, shareEmission)
171 +             }
172 +     }
173 + 
174 + 
175 + func calcPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultPrice) = genericCalcPrice(internalBaseAssetStr, baseAssetId, 0, shareAssetId, decimalsMultPrice)
176 + 
177 + 
178 + func moveTotalLocked (internalBaseAssetStr,price,shareAssetId,decimalsMultPrice) = {
179 +     let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
180 +     let totalLockedInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
181 +     let totalLockedInShareAmount = totalLockedArray[IdxTotalLockedInShare]
182 +     let lockedAmountsDiff = dataTotalLockedInt(-(totalLockedInShareAmount), fraction(totalLockedInShareAmount, price, decimalsMultPrice), -(totalLockedInBaseAmount), fraction(totalLockedInBaseAmount, decimalsMultPrice, price))
183 +     (updateTotalLocked("INCREMENT", internalBaseAssetStr, "", lockedAmountsDiff) :+ Burn(shareAssetId, totalLockedInShareAmount))
184 +     }
185 + 
186 + 
187 + func submit (operationType,i,inAmount,inAssetId,baseAssetStr) = {
188 +     let inAssetStr = toBase58String(inAssetId)
189 +     let userAddressStr = toString(i.caller)
190 +     let baseAssetId = fromBase58String(baseAssetStr)
191 +     let cfgArray = readAssetCfgOrFail(baseAssetStr)
192 +     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
193 +     let shareAssetId = fromBase58String(shareAssetStr)
194 +     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
195 +     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
196 +     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
197 +     let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
198 +     if (isPutBlocked)
199 +         then throw("put operation is blocked")
200 +         else {
201 +             let topUpCurrentIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
202 +             let lockedAmountsDiff = calcLockedAmountsDiff(operationType, inAmount, 0)
203 +             ([StringEntry(keyOperation(operationType, internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("PENDING", inAmount, 0, 0, height, lastBlock.timestamp, 0, 0, (topUpCurrentIdx + 1)))] ++ updateTotalLocked("INCREMENT", internalBaseAssetStr, userAddressStr, lockedAmountsDiff))
204 +             }
205 +     }
206 + 
207 + 
208 + func execute (operationType,baseAssetStr,userAddressStr,submitTxIdStr) = {
209 +     let userAddress = addressFromStringValue(userAddressStr)
210 +     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
211 +     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
212 +     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
213 +     let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
214 +     let baseAssetId = fromBase58String(baseAssetStr)
215 +     let operationKey = keyOperation(operationType, internalBaseAssetStr, userAddressStr, submitTxIdStr)
216 +     let operationArray = split(getStringOrFail(operationKey), SEP)
217 +     let status = operationArray[IdxOperStatus]
218 +     let inAmount = parseIntValue(operationArray[IdxOperInAmount])
219 +     let operLock = parseIntValue(operationArray[IdxOperLock])
220 +     let currTopUpIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
221 +     let priceByTopUpId = getIntOrFail(keyPriceByTopUpIdx(internalBaseAssetStr, currTopUpIdx))
222 +     let outAmount = if ((operationType == "P"))
223 +         then fraction(inAmount, decimalsMultPrice, priceByTopUpId)
224 +         else if ((operationType == "G"))
225 +             then fraction(inAmount, priceByTopUpId, decimalsMultPrice)
226 +             else throw(("Unsupported operation type " + operationType))
227 +     let lockedAmountsDiff = calcLockedAmountsDiff(operationType, inAmount, outAmount)
228 +     if ((status != "PENDING"))
229 +         then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, submitTxIdStr, operationType)
230 +         else if ((operLock > currTopUpIdx))
231 +             then failExecuteGet(((("OperLock[" + toString(operLock)) + "] > ") + toString(currTopUpIdx)), baseAssetStr, userAddressStr, submitTxIdStr, operationType)
232 +             else {
233 +                 let outTransfer = if ((operationType == "P"))
234 +                     then [Reissue(shareAssetId, outAmount, true), ScriptTransfer(userAddress, outAmount, shareAssetId)]
235 +                     else if ((operationType == "G"))
236 +                         then [ScriptTransfer(userAddress, outAmount, baseAssetId)]
237 +                         else throw(("Unsupported operation type " + operationType))
238 +                 (([StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", lastBlock.timestamp))] ++ outTransfer) ++ updateTotalLocked("DECREMENT", internalBaseAssetStr, userAddressStr, lockedAmountsDiff))
239 +                 }
240 +     }
241 + 
242 + 
243 + func privateCurrentSysParamsREST (baseAssetStr) = {
244 +     let baseAssetId = fromBase58String(baseAssetStr)
245 +     let cfgArray = readAssetCfgOrFail(baseAssetStr)
246 +     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
247 +     let shareAssetId = fromBase58String(shareAssetStr)
248 +     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
249 +     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
250 +     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
251 +     let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPrice)
252 +     $Tuple6(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("totalLockedBaseAmount", sysState._3), IntegerEntry("baseAssetBalanceConsideringLock", sysState._4), IntegerEntry("shareEmission", sysState._5))
253 +     }
254 + 
255 + 
256 + @Callable(i)
257 + func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress,startPrice) = {
258 +     let baseAssetId = fromBase58String(baseAssetStr)
259 +     let decimals = value(assetInfo(baseAssetId)).decimals
260 +     if ((i.caller != this))
261 +         then throw("permissions denied")
262 +         else if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
263 +             then throw("invalid shutdownManagerAddress")
264 +             else if ((0 > getDelayinBlocks))
265 +                 then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
266 +                 else {
267 +                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, 1, decimals, true)
268 +                     let shareAssetId = calculateAssetId(shareAssetIssueAction)
269 +                     let shareAssetStr = toBase58String(shareAssetId)
270 +                     let decimalsMultPrice = ((100 * 1000) * 1000)
271 +                     let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
272 +                     let internalBaseAssettId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
273 +                     let internalBaseAssetStr = toString(internalBaseAssettId)
274 + [StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks)), StringEntry(keyMappingsInternal2baseAssetId(internalBaseAssettId), baseAssetStr), StringEntry(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StringEntry(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StringEntry(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownPutOperation(internalBaseAssetStr), false), StringEntry(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntegerEntry(keyNextInternalAssetId(), (internalBaseAssettId + 1)), IntegerEntry(keyPriceLast(internalBaseAssetStr), startPrice), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), IntegerEntry(keyTopUpCurrentIdx(internalBaseAssetStr), 0), shareAssetIssueAction, Burn(shareAssetId, 1)]
275 +                     }
276 +     }
277 + 
278 + 
279 + 
280 + @Callable(i)
281 + func shutdownPut (internalBaseAssetId) = {
282 +     let internalBaseAssetIdStr = toString(internalBaseAssetId)
283 +     let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
284 +     let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
285 +     if ((1 > size(baseAssetIdStr)))
286 +         then throw("invalid internalBaseAssetId")
287 +         else if ((toString(i.caller) != shutdownManagerAddress))
288 +             then throw("access denied")
289 +             else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
290 +     }
291 + 
292 + 
293 + 
294 + @Callable(i)
295 + func submitPut () = {
296 +     let pmt = value(i.payments[0])
297 +     let inAmount = pmt.amount
298 +     let inAssetId = value(pmt.assetId)
299 +     let baseAssetStr = toBase58String(inAssetId)
300 +     submit("P", i, inAmount, inAssetId, baseAssetStr)
301 +     }
302 + 
303 + 
304 + 
305 + @Callable(i)
306 + func submitGet () = {
307 +     let pmt = value(i.payments[0])
308 +     let inAmount = pmt.amount
309 +     let inAssetId = value(pmt.assetId)
310 +     let shareAssetStr = toBase58String(inAssetId)
311 +     let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
312 +     submit("G", i, inAmount, inAssetId, baseAssetStr)
313 +     }
314 + 
315 + 
316 + 
317 + @Callable(i)
318 + func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = execute("P", baseAssetStr, userAddressStr, submitTxIdStr)
319 + 
320 + 
321 + 
322 + @Callable(i)
323 + func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = execute("G", baseAssetStr, userAddressStr, submitTxIdStr)
324 + 
325 + 
326 + 
327 + @Callable(i)
328 + func topUpBalance (baseAssetStr,amount) = {
329 +     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
330 +     let pmt = value(i.payments[0])
331 +     let pmtAssetId = value(pmt.assetId)
332 +     let pmtAssetStr = toBase58String(pmtAssetId)
333 +     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
334 +     let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
335 +     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
336 +     let topUpCurrentIdxKEY = keyTopUpCurrentIdx(internalBaseAssetStr)
337 +     let prevTopUpIdx = getIntOrFail(topUpCurrentIdxKEY)
338 +     let currentTopUpIdx = (prevTopUpIdx + 1)
339 +     if ((baseAssetStr != pmtAssetStr))
340 +         then throw("attached payment's asset id is NOT matched passed baseAssetStr")
341 +         else if ((size(i.payments) > 1))
342 +             then throw("only one payment can be attached")
343 +             else {
344 +                 let price = genericCalcPrice(internalBaseAssetStr, pmtAssetId, pmt.amount, shareAssetId, decimalsMultPrice)._1
345 +                 ([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx)] ++ moveTotalLocked(internalBaseAssetStr, price, shareAssetId, decimalsMultPrice))
346 +                 }
347 +     }
348 + 
349 + 
350 + 
351 + @Callable(i)
352 + func currentSysParamsREST (baseAssetStr) = {
353 +     let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
354 +     let price = sysStateTuple._1.value
355 +     let decimalsMultPrice = sysStateTuple._2.value
356 +     let baseAssetBalance = sysStateTuple._3.value
357 +     let totalLockedBaseAmount = sysStateTuple._4.value
358 +     let baseAssetBalanceConsideringLock = sysStateTuple._5.value
359 +     let shareEmission = sysStateTuple._6.value
360 +     let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceConsideringLock), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
361 +     throw(restData)
362 +     }
363 + 
364 +

Old	New		Differences
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 failExecuteGet (msg,baseAssetStr,userAddressStr,submitTxIdStr,operationType) = throw(((((((((msg + ": baseAssetStr=") + baseAssetStr) + " userAddressStr=") + userAddressStr) + " submitTxIdStr=") + submitTxIdStr) + " operationType=") + operationType))
	16	+
	17	+
	18	+	func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
	19	+
	20	+
	21	+	func keyNextInternalAssetId () = "%s__nextInternalAssetId"
	22	+
	23	+
	24	+	func keyPriceLast (internalBasetAssetStr) = ("%s%s%d__price__last__" + internalBasetAssetStr)
	25	+
	26	+
	27	+	func keyPriceByTopUpIdx (internalBaseAssetStr,topUpIdx) = makeString(["%s%s%d%d__price__byTopUpIdx", internalBaseAssetStr, toString(topUpIdx)], SEP)
	28	+
	29	+
	30	+	func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
	31	+
	32	+
	33	+	func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
	34	+
	35	+
	36	+	func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
	37	+
	38	+
	39	+	func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
	40	+
	41	+
	42	+	func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
	43	+
	44	+
	45	+	func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
	46	+
	47	+
	48	+	func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
	49	+
	50	+
	51	+	func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
	52	+
	53	+
	54	+	func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
	55	+
	56	+
	57	+	func keyTopUpCurrentIdx (internalBaseAssetStr) = ("%s%s%d__topup__currentIdx__" + internalBaseAssetStr)
	58	+
	59	+
	60	+	let IdxCfgShareAssetId = 1
	61	+
	62	+	let IdxCfgInternalBaseAsset = 2
	63	+
	64	+	let IdxCfgDecimalsMultBothAssets = 3
	65	+
	66	+	let IdxCfgDecimalsMultPrice = 4
	67	+
	68	+	let IdxCfgGetDelayBlocks = 5
	69	+
	70	+	func dataAssetCfg (shareAssetStr,internalBaseAssetStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks) = makeString(["%s%d%d%d%d", shareAssetStr, internalBaseAssetStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks)], SEP)
	71	+
	72	+
	73	+	let IdxTotalLockedInShare = 1
	74	+
	75	+	let IdxTotalLockedOutBase = 2
	76	+
	77	+	let IdxTotalLockedInBase = 3
	78	+
	79	+	let IdxTotalLockedOutShare = 4
	80	+
	81	+	func dataTotalLocked (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = makeString(["%d%d%d%d", toString(inShareAmount), toString(outBaseAmount), toString(inBaseAmount), toString(outShareAmount)], SEP)
	82	+
	83	+
	84	+	func dataTotalLockedInt (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = [-1, inShareAmount, outBaseAmount, inBaseAmount, outShareAmount]
	85	+
	86	+
	87	+	func readTotalLocked (key) = {
	88	+	let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0, 0, 0)), SEP)
	89	+	dataTotalLockedInt(parseIntValue(totalLockedArray[IdxTotalLockedInShare]), parseIntValue(totalLockedArray[IdxTotalLockedOutBase]), parseIntValue(totalLockedArray[IdxTotalLockedInBase]), parseIntValue(totalLockedArray[IdxTotalLockedOutShare]))
	90	+	}
	91	+
	92	+
	93	+	func calcLockedAmountsDiff (operationType,inOperationAmount,outOperationAmount) = if ((operationType == "P"))
	94	+	then dataTotalLockedInt(0, 0, inOperationAmount, outOperationAmount)
	95	+	else if ((operationType == "G"))
	96	+	then dataTotalLockedInt(inOperationAmount, outOperationAmount, 0, 0)
	97	+	else throw(("Unsupported operationType " + operationType))
	98	+
	99	+
	100	+	func updateTotalLocked (action,internalBaseAssetStr,userAddress,lockedAmountsDiff) = {
	101	+	func UPDATE (a,b) = if ((action == "INCREMENT"))
	102	+	then (a + b)
	103	+	else if ((action == "DECREMENT"))
	104	+	then (a - b)
	105	+	else throw(("Unsupported action " + action))
	106	+
	107	+	func TotalLockedStringEntry (key) = {
	108	+	let dataArray = readTotalLocked(key)
	109	+	StringEntry(key, dataTotalLocked(UPDATE(dataArray[IdxTotalLockedInShare], lockedAmountsDiff[IdxTotalLockedInShare]), UPDATE(dataArray[IdxTotalLockedOutBase], lockedAmountsDiff[IdxTotalLockedOutBase]), UPDATE(dataArray[IdxTotalLockedInBase], lockedAmountsDiff[IdxTotalLockedInBase]), UPDATE(dataArray[IdxTotalLockedOutShare], lockedAmountsDiff[IdxTotalLockedOutShare])))
	110	+	}
	111	+
	112	+	([TotalLockedStringEntry(keyTotalLocked(internalBaseAssetStr))] ++ (if ((userAddress != ""))
	113	+	then [TotalLockedStringEntry(keyTotalLockedByUser(internalBaseAssetStr, userAddress))]
	114	+	else nil))
	115	+	}
	116	+
	117	+
	118	+	func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
	119	+
	120	+
	121	+	let IdxOperStatus = 1
	122	+
	123	+	let IdxOperInAmount = 2
	124	+
	125	+	let IdxOperPrice = 3
	126	+
	127	+	let IdxOperOutAmount = 4
	128	+
	129	+	let IdxOperStartHeight = 5
	130	+
	131	+	let IdxOperStartTimestamp = 6
	132	+
	133	+	let IdxOperEndHeight = 7
	134	+
	135	+	let IdxOperEndTimestamp = 8
	136	+
	137	+	let IdxOperLock = 9
	138	+
	139	+	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)
	140	+
	141	+
	142	+	func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp,lock) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp), toString(lock))
	143	+
	144	+
	145	+	func dataOperationExecutionUpdate (currOperArray,newStatus,newEndTimestamp) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], currOperArray[IdxOperPrice], currOperArray[IdxOperOutAmount], currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], currOperArray[IdxOperEndHeight], toString(newEndTimestamp), currOperArray[IdxOperLock])
	146	+
	147	+
	148	+	func readAssetCfgOrFail (baseAssetStr) = {
	149	+	let key = keyAssetCfg(baseAssetStr)
	150	+	split(getStringOrFail(key), SEP)
	151	+	}
	152	+
	153	+
	154	+	func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultPrice) = {
	155	+	let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
	156	+	let totalLockedOutBaseAmount = totalLockedArray[IdxTotalLockedOutBase]
	157	+	let totalLockedInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
	158	+	let baseAssetBalance = assetBalance(this, baseAssetId)
	159	+	let baseAssetBalanceCALC = (((baseAssetBalance + topUpBaseAmount) - totalLockedInBaseAmount) - totalLockedOutBaseAmount)
	160	+	let totalLockedOutShareAmount = totalLockedArray[IdxTotalLockedOutShare]
	161	+	let totalLockedInShareAmount = totalLockedArray[IdxTotalLockedInShare]
	162	+	let shareEmission = value(assetInfo(shareAssetId)).quantity
	163	+	let shareEmissionCALC = (shareEmission + totalLockedOutShareAmount)
	164	+	if ((0 > baseAssetBalanceCALC))
	165	+	then throw(((("baseAssetBalanceCALC < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceCALC=") + toString(baseAssetBalanceCALC)))
	166	+	else {
	167	+	let price = if ((shareEmission == 0))
	168	+	then (2 * decimalsMultPrice)
	169	+	else fraction(baseAssetBalanceCALC, decimalsMultPrice, shareEmissionCALC)
	170	+	$Tuple5(price, baseAssetBalance, totalLockedOutBaseAmount, baseAssetBalanceCALC, shareEmission)
	171	+	}
	172	+	}
	173	+
	174	+
	175	+	func calcPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultPrice) = genericCalcPrice(internalBaseAssetStr, baseAssetId, 0, shareAssetId, decimalsMultPrice)
	176	+
	177	+
	178	+	func moveTotalLocked (internalBaseAssetStr,price,shareAssetId,decimalsMultPrice) = {
	179	+	let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
	180	+	let totalLockedInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
	181	+	let totalLockedInShareAmount = totalLockedArray[IdxTotalLockedInShare]
	182	+	let lockedAmountsDiff = dataTotalLockedInt(-(totalLockedInShareAmount), fraction(totalLockedInShareAmount, price, decimalsMultPrice), -(totalLockedInBaseAmount), fraction(totalLockedInBaseAmount, decimalsMultPrice, price))
	183	+	(updateTotalLocked("INCREMENT", internalBaseAssetStr, "", lockedAmountsDiff) :+ Burn(shareAssetId, totalLockedInShareAmount))
	184	+	}
	185	+
	186	+
	187	+	func submit (operationType,i,inAmount,inAssetId,baseAssetStr) = {
	188	+	let inAssetStr = toBase58String(inAssetId)
	189	+	let userAddressStr = toString(i.caller)
	190	+	let baseAssetId = fromBase58String(baseAssetStr)
	191	+	let cfgArray = readAssetCfgOrFail(baseAssetStr)
	192	+	let shareAssetStr = cfgArray[IdxCfgShareAssetId]
	193	+	let shareAssetId = fromBase58String(shareAssetStr)
	194	+	let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
	195	+	let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
	196	+	let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
	197	+	let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
	198	+	if (isPutBlocked)
	199	+	then throw("put operation is blocked")
	200	+	else {
	201	+	let topUpCurrentIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
	202	+	let lockedAmountsDiff = calcLockedAmountsDiff(operationType, inAmount, 0)
	203	+	([StringEntry(keyOperation(operationType, internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("PENDING", inAmount, 0, 0, height, lastBlock.timestamp, 0, 0, (topUpCurrentIdx + 1)))] ++ updateTotalLocked("INCREMENT", internalBaseAssetStr, userAddressStr, lockedAmountsDiff))
	204	+	}
	205	+	}
	206	+
	207	+
	208	+	func execute (operationType,baseAssetStr,userAddressStr,submitTxIdStr) = {
	209	+	let userAddress = addressFromStringValue(userAddressStr)
	210	+	let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
	211	+	let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
	212	+	let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
	213	+	let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
	214	+	let baseAssetId = fromBase58String(baseAssetStr)
	215	+	let operationKey = keyOperation(operationType, internalBaseAssetStr, userAddressStr, submitTxIdStr)
	216	+	let operationArray = split(getStringOrFail(operationKey), SEP)
	217	+	let status = operationArray[IdxOperStatus]
	218	+	let inAmount = parseIntValue(operationArray[IdxOperInAmount])
	219	+	let operLock = parseIntValue(operationArray[IdxOperLock])
	220	+	let currTopUpIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
	221	+	let priceByTopUpId = getIntOrFail(keyPriceByTopUpIdx(internalBaseAssetStr, currTopUpIdx))
	222	+	let outAmount = if ((operationType == "P"))
	223	+	then fraction(inAmount, decimalsMultPrice, priceByTopUpId)
	224	+	else if ((operationType == "G"))
	225	+	then fraction(inAmount, priceByTopUpId, decimalsMultPrice)
	226	+	else throw(("Unsupported operation type " + operationType))
	227	+	let lockedAmountsDiff = calcLockedAmountsDiff(operationType, inAmount, outAmount)
	228	+	if ((status != "PENDING"))
	229	+	then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, submitTxIdStr, operationType)
	230	+	else if ((operLock > currTopUpIdx))
	231	+	then failExecuteGet(((("OperLock[" + toString(operLock)) + "] > ") + toString(currTopUpIdx)), baseAssetStr, userAddressStr, submitTxIdStr, operationType)
	232	+	else {
	233	+	let outTransfer = if ((operationType == "P"))
	234	+	then [Reissue(shareAssetId, outAmount, true), ScriptTransfer(userAddress, outAmount, shareAssetId)]
	235	+	else if ((operationType == "G"))
	236	+	then [ScriptTransfer(userAddress, outAmount, baseAssetId)]
	237	+	else throw(("Unsupported operation type " + operationType))
	238	+	(([StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", lastBlock.timestamp))] ++ outTransfer) ++ updateTotalLocked("DECREMENT", internalBaseAssetStr, userAddressStr, lockedAmountsDiff))
	239	+	}
	240	+	}
	241	+
	242	+
	243	+	func privateCurrentSysParamsREST (baseAssetStr) = {
	244	+	let baseAssetId = fromBase58String(baseAssetStr)
	245	+	let cfgArray = readAssetCfgOrFail(baseAssetStr)
	246	+	let shareAssetStr = cfgArray[IdxCfgShareAssetId]
	247	+	let shareAssetId = fromBase58String(shareAssetStr)
	248	+	let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
	249	+	let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
	250	+	let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
	251	+	let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPrice)
	252	+	$Tuple6(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("totalLockedBaseAmount", sysState._3), IntegerEntry("baseAssetBalanceConsideringLock", sysState._4), IntegerEntry("shareEmission", sysState._5))
	253	+	}
	254	+
	255	+
	256	+	@Callable(i)
	257	+	func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress,startPrice) = {
	258	+	let baseAssetId = fromBase58String(baseAssetStr)
	259	+	let decimals = value(assetInfo(baseAssetId)).decimals
	260	+	if ((i.caller != this))
	261	+	then throw("permissions denied")
	262	+	else if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
	263	+	then throw("invalid shutdownManagerAddress")
	264	+	else if ((0 > getDelayinBlocks))
	265	+	then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
	266	+	else {
	267	+	let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, 1, decimals, true)
	268	+	let shareAssetId = calculateAssetId(shareAssetIssueAction)
	269	+	let shareAssetStr = toBase58String(shareAssetId)
	270	+	let decimalsMultPrice = ((100 * 1000) * 1000)
	271	+	let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
	272	+	let internalBaseAssettId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
	273	+	let internalBaseAssetStr = toString(internalBaseAssettId)
	274	+	[StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks)), StringEntry(keyMappingsInternal2baseAssetId(internalBaseAssettId), baseAssetStr), StringEntry(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StringEntry(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StringEntry(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownPutOperation(internalBaseAssetStr), false), StringEntry(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntegerEntry(keyNextInternalAssetId(), (internalBaseAssettId + 1)), IntegerEntry(keyPriceLast(internalBaseAssetStr), startPrice), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), IntegerEntry(keyTopUpCurrentIdx(internalBaseAssetStr), 0), shareAssetIssueAction, Burn(shareAssetId, 1)]
	275	+	}
	276	+	}
	277	+
	278	+
	279	+
	280	+	@Callable(i)
	281	+	func shutdownPut (internalBaseAssetId) = {
	282	+	let internalBaseAssetIdStr = toString(internalBaseAssetId)
	283	+	let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
	284	+	let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
	285	+	if ((1 > size(baseAssetIdStr)))
	286	+	then throw("invalid internalBaseAssetId")
	287	+	else if ((toString(i.caller) != shutdownManagerAddress))
	288	+	then throw("access denied")
	289	+	else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
	290	+	}
	291	+
	292	+
	293	+
	294	+	@Callable(i)
	295	+	func submitPut () = {
	296	+	let pmt = value(i.payments[0])
	297	+	let inAmount = pmt.amount
	298	+	let inAssetId = value(pmt.assetId)
	299	+	let baseAssetStr = toBase58String(inAssetId)
	300	+	submit("P", i, inAmount, inAssetId, baseAssetStr)
	301	+	}
	302	+
	303	+
	304	+
	305	+	@Callable(i)
	306	+	func submitGet () = {
	307	+	let pmt = value(i.payments[0])
	308	+	let inAmount = pmt.amount
	309	+	let inAssetId = value(pmt.assetId)
	310	+	let shareAssetStr = toBase58String(inAssetId)
	311	+	let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
	312	+	submit("G", i, inAmount, inAssetId, baseAssetStr)
	313	+	}
	314	+
	315	+
	316	+
	317	+	@Callable(i)
	318	+	func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = execute("P", baseAssetStr, userAddressStr, submitTxIdStr)
	319	+
	320	+
	321	+
	322	+	@Callable(i)
	323	+	func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = execute("G", baseAssetStr, userAddressStr, submitTxIdStr)
	324	+
	325	+
	326	+
	327	+	@Callable(i)
	328	+	func topUpBalance (baseAssetStr,amount) = {
	329	+	let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
	330	+	let pmt = value(i.payments[0])
	331	+	let pmtAssetId = value(pmt.assetId)
	332	+	let pmtAssetStr = toBase58String(pmtAssetId)
	333	+	let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
	334	+	let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
	335	+	let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
	336	+	let topUpCurrentIdxKEY = keyTopUpCurrentIdx(internalBaseAssetStr)
	337	+	let prevTopUpIdx = getIntOrFail(topUpCurrentIdxKEY)
	338	+	let currentTopUpIdx = (prevTopUpIdx + 1)
	339	+	if ((baseAssetStr != pmtAssetStr))
	340	+	then throw("attached payment's asset id is NOT matched passed baseAssetStr")
	341	+	else if ((size(i.payments) > 1))
	342	+	then throw("only one payment can be attached")
	343	+	else {
	344	+	let price = genericCalcPrice(internalBaseAssetStr, pmtAssetId, pmt.amount, shareAssetId, decimalsMultPrice)._1
	345	+	([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx)] ++ moveTotalLocked(internalBaseAssetStr, price, shareAssetId, decimalsMultPrice))
	346	+	}
	347	+	}
	348	+
	349	+
	350	+
	351	+	@Callable(i)
	352	+	func currentSysParamsREST (baseAssetStr) = {
	353	+	let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
	354	+	let price = sysStateTuple._1.value
	355	+	let decimalsMultPrice = sysStateTuple._2.value
	356	+	let baseAssetBalance = sysStateTuple._3.value
	357	+	let totalLockedBaseAmount = sysStateTuple._4.value
	358	+	let baseAssetBalanceConsideringLock = sysStateTuple._5.value
	359	+	let shareEmission = sysStateTuple._6.value
	360	+	let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceConsideringLock), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
	361	+	throw(restData)
	362	+	}
	363	+
	364	+

github/deemru/w8io/873ac7e 
27.40 ms ◑