tx · Gpxk17PkttcqbR5kPChQMTPCF57ryeu6KV1y66Wc7x9M

3P3hCvE9ZfeMnZE6kXzR6YBzxhxM8J6PE7K:  -0.03100000 Waves

2023.05.10 15:27 [3637252] smart account 3P3hCvE9ZfeMnZE6kXzR6YBzxhxM8J6PE7K > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Gpxk17PkttcqbR5kPChQMTPCF57ryeu6KV1y66Wc7x9M",
    "fee": 3100000,
    "feeAssetId": null,
    "timestamp": 1683721662399,
    "version": 2,
    "chainId": 87,
    "sender": "3P3hCvE9ZfeMnZE6kXzR6YBzxhxM8J6PE7K",
    "senderPublicKey": "EM7EfoVTgHtLuphbMD4o1z2Br9abQALk5fCGoMLeKTfX",
    "proofs": [
        "26qEPEcpKrDYxb3sJye4smpv2vSfCVveiZgiq2FAaqjHxudN7vPFkW2HnsJjjZdUw9NtQWNeC4NHBPuPizytP1p2"
    ],
    "script": "base64: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",
    "height": 3637252,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 2jRkRxYXvedoS6RMax2m9cNwYydAArQJtsBDhvRUByMY
Next: AJm2FZWAtWH2GSEbFuX7Bg51ebzXu2x4JFtKdQbqPBXG

Diff: 

OldNewDifferences
1-{-# STDLIB_VERSION 4 #-}
1+{-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "__"
9494 
9595 
9696 func keyLimitsRemaining (innerBaseStr) = ("%s%s%d__limits__remaining__" + innerBaseStr)
97+
98+
99+func keyManagerVaultAddress () = "%s__managerVaultAddress"
100+
101+
102+func keyManagerPublicKey () = "%s__managerPublicKey"
97103 
98104 
99105 let IdxCfgShareAssetId = 1
268274 func calcPrice (innerBaseStr,baseAssetId,shareAssetId,decimalsMultPrice) = genericCalcPrice(innerBaseStr, baseAssetId, 0, shareAssetId, decimalsMultPrice)
269275 
270276 
277+func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
278+    case s: String => 
279+        addressFromStringValue(s)
280+    case _ => 
281+        this
282+}
283+
284+
285+func managerPublicKeyOrUnit () = {
286+    let managerVaultAddress = getManagerVaultAddressOrThis()
287+    match getString(managerVaultAddress, keyManagerPublicKey()) {
288+        case s: String => 
289+            fromBase58String(s)
290+        case _: Unit => 
291+            unit
292+        case _ => 
293+            throw("Match error")
294+    }
295+    }
296+
297+
298+func isManager (i) = match managerPublicKeyOrUnit() {
299+    case pk: ByteVector => 
300+        (i.callerPublicKey == pk)
301+    case _: Unit => 
302+        (i.caller == this)
303+    case _ => 
304+        throw("Match error")
305+}
306+
307+
308+func mustManager (i) = if (isManager(i))
309+    then true
310+    else throw("permission denied")
311+
312+
271313 func commonSubmit (operationType,i,inAmount,inAssetId,baseAssetStr) = {
272314     let inAssetStr = toBase58String(inAssetId)
273315     let userAddressStr = toString(i.caller)
368410     let decimalsMultPrice = ((100 * 1000) * 1000)
369411     let topupMaxNegativePercents = fraction(topupMaxNegativePart, 100, decimalsMultBothAssets)
370412     let baseAssetBalance = assetBalance(this, baseAssetId)
371-    if ((i.caller != this))
372-        then throw("permissions denied")
373-        else if ((baseAssetBalance == 0))
413+    let checkCaller = mustManager(i)
414+    if ((checkCaller == checkCaller))
415+        then if ((baseAssetBalance == 0))
374416             then throw(((toString(this) + " must have any initial balance of ") + baseAssetStr))
375417             else if (isDefined(getString(this, keyAssetCfg(baseAssetStr))))
376418                 then throw((baseAssetStr + " has been already registered"))
393435                                     let innerBaseStr = toString(internalBaseAssetId)
394436 [StrE(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, innerBaseStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks, topupIntervalInBlocks, topupMaxNegativePart, topupManagerAddress, submitLimitsBaseMax, submitLimitsBaseReset, submitLimitsShareMax, submitLimitsShareReset, adminAddress)), StrE(keyMappingsInternal2baseAssetId(internalBaseAssetId), baseAssetStr), StrE(keyMappingsBaseAsset2internalId(baseAssetStr), innerBaseStr), StrE(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StrE(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownSubmitOperation(innerBaseStr), false), StrE(keyShutdownManager(innerBaseStr), shutdownManagerAddress), IntE(keyNextInternalAssetId(), (internalBaseAssetId + 1)), IntE(keyPriceLast(innerBaseStr), startPrice), IntE(keyPriceATH(innerBaseStr), startPrice), IntE(keyPriceHistory(innerBaseStr, height, lastBlock.timestamp), startPrice), IntE(keyTopUpCurrentIdx(innerBaseStr), 0), RemainingLimitsStringEntry(keyLimitsRemaining(innerBaseStr), submitLimitsBaseMax, submitLimitsShareMax), shareAssetIssueAction, ScriptTransfer(addressFromStringValue(topupManagerAddress), shareInitAmount, shareAssetId)]
395437                                     }
438+        else throw("Strict value is not equal to itself.")
396439     }
397440 
398441 
399442 
400443 @Callable(i)
401444 func shutdownSubmits (internalBaseAssetId) = {
402-    let internalBaseAssetIdStr = toString(internalBaseAssetId)
403-    let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
404-    let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
405-    if ((1 > size(baseAssetIdStr)))
406-        then throw("invalid internalBaseAssetId")
407-        else if ((toString(i.caller) != shutdownManagerAddress))
408-            then throw("access denied")
409-            else [BooleanEntry(keyShutdownSubmitOperation(toString(internalBaseAssetId)), true)]
445+    let checkCaller = mustManager(i)
446+    if ((checkCaller == checkCaller))
447+        then {
448+            let internalBaseAssetIdStr = toString(internalBaseAssetId)
449+            let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
450+            let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
451+            if ((1 > size(baseAssetIdStr)))
452+                then throw("invalid internalBaseAssetId")
453+                else [BooleanEntry(keyShutdownSubmitOperation(toString(internalBaseAssetId)), true)]
454+            }
455+        else throw("Strict value is not equal to itself.")
410456     }
411457 
412458 
541587 
542588 
543589 @Verifier(tx)
544-func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String("2Cbd8ozG7A1RyRNC3nNnZgHu7Ru4K3JCfpyPkhqr9zxq"))
590+func verify () = {
591+    let targetPublicKey =     match managerPublicKeyOrUnit() {
592+        case pk: ByteVector => 
593+            pk
594+        case _: Unit => 
595+            tx.senderPublicKey
596+        case _ => 
597+            throw("Match error")
598+    }
599+    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
600+    }
545601 

