tx · GvDb6xExW7ZZAZAH1KEkKYZKPnhi7k2fsdcY2MSsW2rk

3Mx9QvErYcj5bfthRftiMDUbTW9bQDpUEdY:  -0.01000000 Waves

2021.03.22 20:16 [1449239] smart account 3Mx9QvErYcj5bfthRftiMDUbTW9bQDpUEdY > SELF 0.00000000 Waves

{ "type": 13, "id": "GvDb6xExW7ZZAZAH1KEkKYZKPnhi7k2fsdcY2MSsW2rk", "fee": 1000000, "feeAssetId": null, "timestamp": 1616433384181, "version": 1, "sender": "3Mx9QvErYcj5bfthRftiMDUbTW9bQDpUEdY", "senderPublicKey": "HnLaPAP3PfW4oxBCSbfzizS1jyVAyZ4LjUKqgQkXLYNb", "proofs": [ "4RaHPHt3GbDeeniD8jYM4yDFZMGs6m7dajB7pVavYUrcAeNBVTzfZhhZva8kwfoQmVY2aeUoV8cHZZuGfozuzioF" ], "script": "base64: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", "chainId": 84, "height": 1449239, "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 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 keyPriceATH (internalBasetAssetStr) = ("%s%s%d__price__ath__" + internalBasetAssetStr)
28+
29+
30+func keyPriceByTopUpIdx (internalBaseAssetStr,topUpIdx) = makeString(["%s%s%d%d__price__byTopUpIdx", internalBaseAssetStr, toString(topUpIdx)], SEP)
31+
32+
33+func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
34+
35+
36+func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
37+
38+
39+func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
40+
41+
42+func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
43+
44+
45+func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
46+
47+
48+func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
49+
50+
51+func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
52+
53+
54+func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
55+
56+
57+func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
58+
59+
60+func keyTopUpCurrentIdx (internalBaseAssetStr) = ("%s%s%d__topup__currentIdx__" + internalBaseAssetStr)
61+
62+
63+func keyTopUpLastHeight (internalBasetAssetStr,sender) = makeString(["%s%s%s%d%s__topup__last__height", internalBasetAssetStr, sender], SEP)
64+
65+
66+func convertShare2Base (shareAmount,price,priceMult) = fraction(shareAmount, price, priceMult)
67+
68+
69+func convertBase2Share (baseAmount,price,priceMult) = fraction(baseAmount, priceMult, price)
70+
71+
72+let IdxCfgShareAssetId = 1
73+
74+let IdxCfgInternalBaseAsset = 2
75+
76+let IdxCfgDecimalsMultBothAssets = 3
77+
78+let IdxCfgDecimalsMultPrice = 4
79+
80+let IdxCfgGetDelayBlocks = 5
81+
82+let IdxCfgTopupIntervalInBlocks = 6
83+
84+let IdxCfgTopupMaxNegativePart = 7
85+
86+let IdxCfgTopupManagerAddress = 8
87+
88+func dataAssetCfg (shareAssetStr,internalBaseAssetStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks,topupIntervalInBlocks,topupMaxNegativePart,topupManagerAddress) = makeString(["%s%d%d%d%d%d", shareAssetStr, internalBaseAssetStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks), toString(topupIntervalInBlocks), toString(topupMaxNegativePart), topupManagerAddress], SEP)
89+
90+
91+let IdxTotalLockedInShare = 1
92+
93+let IdxTotalLockedOutBase = 2
94+
95+let IdxTotalLockedInBase = 3
96+
97+let IdxTotalLockedOutShare = 4
98+
99+func dataTotalLocked (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = makeString(["%d%d%d%d", toString(inShareAmount), toString(outBaseAmount), toString(inBaseAmount), toString(outShareAmount)], SEP)
100+
101+
102+func dataTotalLockedInt (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = [-1, inShareAmount, outBaseAmount, inBaseAmount, outShareAmount]
103+
104+
105+func readTotalLocked (key) = {
106+ let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0, 0, 0)), SEP)
107+ dataTotalLockedInt(parseIntValue(totalLockedArray[IdxTotalLockedInShare]), parseIntValue(totalLockedArray[IdxTotalLockedOutBase]), parseIntValue(totalLockedArray[IdxTotalLockedInBase]), parseIntValue(totalLockedArray[IdxTotalLockedOutShare]))
108+ }
109+
110+
111+func calcTotalLockedDiff (direction,operationType,internalBaseAssetStr,price,priceMult,inAmount,baseAssetId,shareAssetId) = {
112+ let t = (direction + operationType)
113+ if ((t == "submitP"))
114+ then {
115+ let totalDiff = dataTotalLockedInt(0, 0, inAmount, 0)
116+ let userDiff = totalDiff
117+ $Tuple4(totalDiff, userDiff, 0, fromBase58String(""))
118+ }
119+ else if ((t == "submitG"))
120+ then {
121+ let totalDiff = dataTotalLockedInt(inAmount, 0, 0, 0)
122+ let userDiff = totalDiff
123+ $Tuple4(totalDiff, userDiff, 0, fromBase58String(""))
124+ }
125+ else if ((t == "executeP"))
126+ then {
127+ let outAmount = convertBase2Share(inAmount, price, priceMult)
128+ let totalDiff = dataTotalLockedInt(0, 0, 0, outAmount)
129+ let userDiff = dataTotalLockedInt(0, 0, inAmount, 0)
130+ $Tuple4(totalDiff, userDiff, outAmount, shareAssetId)
131+ }
132+ else if ((t == "executeG"))
133+ then {
134+ let outAmount = convertShare2Base(inAmount, price, priceMult)
135+ let totalDiff = dataTotalLockedInt(0, outAmount, 0, 0)
136+ let userDiff = dataTotalLockedInt(inAmount, 0, 0, 0)
137+ $Tuple4(totalDiff, userDiff, outAmount, baseAssetId)
138+ }
139+ else if ((t == "topup"))
140+ then {
141+ let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
142+ let totalLockedInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
143+ let totalLockedInShareAmount = totalLockedArray[IdxTotalLockedInShare]
144+ let totalDiff = dataTotalLockedInt(totalLockedInShareAmount, (-1 * convertShare2Base(totalLockedInShareAmount, price, priceMult)), totalLockedInBaseAmount, (-1 * convertBase2Share(totalLockedInBaseAmount, priceMult, price)))
145+ $Tuple4(totalDiff, nil, 0, fromBase58String(""))
146+ }
147+ else throw(("Unsupported Type " + t))
148+ }
149+
150+
151+func TotalLockedStringEntry (action,key,diff) = {
152+ func UPDATE (a,b) = if ((action == "INCREMENT"))
153+ then (a + b)
154+ else if ((action == "DECREMENT"))
155+ then (a - b)
156+ else throw(("Unsupported action " + action))
157+
158+ let dataArray = readTotalLocked(key)
159+ StringEntry(key, dataTotalLocked(UPDATE(dataArray[IdxTotalLockedInShare], diff[IdxTotalLockedInShare]), UPDATE(dataArray[IdxTotalLockedOutBase], diff[IdxTotalLockedOutBase]), UPDATE(dataArray[IdxTotalLockedInBase], diff[IdxTotalLockedInBase]), UPDATE(dataArray[IdxTotalLockedOutShare], diff[IdxTotalLockedOutShare])))
160+ }
161+
162+
163+func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
164+
165+
166+let IdxOperStatus = 1
167+
168+let IdxOperInAmount = 2
169+
170+let IdxOperPrice = 3
171+
172+let IdxOperOutAmount = 4
173+
174+let IdxOperStartHeight = 5
175+
176+let IdxOperStartTimestamp = 6
177+
178+let IdxOperEndHeight = 7
179+
180+let IdxOperEndTimestamp = 8
181+
182+let IdxOperLock = 9
183+
184+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)
185+
186+
187+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))
188+
189+
190+func dataOperationExecutionUpdate (currOperArray,newStatus,newPrice,newOutAmount) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], toString(newPrice), toString(newOutAmount), currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], toString(height), toString(lastBlock.timestamp), currOperArray[IdxOperLock])
191+
192+
193+func readAssetCfgOrFail (baseAssetStr) = {
194+ let key = keyAssetCfg(baseAssetStr)
195+ split(getStringOrFail(key), SEP)
196+ }
197+
198+
199+func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultPrice) = {
200+ let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
201+ let totalLockedOutBaseAmount = totalLockedArray[IdxTotalLockedOutBase]
202+ let totalLockedInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
203+ let baseAssetBalance = assetBalance(this, baseAssetId)
204+ let baseAssetBalanceCALC = (((baseAssetBalance + topUpBaseAmount) - totalLockedInBaseAmount) - totalLockedOutBaseAmount)
205+ let totalLockedOutShareAmount = totalLockedArray[IdxTotalLockedOutShare]
206+ let totalLockedInShareAmount = totalLockedArray[IdxTotalLockedInShare]
207+ let shareEmission = value(assetInfo(shareAssetId)).quantity
208+ let shareEmissionCALC = (shareEmission + totalLockedOutShareAmount)
209+ if ((0 > baseAssetBalanceCALC))
210+ then throw(((("baseAssetBalanceCALC < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceCALC=") + toString(baseAssetBalanceCALC)))
211+ else {
212+ let price = if ((shareEmission == 0))
213+ then (2 * decimalsMultPrice)
214+ else fraction(baseAssetBalanceCALC, decimalsMultPrice, shareEmissionCALC)
215+ $Tuple5(price, baseAssetBalance, totalLockedOutBaseAmount, baseAssetBalanceCALC, shareEmission)
216+ }
217+ }
218+
219+
220+func calcPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultPrice) = genericCalcPrice(internalBaseAssetStr, baseAssetId, 0, shareAssetId, decimalsMultPrice)
221+
222+
223+func submit (operationType,i,inAmount,inAssetId,baseAssetStr) = {
224+ let inAssetStr = toBase58String(inAssetId)
225+ let userAddressStr = toString(i.caller)
226+ let baseAssetId = fromBase58String(baseAssetStr)
227+ let cfgArray = readAssetCfgOrFail(baseAssetStr)
228+ let shareAssetStr = cfgArray[IdxCfgShareAssetId]
229+ let shareAssetId = fromBase58String(shareAssetStr)
230+ let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
231+ let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
232+ let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
233+ if (isPutBlocked)
234+ then throw("put operation is blocked")
235+ else {
236+ let topUpCurrentIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
237+ let diffTuple = calcTotalLockedDiff("submit", operationType, internalBaseAssetStr, 0, 0, inAmount, baseAssetId, shareAssetId)
238+ (([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))
239+ }
240+ }
241+
242+
243+func execute (operationType,baseAssetStr,userAddressStr,submitTxIdStr) = {
244+ let userAddress = addressFromStringValue(userAddressStr)
245+ let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
246+ let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
247+ let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
248+ let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
249+ let baseAssetId = fromBase58String(baseAssetStr)
250+ let operationKey = keyOperation(operationType, internalBaseAssetStr, userAddressStr, submitTxIdStr)
251+ let operationArray = split(getStringOrFail(operationKey), SEP)
252+ let status = operationArray[IdxOperStatus]
253+ let inAmount = parseIntValue(operationArray[IdxOperInAmount])
254+ let operLock = parseIntValue(operationArray[IdxOperLock])
255+ let currTopUpIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
256+ let priceByTopUpId = getIntOrFail(keyPriceByTopUpIdx(internalBaseAssetStr, currTopUpIdx))
257+ if ((status != "PENDING"))
258+ then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, submitTxIdStr, operationType)
259+ else if ((operLock > currTopUpIdx))
260+ then failExecuteGet(((("OperLock[" + toString(operLock)) + "] > ") + toString(currTopUpIdx)), baseAssetStr, userAddressStr, submitTxIdStr, operationType)
261+ else {
262+ let diffTuple = calcTotalLockedDiff("execute", operationType, internalBaseAssetStr, priceByTopUpId, decimalsMultPrice, inAmount, baseAssetId, shareAssetId)
263+ let outAmount = diffTuple._3
264+ let outTransferData = if ((diffTuple._4 == baseAssetId))
265+ then [ScriptTransfer(userAddress, outAmount, baseAssetId)]
266+ else [Reissue(shareAssetId, outAmount, true), ScriptTransfer(userAddress, outAmount, shareAssetId)]
267+ (((outTransferData :+ StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", priceByTopUpId, outAmount))) :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), diffTuple._1)) :+ TotalLockedStringEntry("DECREMENT", keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), diffTuple._2))
268+ }
269+ }
270+
271+
272+func privateCurrentSysParamsREST (baseAssetStr) = {
273+ let baseAssetId = fromBase58String(baseAssetStr)
274+ let cfgArray = readAssetCfgOrFail(baseAssetStr)
275+ let shareAssetStr = cfgArray[IdxCfgShareAssetId]
276+ let shareAssetId = fromBase58String(shareAssetStr)
277+ let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
278+ let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
279+ let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
280+ let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPrice)
281+ $Tuple6(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("totalLockedBaseAmount", sysState._3), IntegerEntry("baseAssetBalanceConsideringLock", sysState._4), IntegerEntry("shareEmission", sysState._5))
282+ }
283+
284+
285+@Callable(i)
286+func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress,startPrice,topupIntervalInBlocks,topupMaxNegativePart,topupManagerAddress) = {
287+ let baseAssetId = fromBase58String(baseAssetStr)
288+ let decimals = value(assetInfo(baseAssetId)).decimals
289+ let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
290+ let decimalsMultPrice = ((100 * 1000) * 1000)
291+ let topupMaxNegativePercents = fraction(topupMaxNegativePart, 100, decimalsMultBothAssets)
292+ let baseAssetBalance = assetBalance(this, baseAssetId)
293+ if ((i.caller != this))
294+ then throw("permissions denied")
295+ else if ((baseAssetBalance == 0))
296+ then throw(((toString(this) + " must have any initial balance of ") + baseAssetStr))
297+ else if (isDefined(getString(this, keyAssetCfg(baseAssetStr))))
298+ then throw((baseAssetStr + " has been already registered"))
299+ else if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
300+ then throw("invalid shutdownManagerAddress")
301+ else if ((toString(addressFromStringValue(topupManagerAddress)) != topupManagerAddress))
302+ then throw("invalid topupManagerAddress")
303+ else if ((0 > getDelayinBlocks))
304+ then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
305+ else if (if ((0 >= topupMaxNegativePercents))
306+ then true
307+ else (topupMaxNegativePercents >= 99))
308+ then throw("invalid topupMaxNegativePart parameter")
309+ else {
310+ let shareInitAmount = convertBase2Share(baseAssetBalance, startPrice, decimalsMultPrice)
311+ let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, shareInitAmount, decimals, true)
312+ let shareAssetId = calculateAssetId(shareAssetIssueAction)
313+ let shareAssetStr = toBase58String(shareAssetId)
314+ let internalBaseAssettId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
315+ let internalBaseAssetStr = toString(internalBaseAssettId)
316+[StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks, topupIntervalInBlocks, topupMaxNegativePart, topupManagerAddress)), 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]
317+ }
318+ }
319+
320+
321+
322+@Callable(i)
323+func shutdownPut (internalBaseAssetId) = {
324+ let internalBaseAssetIdStr = toString(internalBaseAssetId)
325+ let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
326+ let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
327+ if ((1 > size(baseAssetIdStr)))
328+ then throw("invalid internalBaseAssetId")
329+ else if ((toString(i.caller) != shutdownManagerAddress))
330+ then throw("access denied")
331+ else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
332+ }
333+
334+
335+
336+@Callable(i)
337+func submitPut () = {
338+ let pmt = value(i.payments[0])
339+ let inAmount = pmt.amount
340+ let inAssetId = value(pmt.assetId)
341+ let baseAssetStr = toBase58String(inAssetId)
342+ submit("P", i, inAmount, inAssetId, baseAssetStr)
343+ }
344+
345+
346+
347+@Callable(i)
348+func submitGet () = {
349+ let pmt = value(i.payments[0])
350+ let inAmount = pmt.amount
351+ let inAssetId = value(pmt.assetId)
352+ let shareAssetStr = toBase58String(inAssetId)
353+ let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
354+ submit("G", i, inAmount, inAssetId, baseAssetStr)
355+ }
356+
357+
358+
359+@Callable(i)
360+func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = execute("P", baseAssetStr, userAddressStr, submitTxIdStr)
361+
362+
363+
364+@Callable(i)
365+func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = execute("G", baseAssetStr, userAddressStr, submitTxIdStr)
366+
367+
368+
369+@Callable(i)
370+func topUpBalance (baseAssetStr,amount) = {
371+ let baseAssetId = fromBase58String(baseAssetStr)
372+ let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
373+ let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
374+ let priceMult = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
375+ let bothAssetMult = parseIntValue(assetCfgArray[IdxCfgDecimalsMultBothAssets])
376+ let topupIntervalInBlocks = parseIntValue(assetCfgArray[IdxCfgTopupIntervalInBlocks])
377+ let topupMaxNegativePart = parseIntValue(assetCfgArray[IdxCfgTopupMaxNegativePart])
378+ let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
379+ let topUpCurrentIdxKEY = keyTopUpCurrentIdx(internalBaseAssetStr)
380+ let prevTopUpIdx = getIntOrFail(topUpCurrentIdxKEY)
381+ let currentTopUpIdx = (prevTopUpIdx + 1)
382+ let valid = if ((amount > 0))
383+ then {
384+ let pmt = value(i.payments[0])
385+ let pmtAssetId = value(pmt.assetId)
386+ if ((baseAssetId != pmtAssetId))
387+ then throw("attached payment's asset id is NOT matched passed baseAssetStr")
388+ else if ((size(i.payments) > 1))
389+ then throw("only one payment can be attached")
390+ else if ((pmt.amount != amount))
391+ then throw("attached payment.amount is NOT matched passed amount argument")
392+ else true
393+ }
394+ else if ((0 > amount))
395+ then {
396+ let baseBalance = assetBalance(this, baseAssetId)
397+ let allowedAmount = fraction(topupMaxNegativePart, baseBalance, bothAssetMult)
398+ if ((-(amount) > allowedAmount))
399+ then throw(("Topup negative amount couldn't be greater than " + toString(allowedAmount)))
400+ else true
401+ }
402+ else throw("zero amount is not allowed")
403+ let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
404+ let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
405+ if (!(valid))
406+ then throw("validation failed")
407+ else if ((topupIntervalInBlocks > (height - topUpLastHeight)))
408+ then throw((("1 topup per " + toString(topupIntervalInBlocks)) + " blocks from the same address is allowed"))
409+ else {
410+ let price = genericCalcPrice(internalBaseAssetStr, baseAssetId, amount, shareAssetId, priceMult)._1
411+ let diffTuple = calcTotalLockedDiff("topup", "", internalBaseAssetStr, price, priceMult, 0, baseAssetId, shareAssetId)
412+ let topupTotalDiff = diffTuple._1
413+ let priceAthKEY = keyPriceATH(internalBaseAssetStr)
414+ let prevPriceATH = valueOrElse(getInteger(this, priceAthKEY), 0)
415+ (([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx), IntegerEntry(priceAthKEY, if ((price > prevPriceATH))
416+ then price
417+ else prevPriceATH), IntegerEntry(topUpLastHeightKEY, height)] :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), topupTotalDiff)) :+ Burn(shareAssetId, topupTotalDiff[IdxTotalLockedInShare]))
418+ }
419+ }
420+
421+
422+
423+@Callable(i)
424+func currentSysParamsREST (baseAssetStr) = {
425+ let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
426+ let price = sysStateTuple._1.value
427+ let decimalsMultPrice = sysStateTuple._2.value
428+ let baseAssetBalance = sysStateTuple._3.value
429+ let totalLockedBaseAmount = sysStateTuple._4.value
430+ let baseAssetBalanceConsideringLock = sysStateTuple._5.value
431+ let shareEmission = sysStateTuple._6.value
432+ let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceConsideringLock), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
433+ throw(restData)
434+ }
435+
436+

github/deemru/w8io/3ef1775 
42.20 ms