w8 · tx · DKx···mWy

tx · DKxyAgX2ubtyYE6nAwvpw2t3JdQmVy9x36YuCS9W2mWy

3Mzt645zA6u2QG6jRPoo6H6CK89kVggFgNi:  -0.02500000 Waves

2022.06.07 15:34 [2085952] smart account 3Mzt645zA6u2QG6jRPoo6H6CK89kVggFgNi > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DKxyAgX2ubtyYE6nAwvpw2t3JdQmVy9x36YuCS9W2mWy",
    "fee": 2500000,
    "feeAssetId": null,
    "timestamp": 1654605370791,
    "version": 1,
    "sender": "3Mzt645zA6u2QG6jRPoo6H6CK89kVggFgNi",
    "senderPublicKey": "7uejFa4bRSfBcedNiZpvC7nH9dnudVtejqqd8Rq4o8Ay",
    "proofs": [
        "21UyqyvvEXBVZ4SUShdiDyB1275MfzW5oqMwca7GMbyNLrSNtjN1agWiqq3g2SMHYGYWjcG94A4qUXsGVb2o7dgn"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2085952,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 65remLvToC36SH7VaK6p9MCsrzbBAgEb247SjKueYXQg
Next: none

Full: 
Old New Differences
1 - # no script
1 + {-# STDLIB_VERSION 5 #-}
2 + {-# SCRIPT_TYPE ACCOUNT #-}
3 + {-# CONTENT_TYPE DAPP #-}
4 + let SEP = "__"
5 + 
6 + func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
7 + 
8 + 
9 + func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
10 + 
11 + 
12 + func failExecuteGet (msg,baseAssetStr,userAddressStr,getTxIdStr) = throw(((((((msg + ": baseAssetStr=") + baseAssetStr) + " userAddressStr=") + userAddressStr) + " getTxIdStr=") + getTxIdStr))
13 + 
14 + 
15 + func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
16 + 
17 + 
18 + func keyNextInternalAssetId () = "%s__nextInternalAssetId"
19 + 
20 + 
21 + func keyPriceLast (internalBasetAssetStr) = ("%s%s%d__price__last__" + internalBasetAssetStr)
22 + 
23 + 
24 + func keyTopUpLastHeight (internalBasetAssetStr,sender) = makeString(["%s%s%s%d%s__topup__last__height", internalBasetAssetStr, sender], SEP)
25 + 
26 + 
27 + func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
28 + 
29 + 
30 + func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
31 + 
32 + 
33 + func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
34 + 
35 + 
36 + func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
37 + 
38 + 
39 + func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
40 + 
41 + 
42 + func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
43 + 
44 + 
45 + func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
46 + 
47 + 
48 + func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
49 + 
50 + 
51 + func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
52 + 
53 + 
54 + func keyManagerPublicKey () = "%s__managerPublicKey"
55 + 
56 + 
57 + func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
58 + 
59 + 
60 + let IdxCfgShareAssetId = 1
61 + 
62 + let IdxCfgInternalBaseAsset = 2
63 + 
64 + let IdxCfgDecimalsMultBothAssets = 3
65 + 
66 + let IdxCfgDecimalsMultPrice = 4
67 + 
68 + let IdxCfgGetDelayBlocks = 5
69 + 
70 + func dataAssetCfg (shareAssetStr,internalBaseAssetStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks) = makeString(["%s%d%d%d%d", shareAssetStr, internalBaseAssetStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks)], SEP)
71 + 
72 + 
73 + let IdxTotalLockedShare = 1
74 + 
75 + let IdxTotalLockedBase = 2
76 + 
77 + func dataTotalLocked (shareAssetAmount,baseAssetAmount) = makeString(["%d%d", toString(shareAssetAmount), toString(baseAssetAmount)], SEP)
78 + 
79 + 
80 + func readTotalLocked (key) = {
81 +     let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0)), SEP)
82 + [-1, parseIntValue(totalLockedArray[IdxTotalLockedShare]), parseIntValue(totalLockedArray[IdxTotalLockedBase])]
83 +     }
84 + 
85 + 
86 + func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
87 + 
88 + 
89 + let IdxOperStatus = 1
90 + 
91 + let IdxOperInAmount = 2
92 + 
93 + let IdxOperPrice = 3
94 + 
95 + let IdxOperOutAmount = 4
96 + 
97 + let IdxOperStartHeight = 5
98 + 
99 + let IdxOperStartTimestamp = 6
100 + 
101 + let IdxOperEndHeight = 7
102 + 
103 + let IdxOperEndTimestamp = 8
104 + 
105 + 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)
106 + 
107 + 
108 + 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))
109 + 
110 + 
111 + func dataOperationExecutionUpdate (currOperArray,newStatus,newEndTimestamp) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], currOperArray[IdxOperPrice], currOperArray[IdxOperOutAmount], currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], currOperArray[IdxOperEndHeight], toString(newEndTimestamp))
112 + 
113 + 
114 + func readAssetCfgOrFail (baseAssetStr) = {
115 +     let key = keyAssetCfg(baseAssetStr)
116 +     split(getStringOrFail(key), SEP)
117 +     }
118 + 
119 + 
120 + func incrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
121 +     let dataArray = readTotalLocked(key)
122 +     StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] + shareAssetAmount), (dataArray[IdxTotalLockedBase] + baseAssetAmount)))
123 +     }
124 + 
125 + 
126 + func decrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
127 +     let dataArray = readTotalLocked(key)
128 +     StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] - shareAssetAmount), (dataArray[IdxTotalLockedBase] - baseAssetAmount)))
129 +     }
130 + 
131 + 
132 + func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = {
133 +     let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
134 +     let totalLockedBaseAmount = totalLockedArray[IdxTotalLockedBase]
135 +     let baseAssetBalance = assetBalance(this, baseAssetId)
136 +     let baseAssetBalanceConsideringLock = ((baseAssetBalance - totalLockedBaseAmount) + topUpBaseAmount)
137 +     if ((0 > baseAssetBalanceConsideringLock))
138 +         then throw(((("baseAssetBalanceConsideringLock < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceConsideringLock=") + toString(baseAssetBalanceConsideringLock)))
139 +         else {
140 +             let shareEmission = value(assetInfo(shareAssetId)).quantity
141 +             let price = if ((shareEmission == 0))
142 +                 then (1 * decimalsMultPrice)
143 +                 else fraction(baseAssetBalanceConsideringLock, decimalsMultPrice, shareEmission)
144 +             $Tuple5(price, baseAssetBalance, totalLockedBaseAmount, baseAssetBalanceConsideringLock, shareEmission)
145 +             }
146 +     }
147 + 
148 + 
149 + func calcPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = genericCalcPrice(internalBaseAssetStr, baseAssetId, 0, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)
150 + 
151 + 
152 + func privateCurrentSysParamsREST (baseAssetStr) = {
153 +     let baseAssetId = fromBase58String(baseAssetStr)
154 +     let cfgArray = readAssetCfgOrFail(baseAssetStr)
155 +     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
156 +     let shareAssetId = fromBase58String(shareAssetStr)
157 +     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
158 +     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
159 +     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
160 +     let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)
161 +     $Tuple6(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("totalLockedBaseAmount", sysState._3), IntegerEntry("baseAssetBalanceConsideringLock", sysState._4), IntegerEntry("shareEmission", sysState._5))
162 +     }
163 + 
164 + 
165 + func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
166 +     case s: String => 
167 +         fromBase58String(s)
168 +     case _: Unit => 
169 +         unit
170 +     case _ => 
171 +         throw("Match error")
172 + }
173 + 
174 + 
175 + func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
176 +     case s: String => 
177 +         fromBase58String(s)
178 +     case _: Unit => 
179 +         unit
180 +     case _ => 
181 +         throw("Match error")
182 + }
183 + 
184 + 
185 + func mustManager (i) = {
186 +     let pd = throw("Permission denied")
187 +     match managerPublicKeyOrUnit() {
188 +         case pk: ByteVector => 
189 +             if ((i.callerPublicKey == pk))
190 +                 then true
191 +                 else pd
192 +         case _: Unit => 
193 +             if ((i.caller == this))
194 +                 then true
195 +                 else pd
196 +         case _ => 
197 +             throw("Match error")
198 +     }
199 +     }
200 + 
201 + 
202 + @Callable(i)
203 + func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress) = {
204 +     let baseAssetId = fromBase58String(baseAssetStr)
205 +     let decimals = value(assetInfo(baseAssetId)).decimals
206 +     if ((i.caller != this))
207 +         then throw("permissions denied")
208 +         else if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
209 +             then throw("invalid shutdownManagerAddress")
210 +             else if ((0 > getDelayinBlocks))
211 +                 then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
212 +                 else {
213 +                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, 1, decimals, true)
214 +                     let shareAssetId = calculateAssetId(shareAssetIssueAction)
215 +                     let shareAssetStr = toBase58String(shareAssetId)
216 +                     let decimalsMultPrice = ((100 * 1000) * 1000)
217 +                     let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
218 +                     let startPrice = (1 * decimalsMultPrice)
219 +                     let internalBaseAssettId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
220 +                     let internalBaseAssetStr = toString(internalBaseAssettId)
221 + [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)]
222 +                     }
223 +     }
224 + 
225 + 
226 + 
227 + @Callable(i)
228 + func shutdownPut (internalBaseAssetId) = {
229 +     let internalBaseAssetIdStr = toString(internalBaseAssetId)
230 +     let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
231 +     let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
232 +     if ((1 > size(baseAssetIdStr)))
233 +         then throw("invalid internalBaseAssetId")
234 +         else if ((toString(i.caller) != shutdownManagerAddress))
235 +             then throw("access denied")
236 +             else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
237 +     }
238 + 
239 + 
240 + 
241 + @Callable(i)
242 + func put () = {
243 +     let pmt = value(i.payments[0])
244 +     let baseAssetId = value(pmt.assetId)
245 +     let baseAssetStr = toBase58String(baseAssetId)
246 +     let userAddressStr = toString(i.caller)
247 +     let cfgArray = readAssetCfgOrFail(baseAssetStr)
248 +     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
249 +     let shareAssetId = fromBase58String(shareAssetStr)
250 +     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
251 +     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
252 +     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
253 +     let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
254 +     if (isPutBlocked)
255 +         then throw("put operation is blocked")
256 +         else {
257 +             let price = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
258 +             let shareAssetAmount = fraction(pmt.amount, decimalsMultPrice, price)
259 + [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))]
260 +             }
261 +     }
262 + 
263 + 
264 + 
265 + @Callable(i)
266 + func submitGetRequest () = {
267 +     let pmt = value(i.payments[0])
268 +     let shareAssetId = value(pmt.assetId)
269 +     let shareAssetStr = toBase58String(shareAssetId)
270 +     let callerPubStr = toBase58String(i.callerPublicKey)
271 +     let userAddress = i.caller
272 +     let userAddressStr = toString(userAddress)
273 +     let shareAssetAmount = pmt.amount
274 +     let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
275 +     let baseAssetId = fromBase58String(baseAssetStr)
276 +     let cfgArray = readAssetCfgOrFail(baseAssetStr)
277 +     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
278 +     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
279 +     let getDelayBlocks = parseIntValue(cfgArray[IdxCfgGetDelayBlocks])
280 +     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
281 +     let price = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
282 +     let baseAssetAmount = fraction(shareAssetAmount, price, decimalsMultPrice)
283 +     let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId))
284 +     let operationData = dataOperation("PENDING", shareAssetAmount, price, baseAssetAmount, height, lastBlock.timestamp, (height + getDelayBlocks), 0)
285 + [Burn(shareAssetId, shareAssetAmount), StringEntry(operationKey, operationData), incrementTotalLocked(keyTotalLocked(internalBaseAssetStr), shareAssetAmount, baseAssetAmount), incrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), shareAssetAmount, baseAssetAmount)]
286 +     }
287 + 
288 + 
289 + 
290 + @Callable(i)
291 + func executeGetRequest (baseAssetStr,userAddressStr,getTxIdStr) = {
292 +     let userAddress = addressFromStringValue(userAddressStr)
293 +     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
294 +     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
295 +     let baseAssetId = fromBase58String(baseAssetStr)
296 +     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
297 +     let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, getTxIdStr)
298 +     let operationArray = split(getStringOrFail(operationKey), SEP)
299 +     let status = operationArray[IdxOperStatus]
300 +     let endHeight = parseIntValue(operationArray[IdxOperEndHeight])
301 +     let inShareAmount = parseIntValue(operationArray[IdxOperInAmount])
302 +     let outBaseAmount = parseIntValue(operationArray[IdxOperOutAmount])
303 +     if ((status != "PENDING"))
304 +         then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, getTxIdStr)
305 +         else if ((endHeight > height))
306 +             then failExecuteGet(((("EndHeight[" + toString(endHeight)) + "] > ") + toString(height)), baseAssetStr, userAddressStr, getTxIdStr)
307 +             else [ScriptTransfer(userAddress, outBaseAmount, baseAssetId), StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", lastBlock.timestamp)), decrementTotalLocked(keyTotalLocked(internalBaseAssetStr), inShareAmount, outBaseAmount), decrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), inShareAmount, outBaseAmount)]
308 +     }
309 + 
310 + 
311 + 
312 + @Callable(i)
313 + func topUpBalance (baseAssetStr) = {
314 +     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
315 +     let pmt = value(i.payments[0])
316 +     let pmtAssetId = value(pmt.assetId)
317 +     let pmtAssetStr = toBase58String(pmtAssetId)
318 +     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
319 +     let decimalsMultBothAssets = parseIntValue(assetCfgArray[IdxCfgDecimalsMultBothAssets])
320 +     let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
321 +     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
322 +     let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
323 +     let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
324 +     if ((baseAssetStr != pmtAssetStr))
325 +         then throw("attached payment's asset id is NOT matched passed baseAssetStr")
326 +         else if ((size(i.payments) > 1))
327 +             then throw("only one payment can be attached")
328 +             else if ((100 > (height - topUpLastHeight)))
329 +                 then throw("1 topUp per 100 blocks from the same address is allowed")
330 +                 else {
331 +                     let price = genericCalcPrice(internalBaseAssetStr, pmtAssetId, pmt.amount, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
332 + [IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(topUpLastHeightKEY, height)]
333 +                     }
334 +     }
335 + 
336 + 
337 + 
338 + @Callable(i)
339 + func currentSysParamsREST (baseAssetStr) = {
340 +     let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
341 +     let price = sysStateTuple._1.value
342 +     let decimalsMultPrice = sysStateTuple._2.value
343 +     let baseAssetBalance = sysStateTuple._3.value
344 +     let totalLockedBaseAmount = sysStateTuple._4.value
345 +     let baseAssetBalanceConsideringLock = sysStateTuple._5.value
346 +     let shareEmission = sysStateTuple._6.value
347 +     let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceConsideringLock), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
348 +     throw(restData)
349 +     }
350 + 
351 + 
352 + 
353 + @Callable(i)
354 + func setManager (pendingManagerPublicKey) = {
355 +     let checkCaller = mustManager(i)
356 +     if ((checkCaller == checkCaller))
357 +         then {
358 +             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
359 +             if ((checkManagerPublicKey == checkManagerPublicKey))
360 +                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
361 +                 else throw("Strict value is not equal to itself.")
362 +             }
363 +         else throw("Strict value is not equal to itself.")
364 +     }
365 + 
366 + 
367 + 
368 + @Callable(i)
369 + func confirmManager () = {
370 +     let pm = pendingManagerPublicKeyOrUnit()
371 +     let hasPM = if (isDefined(pm))
372 +         then true
373 +         else throw("No pending manager")
374 +     if ((hasPM == hasPM))
375 +         then {
376 +             let checkPM = if ((i.callerPublicKey == value(pm)))
377 +                 then true
378 +                 else throw("You are not pending manager")
379 +             if ((checkPM == checkPM))
380 +                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
381 +                 else throw("Strict value is not equal to itself.")
382 +             }
383 +         else throw("Strict value is not equal to itself.")
384 +     }
385 + 
386 + 
387 + @Verifier(tx)
388 + func verify () = {
389 +     let targetPublicKey =     match managerPublicKeyOrUnit() {
390 +         case pk: ByteVector => 
391 +             pk
392 +         case _: Unit => 
393 +             tx.senderPublicKey
394 +         case _ => 
395 +             throw("Match error")
396 +     }
397 +     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
398 +     }
399 +

