tx · 2jRkRxYXvedoS6RMax2m9cNwYydAArQJtsBDhvRUByMY

3P3hCvE9ZfeMnZE6kXzR6YBzxhxM8J6PE7K:  -0.01400000 Waves

2022.05.18 19:56 [3122860] smart account 3P3hCvE9ZfeMnZE6kXzR6YBzxhxM8J6PE7K > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2jRkRxYXvedoS6RMax2m9cNwYydAArQJtsBDhvRUByMY",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1652892965732,
    "version": 1,
    "sender": "3P3hCvE9ZfeMnZE6kXzR6YBzxhxM8J6PE7K",
    "senderPublicKey": "EM7EfoVTgHtLuphbMD4o1z2Br9abQALk5fCGoMLeKTfX",
    "proofs": [
        "4ibwXSYLGrSLskDshaqBpz5U6jcNiL8tFhKggi77xyq9itKKinueUJgufB8f7jq3UqgpKjbZ5USPCUazV1jrPvQY"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3122860,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: Bv1PdEUxYmqrCRZEUuwQ5G6pHPn12TQ8nE59cHRdRgKv
Next: Gpxk17PkttcqbR5kPChQMTPCF57ryeu6KV1y66Wc7x9M

Diff: 
Old
New
Differences
540
540
 
    }
541
541
 
542
542
 
543
+
@Verifier(tx)
544
+
func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String("2Cbd8ozG7A1RyRNC3nNnZgHu7Ru4K3JCfpyPkhqr9zxq"))
545
+

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

github/deemru/w8io/6500d08 
88.61 ms ◑