tx · 68G33TYAVsxQs4otucZr4wBknyGhszvmJcG1m8kiJ9RV

3N3BgaByeEjQ2cpoYqusyjmndGDpqX7rg4E:  -0.02400000 Waves

2022.07.12 17:20 [2136618] smart account 3N3BgaByeEjQ2cpoYqusyjmndGDpqX7rg4E > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "68G33TYAVsxQs4otucZr4wBknyGhszvmJcG1m8kiJ9RV",
    "fee": 2400000,
    "feeAssetId": null,
    "timestamp": 1657635662739,
    "version": 1,
    "sender": "3N3BgaByeEjQ2cpoYqusyjmndGDpqX7rg4E",
    "senderPublicKey": "CyYB8W6Hen1XmJwa8PyWXrVSDgYUn1KAagXDtaj4DAPG",
    "proofs": [
        "YJXgS4tRREcvModeRpCU17xJcUq1BJrrBnzmehBnrARSiPZS55dY7XRNKobD91YhdejQmoCyrRNGKyqe6LN5ooR"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2136618,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

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