Old	New		Differences
1		-	# no script
	1	+	{-# STDLIB_VERSION 5 #-}
	2	+	{-# SCRIPT_TYPE ACCOUNT #-}
	3	+	{-# CONTENT_TYPE DAPP #-}
	4	+	let SEP = "__"
	5	+
	6	+	func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
	7	+
	8	+
	9	+	func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
	10	+
	11	+
	12	+	func failExecuteGet (msg,baseAssetStr,userAddressStr,getTxIdStr) = throw(((((((msg + ": baseAssetStr=") + baseAssetStr) + " userAddressStr=") + userAddressStr) + " getTxIdStr=") + getTxIdStr))
	13	+
	14	+
	15	+	func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
	16	+
	17	+
	18	+	func keyNextInternalAssetId () = "%s__nextInternalAssetId"
	19	+
	20	+
	21	+	func keyPriceLast (internalBasetAssetStr) = ("%s%s%d__price__last__" + internalBasetAssetStr)
	22	+
	23	+
	24	+	func keyTopUpLastHeight (internalBasetAssetStr,sender) = makeString(["%s%s%s%d%s__topup__last__height", internalBasetAssetStr, sender], SEP)
	25	+
	26	+
	27	+	func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
	28	+
	29	+
	30	+	func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
	31	+
	32	+
	33	+	func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
	34	+
	35	+
	36	+	func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
	37	+
	38	+
	39	+	func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
	40	+
	41	+
	42	+	func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
	43	+
	44	+
	45	+	func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
	46	+
	47	+
	48	+	func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
	49	+
	50	+
	51	+	func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
	52	+
	53	+
	54	+	func keyManagerPublicKey () = "%s__managerPublicKey"
	55	+
	56	+
	57	+	func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
	58	+
	59	+
	60	+	let IdxCfgShareAssetId = 1
	61	+
	62	+	let IdxCfgInternalBaseAsset = 2
	63	+
	64	+	let IdxCfgDecimalsMultBothAssets = 3
	65	+
	66	+	let IdxCfgDecimalsMultPrice = 4
	67	+
	68	+	let IdxCfgGetDelayBlocks = 5
	69	+
	70	+	func dataAssetCfg (shareAssetStr,internalBaseAssetStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks) = makeString(["%s%d%d%d%d", shareAssetStr, internalBaseAssetStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks)], SEP)
	71	+
	72	+
	73	+	let IdxTotalLockedShare = 1
	74	+
	75	+	let IdxTotalLockedBase = 2
	76	+
	77	+	func dataTotalLocked (shareAssetAmount,baseAssetAmount) = makeString(["%d%d", toString(shareAssetAmount), toString(baseAssetAmount)], SEP)
	78	+
	79	+
	80	+	func readTotalLocked (key) = {
	81	+	let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0)), SEP)
	82	+	[-1, parseIntValue(totalLockedArray[IdxTotalLockedShare]), parseIntValue(totalLockedArray[IdxTotalLockedBase])]
	83	+	}
	84	+
	85	+
	86	+	func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
	87	+
	88	+
	89	+	let IdxOperStatus = 1
	90	+
	91	+	let IdxOperInAmount = 2
	92	+
	93	+	let IdxOperPrice = 3
	94	+
	95	+	let IdxOperOutAmount = 4
	96	+
	97	+	let IdxOperStartHeight = 5
	98	+
	99	+	let IdxOperStartTimestamp = 6
	100	+
	101	+	let IdxOperEndHeight = 7
	102	+
	103	+	let IdxOperEndTimestamp = 8
	104	+
	105	+	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)
	106	+
	107	+
	108	+	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))
	109	+
	110	+
	111	+	func dataOperationExecutionUpdate (currOperArray,newStatus,newEndTimestamp) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], currOperArray[IdxOperPrice], currOperArray[IdxOperOutAmount], currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], currOperArray[IdxOperEndHeight], toString(newEndTimestamp))
	112	+
	113	+
	114	+	func readAssetCfgOrFail (baseAssetStr) = {
	115	+	let key = keyAssetCfg(baseAssetStr)
	116	+	split(getStringOrFail(key), SEP)
	117	+	}
	118	+
	119	+
	120	+	func incrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
	121	+	let dataArray = readTotalLocked(key)
	122	+	StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] + shareAssetAmount), (dataArray[IdxTotalLockedBase] + baseAssetAmount)))
	123	+	}
	124	+
	125	+
	126	+	func decrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
	127	+	let dataArray = readTotalLocked(key)
	128	+	StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] - shareAssetAmount), (dataArray[IdxTotalLockedBase] - baseAssetAmount)))
	129	+	}
	130	+
	131	+
	132	+	func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = {
	133	+	let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
	134	+	let totalLockedBaseAmount = totalLockedArray[IdxTotalLockedBase]
	135	+	let baseAssetBalance = assetBalance(this, baseAssetId)
	136	+	let baseAssetBalanceConsideringLock = ((baseAssetBalance - totalLockedBaseAmount) + topUpBaseAmount)
	137	+	if ((0 > baseAssetBalanceConsideringLock))
	138	+	then throw(((("baseAssetBalanceConsideringLock < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceConsideringLock=") + toString(baseAssetBalanceConsideringLock)))
	139	+	else {
	140	+	let shareEmission = value(assetInfo(shareAssetId)).quantity
	141	+	let price = if ((shareEmission == 0))
	142	+	then (1 * decimalsMultPrice)
	143	+	else fraction(baseAssetBalanceConsideringLock, decimalsMultPrice, shareEmission)
	144	+	$Tuple5(price, baseAssetBalance, totalLockedBaseAmount, baseAssetBalanceConsideringLock, shareEmission)
	145	+	}
	146	+	}
	147	+
	148	+
	149	+	func calcPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = genericCalcPrice(internalBaseAssetStr, baseAssetId, 0, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)
	150	+
	151	+
	152	+	func privateCurrentSysParamsREST (baseAssetStr) = {
	153	+	let baseAssetId = fromBase58String(baseAssetStr)
	154	+	let cfgArray = readAssetCfgOrFail(baseAssetStr)
	155	+	let shareAssetStr = cfgArray[IdxCfgShareAssetId]
	156	+	let shareAssetId = fromBase58String(shareAssetStr)
	157	+	let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
	158	+	let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
	159	+	let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
	160	+	let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)
	161	+	$Tuple6(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("totalLockedBaseAmount", sysState._3), IntegerEntry("baseAssetBalanceConsideringLock", sysState._4), IntegerEntry("shareEmission", sysState._5))
	162	+	}
	163	+
	164	+
	165	+	func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
	166	+	case s: String =>
	167	+	fromBase58String(s)
	168	+	case _: Unit =>
	169	+	unit
	170	+	case _ =>
	171	+	throw("Match error")
	172	+	}
	173	+
	174	+
	175	+	func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
	176	+	case s: String =>
	177	+	fromBase58String(s)
	178	+	case _: Unit =>
	179	+	unit
	180	+	case _ =>
	181	+	throw("Match error")
	182	+	}
	183	+
	184	+
	185	+	func mustManager (i) = {
	186	+	let pd = throw("Permission denied")
	187	+	match managerPublicKeyOrUnit() {
	188	+	case pk: ByteVector =>
	189	+	if ((i.callerPublicKey == pk))
	190	+	then true
	191	+	else pd
	192	+	case _: Unit =>
	193	+	if ((i.caller == this))
	194	+	then true
	195	+	else pd
	196	+	case _ =>
	197	+	throw("Match error")
	198	+	}
	199	+	}
	200	+
	201	+
	202	+	@Callable(i)
	203	+	func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress) = {
	204	+	let baseAssetId = fromBase58String(baseAssetStr)
	205	+	let decimals = value(assetInfo(baseAssetId)).decimals
	206	+	if ((i.caller != this))
	207	+	then throw("permissions denied")
	208	+	else if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
	209	+	then throw("invalid shutdownManagerAddress")
	210	+	else if ((0 > getDelayinBlocks))
	211	+	then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
	212	+	else {
	213	+	let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, 1, decimals, true)
	214	+	let shareAssetId = calculateAssetId(shareAssetIssueAction)
	215	+	let shareAssetStr = toBase58String(shareAssetId)
	216	+	let decimalsMultPrice = ((100 * 1000) * 1000)
	217	+	let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
	218	+	let startPrice = (1 * decimalsMultPrice)
	219	+	let internalBaseAssettId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
	220	+	let internalBaseAssetStr = toString(internalBaseAssettId)
	221	+	[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)]
	222	+	}
	223	+	}
	224	+
	225	+
	226	+
	227	+	@Callable(i)
	228	+	func shutdownPut (internalBaseAssetId) = {
	229	+	let internalBaseAssetIdStr = toString(internalBaseAssetId)
	230	+	let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
	231	+	let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
	232	+	if ((1 > size(baseAssetIdStr)))
	233	+	then throw("invalid internalBaseAssetId")
	234	+	else if ((toString(i.caller) != shutdownManagerAddress))
	235	+	then throw("access denied")
	236	+	else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
	237	+	}
	238	+
	239	+
	240	+
	241	+	@Callable(i)
	242	+	func put () = {
	243	+	let pmt = value(i.payments[0])
	244	+	let baseAssetId = value(pmt.assetId)
	245	+	let baseAssetStr = toBase58String(baseAssetId)
	246	+	let userAddressStr = toString(i.caller)
	247	+	let cfgArray = readAssetCfgOrFail(baseAssetStr)
	248	+	let shareAssetStr = cfgArray[IdxCfgShareAssetId]
	249	+	let shareAssetId = fromBase58String(shareAssetStr)
	250	+	let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
	251	+	let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
	252	+	let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
	253	+	let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
	254	+	if (isPutBlocked)
	255	+	then throw("put operation is blocked")
	256	+	else {
	257	+	let price = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
	258	+	let shareAssetAmount = fraction(pmt.amount, decimalsMultPrice, price)
	259	+	[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))]
	260	+	}
	261	+	}
	262	+
	263	+
	264	+
	265	+	@Callable(i)
	266	+	func submitGetRequest () = {
	267	+	let pmt = value(i.payments[0])
	268	+	let shareAssetId = value(pmt.assetId)
	269	+	let shareAssetStr = toBase58String(shareAssetId)
	270	+	let callerPubStr = toBase58String(i.callerPublicKey)
	271	+	let userAddress = i.caller
	272	+	let userAddressStr = toString(userAddress)
	273	+	let shareAssetAmount = pmt.amount
	274	+	let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
	275	+	let baseAssetId = fromBase58String(baseAssetStr)
	276	+	let cfgArray = readAssetCfgOrFail(baseAssetStr)
	277	+	let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
	278	+	let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
	279	+	let getDelayBlocks = parseIntValue(cfgArray[IdxCfgGetDelayBlocks])
	280	+	let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
	281	+	let price = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
	282	+	let baseAssetAmount = fraction(shareAssetAmount, price, decimalsMultPrice)
	283	+	let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId))
	284	+	let operationData = dataOperation("PENDING", shareAssetAmount, price, baseAssetAmount, height, lastBlock.timestamp, (height + getDelayBlocks), 0)
	285	+	[Burn(shareAssetId, shareAssetAmount), StringEntry(operationKey, operationData), incrementTotalLocked(keyTotalLocked(internalBaseAssetStr), shareAssetAmount, baseAssetAmount), incrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), shareAssetAmount, baseAssetAmount)]
	286	+	}
	287	+
	288	+
	289	+
	290	+	@Callable(i)
	291	+	func executeGetRequest (baseAssetStr,userAddressStr,getTxIdStr) = {
	292	+	let userAddress = addressFromStringValue(userAddressStr)
	293	+	let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
	294	+	let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
	295	+	let baseAssetId = fromBase58String(baseAssetStr)
	296	+	let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
	297	+	let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, getTxIdStr)
	298	+	let operationArray = split(getStringOrFail(operationKey), SEP)
	299	+	let status = operationArray[IdxOperStatus]
	300	+	let endHeight = parseIntValue(operationArray[IdxOperEndHeight])
	301	+	let inShareAmount = parseIntValue(operationArray[IdxOperInAmount])
	302	+	let outBaseAmount = parseIntValue(operationArray[IdxOperOutAmount])
	303	+	if ((status != "PENDING"))
	304	+	then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, getTxIdStr)
	305	+	else if ((endHeight > height))
	306	+	then failExecuteGet(((("EndHeight[" + toString(endHeight)) + "] > ") + toString(height)), baseAssetStr, userAddressStr, getTxIdStr)
	307	+	else [ScriptTransfer(userAddress, outBaseAmount, baseAssetId), StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", lastBlock.timestamp)), decrementTotalLocked(keyTotalLocked(internalBaseAssetStr), inShareAmount, outBaseAmount), decrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), inShareAmount, outBaseAmount)]
	308	+	}
	309	+
	310	+
	311	+
	312	+	@Callable(i)
	313	+	func topUpBalance (baseAssetStr) = {
	314	+	let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
	315	+	let pmt = value(i.payments[0])
	316	+	let pmtAssetId = value(pmt.assetId)
	317	+	let pmtAssetStr = toBase58String(pmtAssetId)
	318	+	let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
	319	+	let decimalsMultBothAssets = parseIntValue(assetCfgArray[IdxCfgDecimalsMultBothAssets])
	320	+	let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
	321	+	let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
	322	+	let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
	323	+	let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
	324	+	if ((baseAssetStr != pmtAssetStr))
	325	+	then throw("attached payment's asset id is NOT matched passed baseAssetStr")
	326	+	else if ((size(i.payments) > 1))
	327	+	then throw("only one payment can be attached")
	328	+	else if ((100 > (height - topUpLastHeight)))
	329	+	then throw("1 topUp per 100 blocks from the same address is allowed")
	330	+	else {
	331	+	let price = genericCalcPrice(internalBaseAssetStr, pmtAssetId, pmt.amount, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
	332	+	[IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(topUpLastHeightKEY, height)]
	333	+	}
	334	+	}
	335	+
	336	+
	337	+
	338	+	@Callable(i)
	339	+	func currentSysParamsREST (baseAssetStr) = {
	340	+	let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
	341	+	let price = sysStateTuple._1.value
	342	+	let decimalsMultPrice = sysStateTuple._2.value
	343	+	let baseAssetBalance = sysStateTuple._3.value
	344	+	let totalLockedBaseAmount = sysStateTuple._4.value
	345	+	let baseAssetBalanceConsideringLock = sysStateTuple._5.value
	346	+	let shareEmission = sysStateTuple._6.value
	347	+	let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceConsideringLock), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
	348	+	throw(restData)
	349	+	}
	350	+
	351	+
	352	+
	353	+	@Callable(i)
	354	+	func setManager (pendingManagerPublicKey) = {
	355	+	let checkCaller = mustManager(i)
	356	+	if ((checkCaller == checkCaller))
	357	+	then {
	358	+	let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
	359	+	if ((checkManagerPublicKey == checkManagerPublicKey))
	360	+	then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
	361	+	else throw("Strict value is not equal to itself.")
	362	+	}
	363	+	else throw("Strict value is not equal to itself.")
	364	+	}
	365	+
	366	+
	367	+
	368	+	@Callable(i)
	369	+	func confirmManager () = {
	370	+	let pm = pendingManagerPublicKeyOrUnit()
	371	+	let hasPM = if (isDefined(pm))
	372	+	then true
	373	+	else throw("No pending manager")
	374	+	if ((hasPM == hasPM))
	375	+	then {
	376	+	let checkPM = if ((i.callerPublicKey == value(pm)))
	377	+	then true
	378	+	else throw("You are not pending manager")
	379	+	if ((checkPM == checkPM))
	380	+	then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
	381	+	else throw("Strict value is not equal to itself.")
	382	+	}
	383	+	else throw("Strict value is not equal to itself.")
	384	+	}
	385	+
	386	+
	387	+	@Verifier(tx)
	388	+	func verify () = {
	389	+	let targetPublicKey = match managerPublicKeyOrUnit() {
	390	+	case pk: ByteVector =>
	391	+	pk
	392	+	case _: Unit =>
	393	+	tx.senderPublicKey
	394	+	case _ =>
	395	+	throw("Match error")
	396	+	}
	397	+	sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
	398	+	}
	399	+

github/deemru/w8io/026f985 
53.07 ms ◑