Full: 

OldNewDifferences
1-{-# STDLIB_VERSION 4 #-}
1+{-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "__"
55 
66 func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
77 
88 
99 func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
1010 
1111 
1212 func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), ("No data for this.key=" + key))
1313 
1414 
1515 func IntE (key,val) = IntegerEntry(key, val)
1616 
1717 
1818 func StrE (key,val) = StringEntry(key, val)
1919 
2020 
2121 func failExecuteGet (msg,baseAssetStr,userAddressStr,submitTxIdStr,operationType) = throw(((((((((msg + ": baseAsset=") + baseAssetStr) + " userAddress=") + userAddressStr) + " submitTxId=") + submitTxIdStr) + " operation=") + operationType))
2222 
2323 
2424 func failSubmitLimitsExceeds (remainingBase,remainingShare,newRemainingBase,newRemainingShare) = throw((((((((("submit operation limits have been reached: " + " remainingBaseVal=") + toString(remainingBase)) + " remainingShareVal=") + toString(remainingShare)) + " newRemainingBaseVal=") + toString(newRemainingBase)) + " newRemainingShareVal=") + toString(newRemainingShare)))
2525 
2626 
2727 func failTopupManagerOnly (topupManagerAddress) = throw((("opertion denied: only topUpManager=" + topupManagerAddress) + " can send such transactions"))
2828 
2929 
3030 func failTopupMaxPriceDeviation (price,minAllowedPrice) = throw(((("topup is not allowed - max deviation from ATH price exceeds: newPrice=" + toString(price)) + " minAllowedPrice=") + toString(minAllowedPrice)))
3131 
3232 
3333 func convertShare2Base (shareAmount,price,priceMult) = fraction(shareAmount, price, priceMult)
3434 
3535 
3636 func convertBase2Share (baseAmount,price,priceMult) = fraction(baseAmount, priceMult, price)
3737 
3838 
3939 func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
4040 
4141 
4242 func keyNextInternalAssetId () = "%s__nextInternalAssetId"
4343 
4444 
4545 func keyPriceLast (innerBaseStr) = ("%s%s%d__price__last__" + innerBaseStr)
4646 
4747 
4848 func keyPriceATH (innerBaseStr) = ("%s%s%d__price__ath__" + innerBaseStr)
4949 
5050 
5151 func keyPriceByTopUpIdx (innerBaseStr,topUpIdx) = makeString(["%s%s%d%d__price__byTopUpIdx", innerBaseStr, toString(topUpIdx)], SEP)
5252 
5353 
5454 func keyPriceHistory (innerBaseStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", innerBaseStr, toString(h), toString(timestamp)], SEP)
5555 
5656 
5757 func keyTotalLocked (innerBaseStr) = ("%s%s%d__total__locked__" + innerBaseStr)
5858 
5959 
6060 func keyTotalLockedByUser (innerBaseStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", innerBaseStr, userAddressStr], SEP)
6161 
6262 
6363 func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
6464 
6565 
6666 func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
6767 
6868 
6969 func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
7070 
7171 
7272 func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
7373 
7474 
7575 func keyShutdownSubmitOperation (innerBaseStr) = ("%s%s%d__shutdown__submit__" + innerBaseStr)
7676 
7777 
7878 func keyShutdownManager (innerBaseStr) = ("%s%s%d__shutdown__manager__" + innerBaseStr)
7979 
8080 
8181 func keyTopUpCurrentIdx (innerBaseStr) = ("%s%s%d__topup__currentIdx__" + innerBaseStr)
8282 
8383 
8484 func keyTopUpLastHeight (innerBaseStr,sender) = makeString(["%s%s%s%d%s__topup__last__height", innerBaseStr, sender], SEP)
8585 
8686 
8787 func keyTopupMutext (innerBaseStr) = ("%s%s%d__topup__mutex__" + innerBaseStr)
8888 
8989 
9090 func keyTopupLastTimestamp (innerBaseStr) = ("%s%s%s%d__topup__last__timestamp__" + innerBaseStr)
9191 
9292 
9393 func keyTopupHistory (innerBaseStr,topupIdx) = makeString(["%s%s%d%d__topup__history", innerBaseStr, toString(topupIdx)], SEP)
9494 
9595 
9696 func keyLimitsRemaining (innerBaseStr) = ("%s%s%d__limits__remaining__" + innerBaseStr)
97+
98+
99+func keyManagerVaultAddress () = "%s__managerVaultAddress"
100+
101+
102+func keyManagerPublicKey () = "%s__managerPublicKey"
97103 
98104 
99105 let IdxCfgShareAssetId = 1
100106 
101107 let IdxCfgInternalBaseAsset = 2
102108 
103109 let IdxCfgDecimalsMultBothAssets = 3
104110 
105111 let IdxCfgDecimalsMultPrice = 4
106112 
107113 let IdxCfgGetDelayBlocks = 5
108114 
109115 let IdxCfgTopupIntervalInBlocks = 6
110116 
111117 let IdxCfgTopupMaxNegativePart = 7
112118 
113119 let IdxCfgTopupManagerAddress = 8
114120 
115121 let IdxCfgSubmitLimitsBaseMax = 9
116122 
117123 let IdxCfgSubmitLimitsBaseReset = 10
118124 
119125 let IdxCfgSubmitLimitsShareMax = 11
120126 
121127 let IdxCfgSubmitLimitsShareReset = 12
122128 
123129 let IdxCfgAdminAddress = 13
124130 
125131 func dataAssetCfg (shareAssetStr,innerBaseStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks,topupIntervalInBlocks,topupMaxNegativePart,topupManagerAddress,submitLimitsBaseMax,submitLimitsBaseReset,submitLimitsShareMax,submitLimitsShareReset,adminAddress) = makeString(["%s%d%d%d%d%d%d%s%d%d%d%d", shareAssetStr, innerBaseStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks), toString(topupIntervalInBlocks), toString(topupMaxNegativePart), topupManagerAddress, toString(submitLimitsBaseMax), toString(submitLimitsBaseReset), toString(submitLimitsShareMax), toString(submitLimitsShareReset), adminAddress], SEP)
126132 
127133 
128134 let IdxTotalLockedInShare = 1
129135 
130136 let IdxTotalLockedOutBase = 2
131137 
132138 let IdxTotalLockedInBase = 3
133139 
134140 let IdxTotalLockedOutShare = 4
135141 
136142 func dataTotalLocked (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = makeString(["%d%d%d%d", toString(inShareAmount), toString(outBaseAmount), toString(inBaseAmount), toString(outShareAmount)], SEP)
137143 
138144 
139145 func dataTotalLockedInt (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = [-1, inShareAmount, outBaseAmount, inBaseAmount, outShareAmount]
140146 
141147 
142148 func readTotalLocked (key) = {
143149     let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0, 0, 0)), SEP)
144150     dataTotalLockedInt(parseIntValue(totalLockedArray[IdxTotalLockedInShare]), parseIntValue(totalLockedArray[IdxTotalLockedOutBase]), parseIntValue(totalLockedArray[IdxTotalLockedInBase]), parseIntValue(totalLockedArray[IdxTotalLockedOutShare]))
145151     }
146152 
147153 
148154 func calcTotalLockedDiff (direction,operationType,innerBaseStr,price,priceMult,inAmount,baseAssetId,shareAssetId) = {
149155     let t = (direction + operationType)
150156     let emptyVect = fromBase58String("")
151157     if ((t == "submitP"))
152158         then {
153159             let totalDiff = dataTotalLockedInt(0, 0, inAmount, 0)
154160             let userDiff = totalDiff
155161             $Tuple5(totalDiff, userDiff, 0, emptyVect, false)
156162             }
157163         else if ((t == "submitG"))
158164             then {
159165                 let totalDiff = dataTotalLockedInt(inAmount, 0, 0, 0)
160166                 let userDiff = totalDiff
161167                 $Tuple5(totalDiff, userDiff, 0, emptyVect, true)
162168                 }
163169             else if ((t == "executeP"))
164170                 then {
165171                     let outAmount = convertBase2Share(inAmount, price, priceMult)
166172                     let totalDiff = dataTotalLockedInt(0, 0, 0, outAmount)
167173                     let userDiff = dataTotalLockedInt(0, 0, inAmount, 0)
168174                     $Tuple5(totalDiff, userDiff, outAmount, shareAssetId, false)
169175                     }
170176                 else if ((t == "executeG"))
171177                     then {
172178                         let outAmount = convertShare2Base(inAmount, price, priceMult)
173179                         let totalDiff = dataTotalLockedInt(0, outAmount, 0, 0)
174180                         let userDiff = dataTotalLockedInt(inAmount, 0, 0, 0)
175181                         $Tuple5(totalDiff, userDiff, outAmount, baseAssetId, false)
176182                         }
177183                     else if ((t == "topup"))
178184                         then {
179185                             let totalLockedArray = readTotalLocked(keyTotalLocked(innerBaseStr))
180186                             let totalLockedInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
181187                             let totalLockedInShareAmount = totalLockedArray[IdxTotalLockedInShare]
182188                             let totalDiff = dataTotalLockedInt(totalLockedInShareAmount, (-1 * convertShare2Base(totalLockedInShareAmount, price, priceMult)), totalLockedInBaseAmount, (-1 * convertBase2Share(totalLockedInBaseAmount, price, priceMult)))
183189                             $Tuple5(totalDiff, nil, 0, emptyVect, false)
184190                             }
185191                         else throw(("Unsupported Type " + t))
186192     }
187193 
188194 
189195 func TotalLockedStringEntry (action,key,diff) = {
190196     func UPDATE (a,b) =     if ((action == "INCREMENT"))
191197         then (a + b)
192198         else if ((action == "DECREMENT"))
193199             then (a - b)
194200             else throw(("Unsupported action " + action))
195201 
196202     let dataArray = readTotalLocked(key)
197203     StrE(key, dataTotalLocked(UPDATE(dataArray[IdxTotalLockedInShare], diff[IdxTotalLockedInShare]), UPDATE(dataArray[IdxTotalLockedOutBase], diff[IdxTotalLockedOutBase]), UPDATE(dataArray[IdxTotalLockedInBase], diff[IdxTotalLockedInBase]), UPDATE(dataArray[IdxTotalLockedOutShare], diff[IdxTotalLockedOutShare])))
198204     }
199205 
200206 
201207 func keyOperation (operationType,innerBaseStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, innerBaseStr, userAddress, txId], SEP)
202208 
203209 
204210 let IdxOperStatus = 1
205211 
206212 let IdxOperInAmount = 2
207213 
208214 let IdxOperPrice = 3
209215 
210216 let IdxOperOutAmount = 4
211217 
212218 let IdxOperStartHeight = 5
213219 
214220 let IdxOperStartTimestamp = 6
215221 
216222 let IdxOperEndHeight = 7
217223 
218224 let IdxOperEndTimestamp = 8
219225 
220226 let IdxOperTopupUnlockIdx = 9
221227 
222228 func privateDataOperationAllStrings (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp,lock) = makeString(["%s%d%d%d%d%d%d%d%d", status, inAssetAmount, price, outAssetAmount, startHeight, startTimestamp, endHeight, endTimestamp, lock], SEP)
223229 
224230 
225231 func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp,topupUnlockIdx) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp), toString(topupUnlockIdx))
226232 
227233 
228234 func dataOperationExecutionUpdate (currOperArray,newStatus,newPrice,newOutAmount) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], toString(newPrice), toString(newOutAmount), currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], toString(height), toString(lastBlock.timestamp), currOperArray[IdxOperTopupUnlockIdx])
229235 
230236 
231237 func readAssetCfgOrFail (baseAssetStr) = {
232238     let key = keyAssetCfg(baseAssetStr)
233239     split(getStringOrFail(key), SEP)
234240     }
235241 
236242 
237243 let IdxLimitsRemainingBase = 1
238244 
239245 let IdxLimitsRemainingShare = 2
240246 
241247 func RemainingLimitsStringEntry (key,baseRemainingLimit,shareRemainingLimit) = StrE(key, makeString(["%d%d", toString(baseRemainingLimit), toString(shareRemainingLimit)], SEP))
242248 
243249 
244250 func TopupMutexIntEntry (innerBaseStr,acquiredHeight) = IntE(keyTopupMutext(innerBaseStr), acquiredHeight)
245251 
246252 
247253 func genericCalcPrice (innerBaseStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultPrice) = {
248254     let totalLockedArray = readTotalLocked(keyTotalLocked(innerBaseStr))
249255     let totalLockedOutBaseAmount = totalLockedArray[IdxTotalLockedOutBase]
250256     let currIterTotalInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
251257     let baseAssetBalance = assetBalance(this, baseAssetId)
252258     let baseAssetBalanceWCO = (((baseAssetBalance + topUpBaseAmount) - currIterTotalInBaseAmount) - totalLockedOutBaseAmount)
253259     let totalLockedOutShareAmount = totalLockedArray[IdxTotalLockedOutShare]
254260     let currIterTotalInShareAmount = totalLockedArray[IdxTotalLockedInShare]
255261     let shareEmission = value(assetInfo(shareAssetId)).quantity
256262     if ((0 > baseAssetBalanceWCO))
257263         then throw(((("baseAssetBalanceWco < 0: baseAssettBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceWco=") + toString(baseAssetBalanceWCO)))
258264         else {
259265             let lastPrice = getIntOrFail(keyPriceLast(innerBaseStr))
260266             let price = if ((shareEmission == 0))
261267                 then lastPrice
262268                 else fraction(baseAssetBalanceWCO, decimalsMultPrice, shareEmission)
263269             $Tuple9(price, baseAssetBalance, -1, baseAssetBalanceWCO, shareEmission, currIterTotalInBaseAmount, currIterTotalInShareAmount, totalLockedOutBaseAmount, totalLockedOutShareAmount)
264270             }
265271     }
266272 
267273 
268274 func calcPrice (innerBaseStr,baseAssetId,shareAssetId,decimalsMultPrice) = genericCalcPrice(innerBaseStr, baseAssetId, 0, shareAssetId, decimalsMultPrice)
269275 
270276 
277+func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
278+    case s: String => 
279+        addressFromStringValue(s)
280+    case _ => 
281+        this
282+}
283+
284+
285+func managerPublicKeyOrUnit () = {
286+    let managerVaultAddress = getManagerVaultAddressOrThis()
287+    match getString(managerVaultAddress, keyManagerPublicKey()) {
288+        case s: String => 
289+            fromBase58String(s)
290+        case _: Unit => 
291+            unit
292+        case _ => 
293+            throw("Match error")
294+    }
295+    }
296+
297+
298+func isManager (i) = match managerPublicKeyOrUnit() {
299+    case pk: ByteVector => 
300+        (i.callerPublicKey == pk)
301+    case _: Unit => 
302+        (i.caller == this)
303+    case _ => 
304+        throw("Match error")
305+}
306+
307+
308+func mustManager (i) = if (isManager(i))
309+    then true
310+    else throw("permission denied")
311+
312+
271313 func commonSubmit (operationType,i,inAmount,inAssetId,baseAssetStr) = {
272314     let inAssetStr = toBase58String(inAssetId)
273315     let userAddressStr = toString(i.caller)
274316     let baseAssetId = fromBase58String(baseAssetStr)
275317     let cfgArray = readAssetCfgOrFail(baseAssetStr)
276318     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
277319     let shareAssetId = fromBase58String(shareAssetStr)
278320     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
279321     let innerBaseStr = cfgArray[IdxCfgInternalBaseAsset]
280322     let getDelayBlocks = parseIntValue(cfgArray[IdxCfgGetDelayBlocks])
281323     let limitsKEY = keyLimitsRemaining(innerBaseStr)
282324     let limitsCfgArray = split(getStringOrFail(limitsKEY), SEP)
283325     let limitsRemainingBase = parseIntValue(limitsCfgArray[IdxLimitsRemainingBase])
284326     let limitsRemainingShare = parseIntValue(limitsCfgArray[IdxLimitsRemainingShare])
285327     let isSubmitBlocked = valueOrElse(getBoolean(this, keyShutdownSubmitOperation(innerBaseStr)), false)
286328     if (isSubmitBlocked)
287329         then throw("submit operation is blocked")
288330         else {
289331             let operationsMutex = valueOrElse(getInteger(this, keyTopupMutext(innerBaseStr)), 0)
290332             if (((operationsMutex + 60) > height))
291333                 then throw("submit operations are blocked by topup manager")
292334                 else {
293335                     let diffTuple = calcTotalLockedDiff("submit", operationType, innerBaseStr, 0, 0, inAmount, baseAssetId, shareAssetId)
294336                     let limitsRemainingBaseNew = (limitsRemainingBase - diffTuple._2[IdxTotalLockedInBase])
295337                     let limitsRemainingShareNew = (limitsRemainingShare - diffTuple._2[IdxTotalLockedInShare])
296338                     if (if ((0 > limitsRemainingBaseNew))
297339                         then true
298340                         else (0 > limitsRemainingShareNew))
299341                         then failSubmitLimitsExceeds(limitsRemainingBase, limitsRemainingShare, limitsRemainingBaseNew, limitsRemainingShareNew)
300342                         else {
301343                             let topUpCurrentIdx = getIntOrFail(keyTopUpCurrentIdx(innerBaseStr))
302344                             let endHeight = if (diffTuple._5)
303345                                 then (height + getDelayBlocks)
304346                                 else height
305347                             ((([StrE(keyOperation(operationType, innerBaseStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("PENDING", inAmount, 0, 0, height, lastBlock.timestamp, endHeight, 0, (topUpCurrentIdx + 1)))] :+ TotalLockedStringEntry("INCREMENT", keyTotalLocked(innerBaseStr), diffTuple._1)) :+ TotalLockedStringEntry("INCREMENT", keyTotalLockedByUser(innerBaseStr, userAddressStr), diffTuple._2)) :+ RemainingLimitsStringEntry(limitsKEY, limitsRemainingBaseNew, limitsRemainingShareNew))
306348                             }
307349                     }
308350             }
309351     }
310352 
311353 
312354 func commonExecute (operationType,baseAssetStr,userAddressStr,submitTxIdStr) = {
313355     let userAddress = addressFromStringValue(userAddressStr)
314356     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
315357     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
316358     let innerBaseStr = assetCfgArray[IdxCfgInternalBaseAsset]
317359     let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
318360     let baseAssetId = fromBase58String(baseAssetStr)
319361     let opKey = keyOperation(operationType, innerBaseStr, userAddressStr, submitTxIdStr)
320362     let opArray = split(getStringOrFail(opKey), SEP)
321363     let status = opArray[IdxOperStatus]
322364     let inAmount = parseIntValue(opArray[IdxOperInAmount])
323365     let topupUnlockIdx = parseIntValue(opArray[IdxOperTopupUnlockIdx])
324366     let unlockHeight = parseIntValue(opArray[IdxOperEndHeight])
325367     let currTopUpIdx = getIntOrFail(keyTopUpCurrentIdx(innerBaseStr))
326368     let priceByTopUpId = getIntOrFail(keyPriceByTopUpIdx(innerBaseStr, topupUnlockIdx))
327369     if ((status != "PENDING"))
328370         then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, submitTxIdStr, operationType)
329371         else if ((topupUnlockIdx > currTopUpIdx))
330372             then failExecuteGet(((("OperLock[" + toString(topupUnlockIdx)) + "] > ") + toString(currTopUpIdx)), baseAssetStr, userAddressStr, submitTxIdStr, operationType)
331373             else if ((unlockHeight > height))
332374                 then failExecuteGet(((("OperHeightLock[" + toString(unlockHeight)) + "] > ") + toString(height)), baseAssetStr, userAddressStr, submitTxIdStr, operationType)
333375                 else {
334376                     let diffTuple = calcTotalLockedDiff("execute", operationType, innerBaseStr, priceByTopUpId, decimalsMultPrice, inAmount, baseAssetId, shareAssetId)
335377                     let outAmount = diffTuple._3
336378                     let outTransferData = if ((diffTuple._4 == baseAssetId))
337379                         then [ScriptTransfer(userAddress, outAmount, baseAssetId)]
338380                         else [ScriptTransfer(userAddress, outAmount, shareAssetId)]
339381                     (((outTransferData :+ StrE(opKey, dataOperationExecutionUpdate(opArray, "FINISHED", priceByTopUpId, outAmount))) :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(innerBaseStr), diffTuple._1)) :+ TotalLockedStringEntry("DECREMENT", keyTotalLockedByUser(innerBaseStr, userAddressStr), diffTuple._2))
340382                     }
341383     }
342384 
343385 
344386 func privateCurrentSysParamsREST (baseAssetStr) = {
345387     let baseAssetId = fromBase58String(baseAssetStr)
346388     let cfgArray = readAssetCfgOrFail(baseAssetStr)
347389     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
348390     let shareAssetId = fromBase58String(shareAssetStr)
349391     let decimalsMultBothAssetsVal = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
350392     let decimalsMultPriceVal = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
351393     let innerBaseStr = cfgArray[IdxCfgInternalBaseAsset]
352394     let priceAthKEY = keyPriceATH(innerBaseStr)
353395     let priceAthVal = valueOrElse(getInteger(this, priceAthKEY), 0)
354396     let priceLastKEY = keyPriceLast(innerBaseStr)
355397     let priceLastVal = valueOrElse(getInteger(this, priceLastKEY), 0)
356398     let topupLastTimeKEY = keyTopupLastTimestamp(innerBaseStr)
357399     let topupLastTimeVal = valueOrElse(getInteger(this, topupLastTimeKEY), 0)
358400     let sysState = calcPrice(innerBaseStr, baseAssetId, shareAssetId, decimalsMultPriceVal)
359401     $Tuple14(IntE("price", priceLastVal), IntE("decimalsMultPrice", decimalsMultPriceVal), IntE("baseAssetBalance", sysState._2), IntE("-1", sysState._3), IntE("baseAssetBalanceWCO", sysState._4), IntE("shareEmission", sysState._5), IntE("currIterTotalInBaseAmount", sysState._6), IntE("currIterTotalInShareAmount", sysState._7), IntE("totalLockedOutBaseAmount", sysState._8), IntE("totalLockedOutShareAmount", sysState._9), IntE("decimalsMultBothAssets", decimalsMultBothAssetsVal), IntE("priceATH", priceAthVal), IntE("priceRecalculated", sysState._1), IntE("topupLastTimestamp", topupLastTimeVal))
360402     }
361403 
362404 
363405 @Callable(i)
364406 func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress,startPrice,topupIntervalInBlocks,topupMaxNegativePart,topupManagerAddress,submitLimitsBaseMax,submitLimitsBaseReset,submitLimitsShareMax,submitLimitsShareReset,adminAddress) = {
365407     let baseAssetId = fromBase58String(baseAssetStr)
366408     let bothAssetsDecimals = value(assetInfo(baseAssetId)).decimals
367409     let decimalsMultBothAssets = pow(10, 0, bothAssetsDecimals, 0, 0, DOWN)
368410     let decimalsMultPrice = ((100 * 1000) * 1000)
369411     let topupMaxNegativePercents = fraction(topupMaxNegativePart, 100, decimalsMultBothAssets)
370412     let baseAssetBalance = assetBalance(this, baseAssetId)
371-    if ((i.caller != this))
372-        then throw("permissions denied")
373-        else if ((baseAssetBalance == 0))
413+    let checkCaller = mustManager(i)
414+    if ((checkCaller == checkCaller))
415+        then if ((baseAssetBalance == 0))
374416             then throw(((toString(this) + " must have any initial balance of ") + baseAssetStr))
375417             else if (isDefined(getString(this, keyAssetCfg(baseAssetStr))))
376418                 then throw((baseAssetStr + " has been already registered"))
377419                 else if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
378420                     then throw("invalid shutdownManagerAddress")
379421                     else if ((toString(addressFromStringValue(topupManagerAddress)) != topupManagerAddress))
380422                         then throw("invalid topupManagerAddress")
381423                         else if ((0 > getDelayinBlocks))
382424                             then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
383425                             else if (if ((0 >= topupMaxNegativePercents))
384426                                 then true
385427                                 else (topupMaxNegativePercents >= 99))
386428                                 then throw("invalid topupMaxNegativePart parameter")
387429                                 else {
388430                                     let shareInitAmount = convertBase2Share(baseAssetBalance, startPrice, decimalsMultPrice)
389431                                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, shareInitAmount, bothAssetsDecimals, true)
390432                                     let shareAssetId = calculateAssetId(shareAssetIssueAction)
391433                                     let shareAssetStr = toBase58String(shareAssetId)
392434                                     let internalBaseAssetId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
393435                                     let innerBaseStr = toString(internalBaseAssetId)
394436 [StrE(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, innerBaseStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks, topupIntervalInBlocks, topupMaxNegativePart, topupManagerAddress, submitLimitsBaseMax, submitLimitsBaseReset, submitLimitsShareMax, submitLimitsShareReset, adminAddress)), StrE(keyMappingsInternal2baseAssetId(internalBaseAssetId), baseAssetStr), StrE(keyMappingsBaseAsset2internalId(baseAssetStr), innerBaseStr), StrE(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StrE(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownSubmitOperation(innerBaseStr), false), StrE(keyShutdownManager(innerBaseStr), shutdownManagerAddress), IntE(keyNextInternalAssetId(), (internalBaseAssetId + 1)), IntE(keyPriceLast(innerBaseStr), startPrice), IntE(keyPriceATH(innerBaseStr), startPrice), IntE(keyPriceHistory(innerBaseStr, height, lastBlock.timestamp), startPrice), IntE(keyTopUpCurrentIdx(innerBaseStr), 0), RemainingLimitsStringEntry(keyLimitsRemaining(innerBaseStr), submitLimitsBaseMax, submitLimitsShareMax), shareAssetIssueAction, ScriptTransfer(addressFromStringValue(topupManagerAddress), shareInitAmount, shareAssetId)]
395437                                     }
438+        else throw("Strict value is not equal to itself.")
396439     }
397440 
398441 
399442 
400443 @Callable(i)
401444 func shutdownSubmits (internalBaseAssetId) = {
402-    let internalBaseAssetIdStr = toString(internalBaseAssetId)
403-    let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
404-    let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
405-    if ((1 > size(baseAssetIdStr)))
406-        then throw("invalid internalBaseAssetId")
407-        else if ((toString(i.caller) != shutdownManagerAddress))
408-            then throw("access denied")
409-            else [BooleanEntry(keyShutdownSubmitOperation(toString(internalBaseAssetId)), true)]
445+    let checkCaller = mustManager(i)
446+    if ((checkCaller == checkCaller))
447+        then {
448+            let internalBaseAssetIdStr = toString(internalBaseAssetId)
449+            let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
450+            let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
451+            if ((1 > size(baseAssetIdStr)))
452+                then throw("invalid internalBaseAssetId")
453+                else [BooleanEntry(keyShutdownSubmitOperation(toString(internalBaseAssetId)), true)]
454+            }
455+        else throw("Strict value is not equal to itself.")
410456     }
411457 
412458 
413459 
414460 @Callable(i)
415461 func submitPut () = {
416462     let pmt = value(i.payments[0])
417463     let inAmount = pmt.amount
418464     let inAssetId = value(pmt.assetId)
419465     let baseAssetStr = toBase58String(inAssetId)
420466     commonSubmit("P", i, inAmount, inAssetId, baseAssetStr)
421467     }
422468 
423469 
424470 
425471 @Callable(i)
426472 func submitGet () = {
427473     let pmt = value(i.payments[0])
428474     let inAmount = pmt.amount
429475     let inAssetId = value(pmt.assetId)
430476     let shareAssetStr = toBase58String(inAssetId)
431477     let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
432478     commonSubmit("G", i, inAmount, inAssetId, baseAssetStr)
433479     }
434480 
435481 
436482 
437483 @Callable(i)
438484 func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = commonExecute("P", baseAssetStr, userAddressStr, submitTxIdStr)
439485 
440486 
441487 
442488 @Callable(i)
443489 func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = commonExecute("G", baseAssetStr, userAddressStr, submitTxIdStr)
444490 
445491 
446492 
447493 @Callable(i)
448494 func operationsMutex (baseAssetStr) = {
449495     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
450496     let topUpManagerAddressStr = assetCfgArray[IdxCfgTopupManagerAddress]
451497     let innerBaseStr = assetCfgArray[IdxCfgInternalBaseAsset]
452498     if ((toString(i.caller) != topUpManagerAddressStr))
453499         then failTopupManagerOnly(topUpManagerAddressStr)
454500         else [TopupMutexIntEntry(innerBaseStr, height)]
455501     }
456502 
457503 
458504 
459505 @Callable(i)
460506 func topUpBalance (baseAssetStr,income) = {
461507     let baseAssetId = fromBase58String(baseAssetStr)
462508     let cfg = readAssetCfgOrFail(baseAssetStr)
463509     let shareAssetId = fromBase58String(cfg[IdxCfgShareAssetId])
464510     let priceMult = parseIntValue(cfg[IdxCfgDecimalsMultPrice])
465511     let bothAssetMult = parseIntValue(cfg[IdxCfgDecimalsMultBothAssets])
466512     let topupIntervalInBlocks = parseIntValue(cfg[IdxCfgTopupIntervalInBlocks])
467513     let topupMaxNegativePart = parseIntValue(cfg[IdxCfgTopupMaxNegativePart])
468514     let innerBaseStr = cfg[IdxCfgInternalBaseAsset]
469515     let topUpManagerAddressStr = cfg[IdxCfgTopupManagerAddress]
470516     let submitLimitsBaseMax = parseIntValue(cfg[IdxCfgSubmitLimitsBaseMax])
471517     let submitLimitsShareMax = parseIntValue(cfg[IdxCfgSubmitLimitsShareMax])
472518     let topUpCurrentIdxKEY = keyTopUpCurrentIdx(innerBaseStr)
473519     let prevTopUpIdx = getIntOrFail(topUpCurrentIdxKEY)
474520     let currentTopUpIdx = (prevTopUpIdx + 1)
475521     let topUpLastHeightKEY = keyTopUpLastHeight(innerBaseStr, toString(i.caller))
476522     let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
477523     let priceAthKEY = keyPriceATH(innerBaseStr)
478524     let prevPriceATH = valueOrElse(getInteger(this, priceAthKEY), 0)
479525     if ((toString(i.caller) != topUpManagerAddressStr))
480526         then failTopupManagerOnly(topUpManagerAddressStr)
481527         else if ((topupIntervalInBlocks > (height - topUpLastHeight)))
482528             then throw((("1 topup per " + toString(topupIntervalInBlocks)) + " blocks from the same address is allowed"))
483529             else {
484530                 let price = genericCalcPrice(innerBaseStr, baseAssetId, income, shareAssetId, priceMult)._1
485531                 let valid = if ((income > 0))
486532                     then {
487533                         let pmt = value(i.payments[0])
488534                         let pmtAssetId = value(pmt.assetId)
489535                         if ((baseAssetId != pmtAssetId))
490536                             then throw("attached payment's asset id is NOT matched passed baseAssetStr")
491537                             else if ((size(i.payments) > 1))
492538                                 then throw("only one payment can be attached")
493539                                 else if ((pmt.amount != income))
494540                                     then throw("attached payment.amount is NOT matched passed income argument")
495541                                     else true
496542                         }
497543                     else if ((0 > income))
498544                         then {
499545                             let minAllowedPrice = fraction(prevPriceATH, ((1 * bothAssetMult) - topupMaxNegativePart), bothAssetMult)
500546                             if ((minAllowedPrice > price))
501547                                 then failTopupMaxPriceDeviation(price, minAllowedPrice)
502548                                 else true
503549                             }
504550                         else throw("zero income is not allowed")
505551                 if (!(valid))
506552                     then throw("validation failed")
507553                     else {
508554                         let diffTuple = calcTotalLockedDiff("topup", "", innerBaseStr, price, priceMult, 0, baseAssetId, shareAssetId)
509555                         let topupTotalDiff = diffTuple._1
510556                         ((((((([IntE(keyPriceLast(innerBaseStr), price), IntE(keyPriceHistory(innerBaseStr, height, lastBlock.timestamp), price), IntE(keyPriceByTopUpIdx(innerBaseStr, currentTopUpIdx), price), IntE(topUpCurrentIdxKEY, currentTopUpIdx), IntE(priceAthKEY, if ((price > prevPriceATH))
511557                             then price
512558                             else prevPriceATH), IntE(topUpLastHeightKEY, height)] :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(innerBaseStr), topupTotalDiff)) :+ TopupMutexIntEntry(innerBaseStr, 0)) :+ IntE(keyTopupLastTimestamp(innerBaseStr), lastBlock.timestamp)) :+ RemainingLimitsStringEntry(keyLimitsRemaining(innerBaseStr), submitLimitsBaseMax, submitLimitsShareMax)) :+ Burn(shareAssetId, topupTotalDiff[IdxTotalLockedInShare])) :+ Reissue(shareAssetId, -(topupTotalDiff[IdxTotalLockedOutShare]), true)) ++ (if ((0 > income))
513559                             then [ScriptTransfer(i.caller, -(income), baseAssetId)]
514560                             else nil))
515561                         }
516562                 }
517563     }
518564 
519565 
520566 
521567 @Callable(i)
522568 func currentSysParamsREST (baseAssetStr) = {
523569     let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
524570     let price = sysStateTuple._1.value
525571     let decimalsMultPrice = sysStateTuple._2.value
526572     let baseAssetBalance = sysStateTuple._3.value
527573     let totalLockedBaseAmount = sysStateTuple._4.value
528574     let baseAssetBalanceWCO = sysStateTuple._5.value
529575     let shareEmission = sysStateTuple._6.value
530576     let currIterTotalInBaseAmount = sysStateTuple._7.value
531577     let currIterTotalInShareAmount = sysStateTuple._8.value
532578     let totalLockedOutBaseAmount = sysStateTuple._9.value
533579     let totalLockedOutShareAmount = sysStateTuple._10.value
534580     let decimalsMultBothAssets = sysStateTuple._11.value
535581     let priceATH = sysStateTuple._12.value
536582     let priceRecalculated = sysStateTuple._13.value
537583     let topupLastTime = sysStateTuple._14.value
538584     let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceWCO), toString(shareEmission), toString(currIterTotalInBaseAmount), toString(currIterTotalInShareAmount), toString(totalLockedOutBaseAmount), toString(totalLockedOutShareAmount), toString(decimalsMultBothAssets), toString(priceATH), toString(priceRecalculated), toString(topupLastTime), "endCurrentSysParamsREST"], SEP)
539585     throw(restData)
540586     }
541587 
542588 
543589 @Verifier(tx)
544-func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String("2Cbd8ozG7A1RyRNC3nNnZgHu7Ru4K3JCfpyPkhqr9zxq"))
590+func verify () = {
591+    let targetPublicKey =     match managerPublicKeyOrUnit() {
592+        case pk: ByteVector => 
593+            pk
594+        case _: Unit => 
595+            tx.senderPublicKey
596+        case _ => 
597+            throw("Match error")
598+    }
599+    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
600+    }
545601 
github/deemru/w8io/6500d08 
84.81 ms ◑