tx · 4zf1kkxY6RRgmPr7B4XkifUxHzrVN5fU4oDpprZMu5Mx

3NCroKxpCWCYijwjiVBg6hc2T7DaajrHuBr:  -0.02900000 Waves

2022.07.11 18:49 [2135272] smart account 3NCroKxpCWCYijwjiVBg6hc2T7DaajrHuBr > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "4zf1kkxY6RRgmPr7B4XkifUxHzrVN5fU4oDpprZMu5Mx",
    "fee": 2900000,
    "feeAssetId": null,
    "timestamp": 1657554601253,
    "version": 1,
    "sender": "3NCroKxpCWCYijwjiVBg6hc2T7DaajrHuBr",
    "senderPublicKey": "4j5ighurrUZ2WcdBTRGqBfXs5fz9YDA76D4gtpZ9basj",
    "proofs": [
        "577FDXeCNLf5QbypYzcdnpmCupEDyai5848kcdZqjcXLfvV6yf4zbL2T6QdyrU3anz89YpCsAMK5EQszR1DZ96t5"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2135272,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 9WgyJ9kYPrLnwcfnuHMWqGJ83DAv3oDm3bg4mXifZxm1
Next: AmbdhwFckrBqxHR5pqY6f5bFMUUa3VhsCmhT3t1XrG88

Diff: 

OldNewDifferences
99 
1010 
1111 func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
12+
13+
14+func testing (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
1215 
1316 
1417 func keyManagerPublicKey () = makeString(["%s", "managerPublicKey"], SEP)

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "__"
55 
66 let EMPTY = ""
77 
88 func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
99 
1010 
1111 func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
12+
13+
14+func testing (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
1215 
1316 
1417 func keyManagerPublicKey () = makeString(["%s", "managerPublicKey"], SEP)
1518 
1619 
1720 func keyPendingManagerPublicKey () = makeString(["%s", "pendingManagerPublicKey"], SEP)
1821 
1922 
2023 func failExecuteGet (msg,baseAssetStr,userAddressStr,getTxIdStr) = throw(((((((msg + ": baseAssetStr=") + baseAssetStr) + " userAddressStr=") + userAddressStr) + " getTxIdStr=") + getTxIdStr))
2124 
2225 
2326 func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], SEP)
2427 
2528 
2629 func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
2730 
2831 
2932 func keyProxyAddress (assetId) = makeString(["%s%s", "proxyAddress", assetId], SEP)
3033 
3134 
3235 func keyBalance (assetId) = makeString(["%s%s", "balance", assetId], SEP)
3336 
3437 
3538 func keyNextInternalAssetId () = "%s__nextInternalAssetId"
3639 
3740 
3841 func keyPriceLast (internalBasetAssetStr) = ("%s%s%d__price__last__" + internalBasetAssetStr)
3942 
4043 
4144 func keyTopUpLastHeight (internalBasetAssetStr,sender) = makeString(["%s%s%s%d%s__topup__last__height", internalBasetAssetStr, sender], SEP)
4245 
4346 
4447 func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
4548 
4649 
4750 func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
4851 
4952 
5053 func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
5154 
5255 
5356 func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
5457 
5558 
5659 func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
5760 
5861 
5962 func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
6063 
6164 
6265 func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
6366 
6467 
6568 func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
6669 
6770 
6871 func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
6972 
7073 
7174 func assetsStoreContract () = addressFromStringValue(value(getString(keyAssetsStoreContract())))
7275 
7376 
7477 let IdxCfgShareAssetId = 1
7578 
7679 let IdxCfgInternalBaseAsset = 2
7780 
7881 let IdxCfgDecimalsMultBothAssets = 3
7982 
8083 let IdxCfgDecimalsMultPrice = 4
8184 
8285 let IdxCfgGetDelayBlocks = 5
8386 
8487 func dataAssetCfg (shareAssetStr,internalBaseAssetStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks) = makeString(["%s%d%d%d%d", shareAssetStr, internalBaseAssetStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks)], SEP)
8588 
8689 
8790 let IdxTotalLockedShare = 1
8891 
8992 let IdxTotalLockedBase = 2
9093 
9194 func dataTotalLocked (shareAssetAmount,baseAssetAmount) = makeString(["%d%d", toString(shareAssetAmount), toString(baseAssetAmount)], SEP)
9295 
9396 
9497 func readTotalLocked (key) = {
9598     let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0)), SEP)
9699 [-1, parseIntValue(totalLockedArray[IdxTotalLockedShare]), parseIntValue(totalLockedArray[IdxTotalLockedBase])]
97100     }
98101 
99102 
100103 func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
101104 
102105 
103106 let IdxOperStatus = 1
104107 
105108 let IdxOperInAmount = 2
106109 
107110 let IdxOperPrice = 3
108111 
109112 let IdxOperOutAmount = 4
110113 
111114 let IdxOperStartHeight = 5
112115 
113116 let IdxOperStartTimestamp = 6
114117 
115118 let IdxOperEndHeight = 7
116119 
117120 let IdxOperEndTimestamp = 8
118121 
119122 func privateDataOperationAllStrings (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp) = makeString(["%s%d%d%d%d%d%d%d", status, inAssetAmount, price, outAssetAmount, startHeight, startTimestamp, endHeight, endTimestamp], SEP)
120123 
121124 
122125 func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp))
123126 
124127 
125128 func dataOperationExecutionUpdate (currOperArray,newStatus,newEndTimestamp) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], currOperArray[IdxOperPrice], currOperArray[IdxOperOutAmount], currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], currOperArray[IdxOperEndHeight], toString(newEndTimestamp))
126129 
127130 
128131 func readAssetCfgOrFail (baseAssetStr) = {
129132     let key = keyAssetCfg(baseAssetStr)
130133     split(getStringOrFail(key), SEP)
131134     }
132135 
133136 
134137 func incrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
135138     let dataArray = readTotalLocked(key)
136139     StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] + shareAssetAmount), (dataArray[IdxTotalLockedBase] + baseAssetAmount)))
137140     }
138141 
139142 
140143 func decrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
141144     let dataArray = readTotalLocked(key)
142145     StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] - shareAssetAmount), (dataArray[IdxTotalLockedBase] - baseAssetAmount)))
143146     }
144147 
145148 
146149 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
147150     case s: String => 
148151         fromBase58String(s)
149152     case _: Unit => 
150153         unit
151154     case _ => 
152155         throw("Match error")
153156 }
154157 
155158 
156159 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
157160     case s: String => 
158161         fromBase58String(s)
159162     case _: Unit => 
160163         unit
161164     case _ => 
162165         throw("Match error")
163166 }
164167 
165168 
166169 func balanceOrZero (assetId) = valueOrElse(getInteger(keyBalance(assetId)), 0)
167170 
168171 
169172 func calcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = {
170173     let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
171174     let totalLockedBaseAmount = totalLockedArray[IdxTotalLockedBase]
172175     let baseAssetBalance = balanceOrZero(toBase58String(baseAssetId))
173176     let baseAssetBalanceConsideringLock = (baseAssetBalance + topUpBaseAmount)
174177     if ((0 > baseAssetBalanceConsideringLock))
175178         then throw(((("baseAssetBalanceConsideringLock < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceConsideringLock=") + toString(baseAssetBalanceConsideringLock)))
176179         else {
177180             let shareEmission = value(assetInfo(shareAssetId)).quantity
178181             let price = if ((shareEmission == 0))
179182                 then (1 * decimalsMultPrice)
180183                 else fraction(baseAssetBalanceConsideringLock, decimalsMultPrice, shareEmission)
181184             $Tuple5(price, baseAssetBalance, totalLockedBaseAmount, baseAssetBalanceConsideringLock, shareEmission)
182185             }
183186     }
184187 
185188 
186189 func getPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = {
187190     let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
188191     let totalLockedBaseAmount = totalLockedArray[IdxTotalLockedBase]
189192     let baseAssetBalance = balanceOrZero(toBase58String(baseAssetId))
190193     let baseAssetBalanceConsideringLock = baseAssetBalance
191194     let shareEmission = value(assetInfo(shareAssetId)).quantity
192195     let price = value(getInteger(keyPriceLast(internalBaseAssetStr)))
193196     $Tuple5(price, baseAssetBalance, totalLockedBaseAmount, baseAssetBalanceConsideringLock, shareEmission)
194197     }
195198 
196199 
197200 func privateCurrentSysParamsREST (baseAssetStr) = {
198201     let baseAssetId = fromBase58String(baseAssetStr)
199202     let cfgArray = readAssetCfgOrFail(baseAssetStr)
200203     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
201204     let shareAssetId = fromBase58String(shareAssetStr)
202205     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
203206     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
204207     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
205208     let sysState = getPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)
206209     let topUpLastHeight =     match getInteger(keyTopUpLastHeight(internalBaseAssetStr, getStringValue(keyProxyAddress(baseAssetStr)))) {
207210         case h: Int => 
208211             value(h)
209212         case _: Unit => 
210213             getIntegerValue(keyTopUpLastHeight(internalBaseAssetStr, toString(addressFromPublicKey(fromBase58String(getStringValue(keyManagerPublicKey()))))))
211214         case _ => 
212215             throw("undefined behaviour in privateCurrentSysParamsREST match")
213216     }
214217     $Tuple8(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("totalLockedBaseAmount", sysState._3), IntegerEntry("baseAssetBalanceConsideringLock", sysState._4), IntegerEntry("shareEmission", sysState._5), IntegerEntry("baseAssetDecimals", value(assetInfo(baseAssetId)).decimals), IntegerEntry("lastTopUpTimestamp", value(blockInfoByHeight(topUpLastHeight)).timestamp))
215218     }
216219 
217220 
218221 func mustManager (i) = {
219222     let pd = throw("permission denied")
220223     match managerPublicKeyOrUnit() {
221224         case pk: ByteVector => 
222225             if ((i.callerPublicKey == pk))
223226                 then true
224227                 else pd
225228         case _: Unit => 
226229             if ((i.caller == this))
227230                 then true
228231                 else pd
229232         case _ => 
230233             throw("Match error")
231234     }
232235     }
233236 
234237 
235238 func mustProxyAddress (i,assetId) = {
236239     let isProxy = (toString(i.caller) == valueOrElse(getString(keyProxyAddress(assetId)), EMPTY))
237240     if (isProxy)
238241         then true
239242         else {
240243             let checkCaller = mustManager(i)
241244             if ((checkCaller == checkCaller))
242245                 then true
243246                 else throw("Strict value is not equal to itself.")
244247             }
245248     }
246249 
247250 
248251 @Callable(i)
249252 func constructor (assetsStoreContract) = {
250253     let checkCaller = mustManager(i)
251254     if ((checkCaller == checkCaller))
252255         then [StringEntry(keyAssetsStoreContract(), assetsStoreContract)]
253256         else throw("Strict value is not equal to itself.")
254257     }
255258 
256259 
257260 
258261 @Callable(i)
259262 func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,shareAssetLogo,getDelayinBlocks,shutdownManagerAddress,proxyAddress) = {
260263     let baseAssetId = fromBase58String(baseAssetStr)
261264     let decimals = value(assetInfo(baseAssetId)).decimals
262265     let check = mustManager(i)
263266     if ((check == check))
264267         then if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
265268             then throw("invalid shutdownManagerAddress")
266269             else if ((0 > getDelayinBlocks))
267270                 then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
268271                 else {
269272                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, 1, decimals, true)
270273                     let shareAssetId = calculateAssetId(shareAssetIssueAction)
271274                     let shareAssetStr = toBase58String(shareAssetId)
272275                     let decimalsMultPrice = ((100 * 1000) * 1000)
273276                     let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
274277                     let startPrice = (1 * decimalsMultPrice)
275278                     let internalBaseAssettId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
276279                     let internalBaseAssetStr = toString(internalBaseAssettId)
277280                     let createOrUpdate = invoke(assetsStoreContract(), "createOrUpdate", [shareAssetStr, shareAssetLogo, false], nil)
278281                     if ((createOrUpdate == createOrUpdate))
279282                         then {
280283                             let addLabel = invoke(assetsStoreContract(), "addLabel", [shareAssetStr, "DEFI"], nil)
281284                             if ((addLabel == addLabel))
282285                                 then [StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks)), StringEntry(keyMappingsInternal2baseAssetId(internalBaseAssettId), baseAssetStr), StringEntry(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StringEntry(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StringEntry(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownPutOperation(internalBaseAssetStr), false), StringEntry(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntegerEntry(keyNextInternalAssetId(), (internalBaseAssettId + 1)), IntegerEntry(keyPriceLast(internalBaseAssetStr), startPrice), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), shareAssetIssueAction, Burn(shareAssetId, 1), StringEntry(keyProxyAddress(baseAssetStr), proxyAddress)]
283286                                 else throw("Strict value is not equal to itself.")
284287                             }
285288                         else throw("Strict value is not equal to itself.")
286289                     }
287290         else throw("Strict value is not equal to itself.")
288291     }
289292 
290293 
291294 
292295 @Callable(i)
293296 func shutdownPut (internalBaseAssetId) = {
294297     let internalBaseAssetIdStr = toString(internalBaseAssetId)
295298     let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
296299     let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
297300     if ((1 > size(baseAssetIdStr)))
298301         then throw("invalid internalBaseAssetId")
299302         else if ((toString(i.caller) != shutdownManagerAddress))
300303             then throw("access denied")
301304             else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
302305     }
303306 
304307 
305308 
306309 @Callable(i)
307310 func put () = {
308311     let pmt = value(i.payments[0])
309312     let baseAssetId = value(pmt.assetId)
310313     let baseAssetStr = toBase58String(baseAssetId)
311314     let userAddressStr = toString(i.caller)
312315     let cfgArray = readAssetCfgOrFail(baseAssetStr)
313316     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
314317     let shareAssetId = fromBase58String(shareAssetStr)
315318     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
316319     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
317320     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
318321     let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
319322     if (isPutBlocked)
320323         then throw("put operation is blocked")
321324         else {
322325             let newBalance = (balanceOrZero(baseAssetStr) + pmt.amount)
323326             let price = getPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
324327             let shareAssetAmount = fraction(pmt.amount, decimalsMultPrice, price, CEILING)
325328 [Reissue(shareAssetId, shareAssetAmount, true), ScriptTransfer(i.caller, shareAssetAmount, shareAssetId), StringEntry(keyOperation("P", internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("FINISHED", pmt.amount, price, shareAssetAmount, height, lastBlock.timestamp, height, lastBlock.timestamp)), ScriptTransfer(addressFromStringValue(value(getString(keyProxyAddress(baseAssetStr)))), pmt.amount, baseAssetId), IntegerEntry(keyBalance(baseAssetStr), newBalance)]
326329             }
327330     }
328331 
329332 
330333 
331334 @Callable(i)
332335 func submitGetRequest () = {
333336     let pmt = value(i.payments[0])
334337     let shareAssetId = value(pmt.assetId)
335338     let shareAssetStr = toBase58String(shareAssetId)
336339     let callerPubStr = toBase58String(i.callerPublicKey)
337340     let userAddress = i.caller
338341     let userAddressStr = toString(userAddress)
339342     let shareAssetAmount = pmt.amount
340343     let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
341344     let baseAssetId = fromBase58String(baseAssetStr)
342345     let cfgArray = readAssetCfgOrFail(baseAssetStr)
343346     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
344347     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
345348     let getDelayBlocks = parseIntValue(cfgArray[IdxCfgGetDelayBlocks])
346349     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
347350     let price = getPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
348351     let baseAssetAmount = fraction(shareAssetAmount, price, decimalsMultPrice)
349352     let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId))
350353     let operationData = dataOperation("PENDING", shareAssetAmount, price, baseAssetAmount, height, lastBlock.timestamp, (height + getDelayBlocks), 0)
351354 [Burn(shareAssetId, shareAssetAmount), StringEntry(operationKey, operationData), incrementTotalLocked(keyTotalLocked(internalBaseAssetStr), shareAssetAmount, baseAssetAmount), incrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), shareAssetAmount, baseAssetAmount), IntegerEntry(keyBalance(baseAssetStr), (balanceOrZero(baseAssetStr) - baseAssetAmount))]
352355     }
353356 
354357 
355358 
356359 @Callable(i)
357360 func executeGetRequest (baseAssetStr,userAddressStr,getTxIdStr) = {
358361     let userAddress = addressFromStringValue(userAddressStr)
359362     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
360363     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
361364     let baseAssetId = fromBase58String(baseAssetStr)
362365     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
363366     let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, getTxIdStr)
364367     let operationArray = split(getStringOrFail(operationKey), SEP)
365368     let status = operationArray[IdxOperStatus]
366369     let endHeight = parseIntValue(operationArray[IdxOperEndHeight])
367370     let inShareAmount = parseIntValue(operationArray[IdxOperInAmount])
368371     let outBaseAmount = parseIntValue(operationArray[IdxOperOutAmount])
369372     if ((status != "PENDING"))
370373         then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, getTxIdStr)
371374         else if ((endHeight > height))
372375             then failExecuteGet(((("EndHeight[" + toString(endHeight)) + "] > ") + toString(height)), baseAssetStr, userAddressStr, getTxIdStr)
373376             else [ScriptTransfer(userAddress, outBaseAmount, baseAssetId), StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", lastBlock.timestamp)), decrementTotalLocked(keyTotalLocked(internalBaseAssetStr), inShareAmount, outBaseAmount), decrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), inShareAmount, outBaseAmount)]
374377     }
375378 
376379 
377380 
378381 @Callable(i)
379382 func topUpBalance (baseAssetStr,delta) = {
380383     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
381384     let pmt = value(i.payments[0])
382385     let pmtAssetId = value(pmt.assetId)
383386     let pmtAssetStr = toBase58String(pmtAssetId)
384387     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
385388     let decimalsMultBothAssets = parseIntValue(assetCfgArray[IdxCfgDecimalsMultBothAssets])
386389     let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
387390     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
388391     let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
389392     let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
390393     let checks = [mustProxyAddress(i, baseAssetStr), if ((topUpLastHeight != height))
391394         then true
392395         else throw("only one topUp per block is allowed"), if ((delta > 0))
393396         then true
394397         else throw("only positive delta is allowed")]
395398     if ((checks == checks))
396399         then if ((baseAssetStr != pmtAssetStr))
397400             then throw("attached payment's asset id is NOT matched passed baseAssetStr")
398401             else if ((size(i.payments) > 1))
399402                 then throw("only one payment can be attached")
400403                 else {
401404                     let price = calcPrice(internalBaseAssetStr, pmtAssetId, delta, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
402405 [IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(topUpLastHeightKEY, height), IntegerEntry(keyBalance(pmtAssetStr), (balanceOrZero(pmtAssetStr) + delta))]
403406                     }
404407         else throw("Strict value is not equal to itself.")
405408     }
406409 
407410 
408411 
409412 @Callable(i)
410413 func currentSysParamsREST (baseAssetStr) = {
411414     let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
412415     let price = sysStateTuple._1.value
413416     let decimalsMultPrice = sysStateTuple._2.value
414417     let baseAssetBalance = sysStateTuple._3.value
415418     let totalLockedBaseAmount = sysStateTuple._4.value
416419     let baseAssetBalanceConsideringLock = sysStateTuple._5.value
417420     let shareEmission = sysStateTuple._6.value
418421     let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceConsideringLock), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
419422     throw(restData)
420423     }
421424 
422425 
423426 
424427 @Callable(i)
425428 func setManager (pendingManagerPublicKey) = {
426429     let checkCaller = mustManager(i)
427430     if ((checkCaller == checkCaller))
428431         then {
429432             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
430433             if ((checkManagerPublicKey == checkManagerPublicKey))
431434                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
432435                 else throw("Strict value is not equal to itself.")
433436             }
434437         else throw("Strict value is not equal to itself.")
435438     }
436439 
437440 
438441 
439442 @Callable(i)
440443 func confirmManager () = {
441444     let pm = pendingManagerPublicKeyOrUnit()
442445     let hasPM = if (isDefined(pm))
443446         then true
444447         else throw("no pending manager")
445448     if ((hasPM == hasPM))
446449         then {
447450             let checkPM = if ((i.callerPublicKey == value(pm)))
448451                 then true
449452                 else throw("you are not pending manager")
450453             if ((checkPM == checkPM))
451454                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
452455                 else throw("Strict value is not equal to itself.")
453456             }
454457         else throw("Strict value is not equal to itself.")
455458     }
456459 
457460 
458461 @Verifier(tx)
459462 func verify () = {
460463     let targetPublicKey =     match managerPublicKeyOrUnit() {
461464         case pk: ByteVector => 
462465             pk
463466         case _: Unit => 
464467             tx.senderPublicKey
465468         case _ => 
466469             throw("Match error")
467470     }
468471     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
469472     }
470473 
github/deemru/w8io/169f3d6 
67.99 ms ◑