w8 · tx · 24w···eAw

tx · 24w2yoHRoB44ajZVdmtj6acdRUA8Vhf5Xr9niZFGveAw

3NC9wWawxuFG6a3sZdfckGwoMeVhLFjZFwH:  -0.01400000 Waves

2021.03.26 15:52 [1454737] smart account 3NC9wWawxuFG6a3sZdfckGwoMeVhLFjZFwH > SELF 0.00000000 Waves

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

View: original | compacted
Prev: DtnPPqZXor71n3iJtMQAB13ee419iGiCDx5qvcKjrPbD
Next: DVX22nRt1mjPq68jUi8X8J8fbnrfJexJP7uER6eTwRns

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

Old	New		Differences
235	235		func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultPrice) = {
236	236		let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
237	237		let totalLockedOutBaseAmount = totalLockedArray[IdxTotalLockedOutBase]
238		-	let ~~totalLockedInBaseAmount~~ = totalLockedArray[IdxTotalLockedInBase]
	238	+	let currIterTotalInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
239	239		let baseAssetBalance = assetBalance(this, baseAssetId)
240		-	let baseAssetBalanceWCO = (((baseAssetBalance + topUpBaseAmount) - ~~totalLockedInBaseAmount~~) - totalLockedOutBaseAmount)
	240	+	let baseAssetBalanceWCO = (((baseAssetBalance + topUpBaseAmount) - currIterTotalInBaseAmount) - totalLockedOutBaseAmount)
241	241		let totalLockedOutShareAmount = totalLockedArray[IdxTotalLockedOutShare]
242		-	let ~~totalLockedInShareAmount~~ = totalLockedArray[IdxTotalLockedInShare]
	242	+	let currIterTotalInShareAmount = totalLockedArray[IdxTotalLockedInShare]
243	243		let shareEmission = value(assetInfo(shareAssetId)).quantity
244	244		if ((0 > baseAssetBalanceWCO))
245	245		then throw(((("baseAssetBalanceWCO < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceWCO=") + toString(baseAssetBalanceWCO)))

248	248		let price = if ((shareEmission == 0))
249	249		then lastPrice
250	250		else fraction(baseAssetBalanceWCO, decimalsMultPrice, shareEmission)
251		-	$~~Tuple5~~(price, baseAssetBalance, -1, baseAssetBalanceWCO, shareEmission)
	251	+	$Tuple9(price, baseAssetBalance, -1, baseAssetBalanceWCO, shareEmission, currIterTotalInBaseAmount, currIterTotalInShareAmount, totalLockedOutBaseAmount, totalLockedOutShareAmount)
252	252		}
253	253		}
254	254

330	330		let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
331	331		let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
332	332		let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
	333	+	let priceAthKEY = keyPriceATH(internalBaseAssetStr)
	334	+	let priceATH = valueOrElse(getInteger(this, priceAthKEY), 0)
333	335		let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPrice)
334		-	$~~Tuple6~~(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("-1", sysState._3), IntegerEntry("baseAssetBalanceWCO", sysState._4), IntegerEntry("shareEmission", sysState._5))
	336	+	$Tuple12(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("-1", sysState._3), IntegerEntry("baseAssetBalanceWCO", sysState._4), IntegerEntry("shareEmission", sysState._5), IntegerEntry("currIterTotalInBaseAmount", sysState._6), IntegerEntry("currIterTotalInShareAmount", sysState._7), IntegerEntry("totalLockedOutBaseAmount", sysState._8), IntegerEntry("totalLockedOutShareAmount", sysState._9), IntegerEntry("decimalsMultBothAssets", decimalsMultBothAssets), IntegerEntry("priceATH", priceATH))
335	337		}
336	338
337	339

499	501		let totalLockedBaseAmount = sysStateTuple._4.value
500	502		let baseAssetBalanceWCO = sysStateTuple._5.value
501	503		let shareEmission = sysStateTuple._6.value
502		-	let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceWCO), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
	504	+	let currIterTotalInBaseAmount = sysStateTuple._7.value
	505	+	let currIterTotalInShareAmount = sysStateTuple._8.value
	506	+	let totalLockedOutBaseAmount = sysStateTuple._9.value
	507	+	let totalLockedOutShareAmount = sysStateTuple._10.value
	508	+	let decimalsMultBothAssets = sysStateTuple._11.value
	509	+	let priceATH = sysStateTuple._12.value
	510	+	let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceWCO), toString(shareEmission), toString(currIterTotalInBaseAmount), toString(currIterTotalInShareAmount), toString(totalLockedOutBaseAmount), toString(totalLockedOutShareAmount), toString(decimalsMultBothAssets), toString(priceATH), "endCurrentSysParamsREST"], SEP)
503	511		throw(restData)
504	512		}
505	513

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

github/deemru/w8io/169f3d6 
185.12 ms ◑