2023.02.07 18:59 [3504979] smart account 3PKkojKdd6BBzTf1RXbQVfUDraNFXXHKzQF > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "ACgshZpRxaA4FVFbUHT6pgWvLbGp8fL2q57DorLZHEu2",
    "fee": 1600000,
    "feeAssetId": null,
    "timestamp": 1675785574279,
    "version": 1,
    "sender": "3PKkojKdd6BBzTf1RXbQVfUDraNFXXHKzQF",
    "senderPublicKey": "EFvHiEdrRDt5rY98zz2qr96FtqeDuPim2jiQt4kktAEH",
    "proofs": [
        "217MLWsgty2et6ayYpitRzvSJ1qVTjgJZ8JSC7L5vgYSjZqZM2TcmtGSDFJpy4rZSaL1CyHxw5MNLnbj6N5fxYeN"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3504979,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 3HG5CUf2qX6v41xgoYD1SM9F8EH7isXDyEHbGsrAKqDt
Next: AdKwaNFBfj8KcwFBjH3RAuB3f4J46kDgnxYsbf3jD6Kn

Diff: 
Old
New
Differences
335
335
 
                                    let msgArray = split(msg, ProtocolSEP)
336
336
 
                                    if (((size(msgArray) % 3) != 0))
337
337
 
                                        then throw(("msg parameters count must be multiple of 3: msgArray.size=" + toString(size(msg))))
338
-
                                        else ((((finalizePriceV2Common(0, groupNum, groupDataStr, msgArray, signs0) ++ finalizePriceV2Common(1, groupNum, groupDataStr, msgArray, signs1)) ++ finalizePriceV2Common(2, groupNum, groupDataStr, msgArray, signs2)) ++ finalizeUsdnUsdtOnchain()) :+ BooleanEntry(keyGroupStatus(groupNum, finHeightStr), true))
338
+
                                        else ((((finalizePriceV2Common(0, groupNum, groupDataStr, msgArray, signs0) ++ finalizePriceV2Common(1, groupNum, groupDataStr, msgArray, signs1)) ++ finalizePriceV2Common(2, groupNum, groupDataStr, msgArray, signs2)) ++ finalizeUsdnUsdtOnchainV2()) :+ BooleanEntry(keyGroupStatus(groupNum, finHeightStr), true))
339
339
 
                                    }
340
340
 
    }
341
341
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let ProtocolSEP = ":"
5
5
 
6
6
 
let SEP = "__"
7
7
 
8
8
 
let percentPriceOffset = 95
9
9
 
10
10
 
func keyPrice (symbol) = ("%s%s__price__" + symbol)
11
11
 
12
12
 
13
13
 
func keyOracles () = "%s%s__config__oracles"
14
14
 
15
15
 
16
16
 
func keyGroupData (groupNum) = ("%s%d__group__" + groupNum)
17
17
 
18
18
 
19
19
 
func keyMinConsensus () = "%s%s__config__minConsensus"
20
20
 
21
21
 
22
22
 
func keyPriceFailure (symbol) = makeString(["%s%s%d__finalizationFailure", symbol, toString(height)], SEP)
23
23
 
24
24
 
25
25
 
func keyLastHeight (symbol) = ("%s%s__lastHeight__" + symbol)
26
26
 
27
27
 
28
28
 
func keyPriceByHeight (symbol,h) = makeString(["%s%s%d__priceByHeight", symbol, toString(h)], SEP)
29
29
 
30
30
 
31
31
 
func keyIdx (symbol) = ("%s%s__idxCurrent__" + symbol)
32
32
 
33
33
 
34
34
 
func keyIdx2Height (symbol,idx) = makeString(["%s%s%d__idx2Height", symbol, toString(idx)], SEP)
35
35
 
36
36
 
37
37
 
func keyHeight2Idx (symbol,h) = makeString(["%s%s%d__height2Idx", symbol, toString(h)], SEP)
38
38
 
39
39
 
40
40
 
func keyGroupStatus (groupNum,finHeightStr) = makeString(["%s%d%d__groupStatus", groupNum, finHeightStr], SEP)
41
41
 
42
42
 
43
43
 
func keyIsMarketOpened (symbol) = ("%s%s__isMarketOpened__" + symbol)
44
44
 
45
45
 
46
46
 
func keyEmptyPriceMsg (position) = makeString(["%s%d%d__emptyPriceMsg", toString(height), toString(position)], SEP)
47
47
 
48
48
 
49
49
 
func keyIsBlocked (symbol) = ("%s%s__isBlocked__" + symbol)
50
50
 
51
51
 
52
52
 
func keyIsBlockedSender (symbol) = makeString(["%s%s%s__isBlocked", symbol, "sender"], SEP)
53
53
 
54
54
 
55
55
 
func keyIsBlockedReason (symbol) = makeString(["%s%s%s__isBlocked", symbol, "reason"], SEP)
56
56
 
57
57
 
58
58
 
func keyBlackSwarmPrice (h,symbol) = makeString(["%s%s%s%d__isBlocked", symbol, "blackSwarmPrice", toString(h)], SEP)
59
59
 
60
60
 
61
61
 
let DAYMILLIS = 86400000
62
62
 
63
63
 
let H4MILLIS = 14400000
64
64
 
65
65
 
func toPeriod (timestamp,period) = ((timestamp / period) * period)
66
66
 
67
67
 
68
68
 
func keyStats1stPeriod (symbol) = makeString(["%s%s", "stats1stPeriod", symbol], SEP)
69
69
 
70
70
 
71
71
 
func keyStatsPriceSum (symbol) = makeString(["%s%s", "statsPriceSum", symbol], SEP)
72
72
 
73
73
 
74
74
 
func keyStatsCountSum (symbol) = makeString(["%s%s", "statsCountSum", symbol], SEP)
75
75
 
76
76
 
77
77
 
func keyStatsByPeriodPriceSum (symbol,period) = makeString(["%s%s%d", "statsPriceSum", symbol, period], SEP)
78
78
 
79
79
 
80
80
 
func keyStatsByPeriodCountSum (symbol,period) = makeString(["%s%s%d", "statsCountSum", symbol, period], SEP)
81
81
 
82
82
 
83
83
 
func keyStatsByPeriodMin (symbol,period) = makeString(["%s%s%d", "statsPriceMin", symbol, period], SEP)
84
84
 
85
85
 
86
86
 
func keyStatsByPeriodMax (symbol,period) = makeString(["%s%s%d", "statsPriceMax", symbol, period], SEP)
87
87
 
88
88
 
89
89
 
func StatsEntry (symbol,price) = {
90
90
 
    let period = toPeriod(lastBlock.timestamp, H4MILLIS)
91
91
 
    let periodStr = toString(period)
92
92
 
    let stats1stPeriodKEY = keyStats1stPeriod(symbol)
93
93
 
    let statsPriceSumKEY = keyStatsPriceSum(symbol)
94
94
 
    let statsCountSumKEY = keyStatsCountSum(symbol)
95
95
 
    let statsByPeriodPriceSumKEY = keyStatsByPeriodPriceSum(symbol, periodStr)
96
96
 
    let statsByPeriodCountSumKEY = keyStatsByPeriodCountSum(symbol, periodStr)
97
97
 
    let statsByPeriodMinKEY = keyStatsByPeriodMin(symbol, periodStr)
98
98
 
    let statsByPeriodMaxKEY = keyStatsByPeriodMax(symbol, periodStr)
99
99
 
    let statsPriceSum = parseBigIntValue(valueOrElse(getString(this, statsPriceSumKEY), "0"))
100
100
 
    let statsCountSum = valueOrElse(getInteger(this, statsCountSumKEY), 0)
101
101
 
    let statsByPeriodMin = valueOrElse(getInteger(this, statsByPeriodMinKEY), 9223372036854775)
102
102
 
    let statsByPeriodMax = valueOrElse(getInteger(this, statsByPeriodMaxKEY), 0)
103
103
 
    let newStatsPriceSum = (statsPriceSum + toBigInt(price))
104
104
 
    let newStatsCountSum = (statsCountSum + 1)
105
105
 
    let newStatsByPeriodPriceSum = newStatsPriceSum
106
106
 
    let newStatsByPeriodCountSum = newStatsCountSum
107
107
 
    let newStatsByPeriodMin = min([statsByPeriodMin, price])
108
108
 
    let newStatsByPeriodMax = max([statsByPeriodMax, price])
109
109
 
    let stats1stPeriod = valueOrElse(getInteger(this, stats1stPeriodKEY), -1)
110
110
 
    ([StringEntry(statsPriceSumKEY, toString(newStatsPriceSum)), IntegerEntry(statsCountSumKEY, newStatsCountSum), StringEntry(statsByPeriodPriceSumKEY, toString(newStatsByPeriodPriceSum)), IntegerEntry(statsByPeriodCountSumKEY, newStatsByPeriodCountSum), IntegerEntry(statsByPeriodMinKEY, newStatsByPeriodMin), IntegerEntry(statsByPeriodMaxKEY, newStatsByPeriodMax)] ++ (if ((0 > stats1stPeriod))
111
111
 
        then [IntegerEntry(stats1stPeriodKEY, period)]
112
112
 
        else nil))
113
113
 
    }
114
114
 
115
115
 
116
116
 
func isGroupFinalaized (groupNum,finHeightStr) = isDefined(getBoolean(this, keyGroupStatus(groupNum, finHeightStr)))
117
117
 
118
118
 
119
119
 
func readGroupDataOrFail (groupNum) = {
120
120
 
    let k = keyGroupData(groupNum)
121
121
 
    let groupDataOpt = getString(this, k)
122
122
 
    if (isDefined(groupDataOpt))
123
123
 
        then value(groupDataOpt)
124
124
 
        else throw(("empty group data for key=" + k))
125
125
 
    }
126
126
 
127
127
 
128
128
 
let pubKeyOraclesList = split(getStringValue(this, keyOracles()), ",")
129
129
 
130
130
 
let oracleCount = size(pubKeyOraclesList)
131
131
 
132
132
 
let minConsensus = valueOrElse(getInteger(this, keyMinConsensus()), 3)
133
133
 
134
134
 
func PriceFailedResult (symbol,msg) = [StringEntry(keyPriceFailure(symbol), msg)]
135
135
 
136
136
 
137
137
 
func throwInvalidFinalizationHeight (finHeightStr) = throw(((("invalid finalization height: height=" + toString(height)) + " finalizationHeight=") + finHeightStr))
138
138
 
139
139
 
140
140
 
func throwGroupAlreadyFinalized (groupNum,finHeightStr) = throw((((("prices for groupNum=" + groupNum) + " at ") + finHeightStr) + " height have been already finalized"))
141
141
 
142
142
 
143
143
 
func throwInvalidSignsParamLength (num,param) = throw(((((("invalid signs" + toString(num)) + " parameter: actual.size=") + toString(size(param))) + " base58Val=") + toBase58String(param)))
144
144
 
145
145
 
146
146
 
func throwOutOfTurnFinalization () = throw(((("Out of turn finalization: " + toString(height)) + " block should be finalize by ") + pubKeyOraclesList[(height % oracleCount)]))
147
147
 
148
148
 
149
149
 
func throwBlockedError () = throw("contract is blocked by EMERGENCY SHUTDOWN action")
150
150
 
151
151
 
152
152
 
func PriceEntry (symbol,newPrice,isMarketOpened) = {
153
153
 
    let idx = valueOrElse(getInteger(this, keyIdx(symbol)), 0)
154
154
 
    let newIdx = (idx + 1)
155
155
 
[IntegerEntry(keyPrice(symbol), newPrice), IntegerEntry(keyLastHeight(symbol), height), IntegerEntry(keyPriceByHeight(symbol, height), newPrice), IntegerEntry(keyIdx(symbol), newIdx), IntegerEntry(keyIdx2Height(symbol, newIdx), height), IntegerEntry(keyHeight2Idx(symbol, height), newIdx), BooleanEntry(keyIsMarketOpened(symbol), isMarketOpened)]
156
156
 
    }
157
157
 
158
158
 
159
159
 
func finalizeUsdnUsdtOnchain () = {
160
160
 
    let symbol = "USDN-USDT"
161
161
 
    let usdnId = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
162
162
 
    let usdtId = "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ"
163
163
 
    let usdnAmount = 1000000000
164
164
 
    let wxPoolAddressStr = "3P8KMyAJCPWNcyedqrmymxaeWonvmkhGauz"
165
165
 
    let wxPoolAddress = addressFromStringValue(wxPoolAddressStr)
166
166
 
    let $t075807719 = {
167
167
 
        let @ = invoke(wxPoolAddress, "putOneTknV2WithBonusREADONLY", [usdnAmount, usdnId], nil)
168
168
 
        if ($isInstanceOf(@, "(Int, Int, Int)"))
169
169
 
            then @
170
170
 
            else throw(($getType(invoke(wxPoolAddress, "putOneTknV2WithBonusREADONLY", [usdnAmount, usdnId], nil)) + " couldn't be cast to (Int, Int, Int)"))
171
171
 
        }
172
172
 
    let lpAmount = $t075807719._1
173
173
 
    let feeAmount1 = $t075807719._2
174
174
 
    let bonus = $t075807719._3
175
175
 
    let $t077227840 = {
176
176
 
        let @ = invoke(wxPoolAddress, "getOneTknV2READONLY", [usdtId, lpAmount], nil)
177
177
 
        if ($isInstanceOf(@, "(Int, Int)"))
178
178
 
            then @
179
179
 
            else throw(($getType(invoke(wxPoolAddress, "getOneTknV2READONLY", [usdtId, lpAmount], nil)) + " couldn't be cast to (Int, Int)"))
180
180
 
        }
181
181
 
    let usdtAmount = $t077227840._1
182
182
 
    let feeAmount2 = $t077227840._2
183
183
 
    let newPrice = fraction(usdtAmount, 1000000, usdnAmount)
184
184
 
    (PriceEntry(symbol, newPrice, true) ++ StatsEntry(symbol, newPrice))
185
185
 
    }
186
186
 
187
187
 
188
188
 
func finalizeUsdnUsdtOnchainV2 () = {
189
189
 
    let wavesUsdtPriceX6 = getIntegerValue(this, "%s%s__price__WAVES-USDT")
190
190
 
    let ethUsdtPriceX6 = getIntegerValue(this, "%s%s__price__ETH-USDT")
191
191
 
    let symbol = "USDN-USDT"
192
192
 
    let xtnIdStr = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
193
193
 
    let xtnId = fromBase58String(xtnIdStr)
194
194
 
    let usdtIdStr = "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ"
195
195
 
    let usdnAmount = 1000000000
196
196
 
    let wxUsdtXtnPoolStr = "3P8KMyAJCPWNcyedqrmymxaeWonvmkhGauz"
197
197
 
    let wxUsdtXtnPoolAddress = addressFromStringValue(wxUsdtXtnPoolStr)
198
198
 
    let wxUsdtXtnW = 67
199
199
 
    let $t085528700 = {
200
200
 
        let @ = invoke(wxUsdtXtnPoolAddress, "putOneTknV2WithBonusREADONLY", [usdnAmount, xtnIdStr], nil)
201
201
 
        if ($isInstanceOf(@, "(Int, Int, Int)"))
202
202
 
            then @
203
203
 
            else throw(($getType(invoke(wxUsdtXtnPoolAddress, "putOneTknV2WithBonusREADONLY", [usdnAmount, xtnIdStr], nil)) + " couldn't be cast to (Int, Int, Int)"))
204
204
 
        }
205
205
 
    let lpAmount = $t085528700._1
206
206
 
    let feeAmount1 = $t085528700._2
207
207
 
    let bonus = $t085528700._3
208
208
 
    let $t087038831 = {
209
209
 
        let @ = invoke(wxUsdtXtnPoolAddress, "getOneTknV2READONLY", [usdtIdStr, lpAmount], nil)
210
210
 
        if ($isInstanceOf(@, "(Int, Int)"))
211
211
 
            then @
212
212
 
            else throw(($getType(invoke(wxUsdtXtnPoolAddress, "getOneTknV2READONLY", [usdtIdStr, lpAmount], nil)) + " couldn't be cast to (Int, Int)"))
213
213
 
        }
214
214
 
    let usdtAmount = $t087038831._1
215
215
 
    let feeAmount2 = $t087038831._2
216
216
 
    let wxUsdtXtnPrice = fraction(usdtAmount, 1000000, usdnAmount)
217
217
 
    let wxWavesXtnW = 487
218
218
 
    let wxWavesXtnPoolStr = "3PPZWgFNRKHLvM51pwS934C8VZ7d2F4Z58g"
219
219
 
    let wxWavesXtnPoolAddress = addressFromStringValue(wxWavesXtnPoolStr)
220
220
 
    let wavesWavesXtnX8 = wavesBalance(wxWavesXtnPoolAddress).regular
221
221
 
    let xtnWavesXtnX6 = assetBalance(wxWavesXtnPoolAddress, xtnId)
222
222
 
    let wavesXtnPriceX6 = fraction(xtnWavesXtnX6, 100000000, wavesWavesXtnX8)
223
223
 
    let wxWavesUsdtXtnPrice = fraction(wavesUsdtPriceX6, 1000000, wavesXtnPriceX6)
224
224
 
    let wxEthXtnW = 5
225
225
 
    let ethIdStr = "474jTeYx2r2Va35794tCScAXWJG9hU2HcgxzMowaZUnu"
226
226
 
    let ethId = fromBase58String(ethIdStr)
227
227
 
    let wxEthXtnPoolStr = "3PEMqetsaJDbYMw1XGovmE37FB8VUhGnX9A"
228
228
 
    let wxEthXtnPoolAddress = addressFromStringValue(wxEthXtnPoolStr)
229
229
 
    let ethEthXtnX8 = assetBalance(wxEthXtnPoolAddress, ethId)
230
230
 
    let xtnEthXtnX6 = assetBalance(wxEthXtnPoolAddress, xtnId)
231
231
 
    let ethXtnPriceX6 = fraction(xtnEthXtnX6, 100000000, ethEthXtnX8)
232
232
 
    let wxEthUsdtXtnPrice = fraction(ethUsdtPriceX6, 1000000, ethXtnPriceX6)
233
233
 
    let swopfiWavesXtnW = 433
234
234
 
    let swopfiRest = addressFromStringValue("3P56jNQzECXnrWpnbbSJKw7Eooo6fkUaMPp")
235
235
 
    let swopfiWavesXtnPriceX6 = {
236
236
 
        let @ = invoke(swopfiRest, "calcGetAmountCPMM", ["3PHaNgomBkrvEL2QnuJarQVJa71wjw9qiqG", "3PQHCTqfzE8e1Jo8m1QVaCXATSKyMmkYasF", "WAVES", 100000000], nil)
237
237
 
        if ($isInstanceOf(@, "Int"))
238
238
 
            then @
239
239
 
            else throw(($getType(invoke(swopfiRest, "calcGetAmountCPMM", ["3PHaNgomBkrvEL2QnuJarQVJa71wjw9qiqG", "3PQHCTqfzE8e1Jo8m1QVaCXATSKyMmkYasF", "WAVES", 100000000], nil)) + " couldn't be cast to Int"))
240
240
 
        }
241
241
 
    let swopfiWavesUsdtXtnPrice = fraction(wavesUsdtPriceX6, 1000000, swopfiWavesXtnPriceX6)
242
242
 
    let newPrice = (((fraction(wxUsdtXtnPrice, wxUsdtXtnW, 1000) + fraction(wxWavesUsdtXtnPrice, wxWavesXtnW, 1000)) + fraction(wxEthUsdtXtnPrice, wxEthXtnW, 1000)) + fraction(swopfiWavesUsdtXtnPrice, swopfiWavesXtnW, 1000))
243
243
 
    (PriceEntry(symbol, newPrice, true) ++ StatsEntry(symbol, newPrice))
244
244
 
    }
245
245
 
246
246
 
247
247
 
func finalizePriceV2Common (position,groupNum,groupDataStr,msgArray,signs) = {
248
248
 
    let msgOffset = (position * 3)
249
249
 
    if ((msgOffset >= size(msgArray)))
250
250
 
        then [StringEntry(keyEmptyPriceMsg(position), "price data is empty")]
251
251
 
        else {
252
252
 
            let symbol = msgArray[(msgOffset + 0)]
253
253
 
            let newPriceStr = msgArray[(msgOffset + 1)]
254
254
 
            let isMarketOpenedStr = msgArray[(msgOffset + 2)]
255
255
 
            let newPriceOpt = parseInt(newPriceStr)
256
256
 
            let isMarketOpenedOpt = parseInt(isMarketOpenedStr)
257
257
 
            let sig0 = take(signs, 64)
258
258
 
            let sig1 = take(drop(signs, 64), 64)
259
259
 
            let sig2 = take(drop(signs, 128), 64)
260
260
 
            let sig3 = take(drop(signs, 192), 64)
261
261
 
            let sig4 = takeRight(signs, 64)
262
262
 
            let isBlocked = valueOrElse(getBoolean(this, keyIsBlocked(symbol)), false)
263
263
 
            if ((symbol == ""))
264
264
 
                then nil
265
265
 
                else if (isBlocked)
266
266
 
                    then PriceFailedResult(symbol, (symbol + " is blocked"))
267
267
 
                    else if (contains(groupDataStr, symbol))
268
268
 
                        then if (if (isDefined(newPriceOpt))
269
269
 
                            then isDefined(isMarketOpenedOpt)
270
270
 
                            else false)
271
271
 
                            then {
272
272
 
                                let newPrice = value(newPriceOpt)
273
273
 
                                let isMarketOpened = if ((value(isMarketOpenedOpt) == 1))
274
274
 
                                    then true
275
275
 
                                    else false
276
276
 
                                let priceMsgStr = makeString(["WAVES-DORA2", groupNum, toString(height), symbol, newPriceStr, isMarketOpenedStr], ProtocolSEP)
277
277
 
                                let priceMsg = toBytes(priceMsgStr)
278
278
 
                                let verificationsCount = (((((if (sigVerify_8Kb(priceMsg, sig0, fromBase58String(pubKeyOraclesList[0])))
279
279
 
                                    then 1
280
280
 
                                    else 0) + (if (sigVerify_8Kb(priceMsg, sig1, fromBase58String(pubKeyOraclesList[1])))
281
281
 
                                    then 1
282
282
 
                                    else 0)) + (if (sigVerify_8Kb(priceMsg, sig2, fromBase58String(pubKeyOraclesList[2])))
283
283
 
                                    then 1
284
284
 
                                    else 0)) + (if (sigVerify_8Kb(priceMsg, sig3, fromBase58String(pubKeyOraclesList[3])))
285
285
 
                                    then 1
286
286
 
                                    else 0)) + (if (sigVerify_8Kb(priceMsg, sig4, fromBase58String(pubKeyOraclesList[4])))
287
287
 
                                    then 1
288
288
 
                                    else 0))
289
289
 
                                if ((verificationsCount >= minConsensus))
290
290
 
                                    then {
291
291
 
                                        let price = valueOrElse(getInteger(this, keyPrice(symbol)), 0)
292
292
 
                                        if (if ((price != 0))
293
293
 
                                            then if ((newPrice >= (price + ((price * percentPriceOffset) / 100))))
294
294
 
                                                then true
295
295
 
                                                else ((price - ((price * percentPriceOffset) / 100)) >= newPrice)
296
296
 
                                            else false)
297
297
 
                                            then {
298
298
 
                                                let reason = "automatic emergency shutdown because of large price variability"
299
299
 
[BooleanEntry(keyIsBlocked(symbol), true), StringEntry(keyIsBlockedSender(symbol), toString(this)), StringEntry(keyIsBlockedReason(symbol), reason), IntegerEntry(keyBlackSwarmPrice(height, symbol), newPrice)]
300
300
 
                                                }
301
301
 
                                            else (PriceEntry(symbol, newPrice, isMarketOpened) ++ StatsEntry(symbol, newPrice))
302
302
 
                                        }
303
303
 
                                    else PriceFailedResult(symbol, ((((((((("verificationsCount = " + toString(verificationsCount)) + "signs0.length=") + toString(size(signs))) + " msg0 = ") + priceMsgStr) + " sig0 = ") + toBase58String(sig0)) + " key0 = ") + pubKeyOraclesList[0]))
304
304
 
                                }
305
305
 
                            else PriceFailedResult(symbol, ((("data parsing error: newPrice=" + newPriceStr) + " isMarketOpened=") + isMarketOpenedStr))
306
306
 
                        else PriceFailedResult(symbol, ((symbol + " doesn't exist in group: groupDataStr=") + groupDataStr))
307
307
 
            }
308
308
 
    }
309
309
 
310
310
 
311
311
 
@Callable(i)
312
312
 
func finalizeDORA2 (header,msg,signs0,signs1,signs2,signs3) = {
313
313
 
    let headerArray = split(header, ProtocolSEP)
314
314
 
    let groupNum = headerArray[1]
315
315
 
    let finHeightStr = headerArray[2]
316
316
 
    let finHeight = parseIntValue(finHeightStr)
317
317
 
    let signsLength = (64 * oracleCount)
318
318
 
    if ((height != finHeight))
319
319
 
        then throwInvalidFinalizationHeight(finHeightStr)
320
320
 
        else if (isGroupFinalaized(groupNum, finHeightStr))
321
321
 
            then throwGroupAlreadyFinalized(groupNum, finHeightStr)
322
322
 
            else if ((pubKeyOraclesList[(height % oracleCount)] != toBase58String(i.callerPublicKey)))
323
323
 
                then throwOutOfTurnFinalization()
324
324
 
                else if ((size(signs0) != signsLength))
325
325
 
                    then throwInvalidSignsParamLength(0, signs0)
326
326
 
                    else if ((size(signs1) != signsLength))
327
327
 
                        then throwInvalidSignsParamLength(1, signs1)
328
328
 
                        else if ((size(signs2) != signsLength))
329
329
 
                            then throwInvalidSignsParamLength(2, signs2)
330
330
 
                            else if ((size(signs3) != signsLength))
331
331
 
                                then throwInvalidSignsParamLength(3, signs3)
332
332
 
                                else {
333
333
 
                                    let groupDataKey = keyGroupData(groupNum)
334
334
 
                                    let groupDataStr = valueOrErrorMessage(getString(this, groupDataKey), ("empty group data for key=" + groupDataKey))
335
335
 
                                    let msgArray = split(msg, ProtocolSEP)
336
336
 
                                    if (((size(msgArray) % 3) != 0))
337
337
 
                                        then throw(("msg parameters count must be multiple of 3: msgArray.size=" + toString(size(msg))))
338
-
                                        else ((((finalizePriceV2Common(0, groupNum, groupDataStr, msgArray, signs0) ++ finalizePriceV2Common(1, groupNum, groupDataStr, msgArray, signs1)) ++ finalizePriceV2Common(2, groupNum, groupDataStr, msgArray, signs2)) ++ finalizeUsdnUsdtOnchain()) :+ BooleanEntry(keyGroupStatus(groupNum, finHeightStr), true))
338
+
                                        else ((((finalizePriceV2Common(0, groupNum, groupDataStr, msgArray, signs0) ++ finalizePriceV2Common(1, groupNum, groupDataStr, msgArray, signs1)) ++ finalizePriceV2Common(2, groupNum, groupDataStr, msgArray, signs2)) ++ finalizeUsdnUsdtOnchainV2()) :+ BooleanEntry(keyGroupStatus(groupNum, finHeightStr), true))
339
339
 
                                    }
340
340
 
    }
341
341
 
342
342
 
343
343
 
344
344
 
@Callable(i)
345
345
 
func price (hours) = {
346
346
 
    let symbol = "USDN-USDT"
347
347
 
    let periodSTEP = H4MILLIS
348
348
 
    let maxHours = 80
349
349
 
    let iters = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
350
350
 
    if ((hours > maxHours))
351
351
 
        then throw("hours is greater then max 80")
352
352
 
        else if ((4 > hours))
353
353
 
            then throw("hours is less then min value 4")
354
354
 
            else {
355
355
 
                let currTime = lastBlock.timestamp
356
356
 
                let startTime = ((currTime - (hours * 3600000)) - H4MILLIS)
357
357
 
                let period = toPeriod(currTime, periodSTEP)
358
358
 
                let periodStr = toString(period)
359
359
 
                let smallestPeriod = getIntegerValue(this, keyStats1stPeriod(symbol))
360
360
 
                let startPeriodTmp = toPeriod(startTime, periodSTEP)
361
361
 
                let isEnoughData = (startPeriodTmp >= smallestPeriod)
362
362
 
                let startPeriod = if (isEnoughData)
363
363
 
                    then startPeriodTmp
364
364
 
                    else smallestPeriod
365
365
 
                let startPeriodStr = toString(startPeriod)
366
366
 
                let startPriceSumX = parseBigIntValue(getStringValue(this, keyStatsByPeriodPriceSum(symbol, startPeriodStr)))
367
367
 
                let startCountSum = getIntegerValue(this, keyStatsByPeriodCountSum(symbol, startPeriodStr))
368
368
 
                let endPriceSumX = if (isEnoughData)
369
369
 
                    then parseBigIntValue(getStringValue(this, keyStatsByPeriodPriceSum(symbol, periodStr)))
370
370
 
                    else toBigInt(0)
371
371
 
                let endCountSum = if (isEnoughData)
372
372
 
                    then getIntegerValue(this, keyStatsByPeriodCountSum(symbol, periodStr))
373
373
 
                    else 0
374
374
 
                let priceSum = toInt((endPriceSumX - startPriceSumX))
375
375
 
                let priceCount = (endCountSum - startCountSum)
376
376
 
                let priceAvg = (priceSum / priceCount)
377
377
 
                if ((0 >= priceAvg))
378
378
 
                    then throw("calculation error")
379
379
 
                    else {
380
380
 
                        func findMinMax (minAndMax,nextIdx) =                         {
381
381
 
                            let periodToCheck = (period - (nextIdx * periodSTEP))
382
382
 
                            if ((startPeriod > periodToCheck))
383
383
 
                                then minAndMax
384
384
 
                                else {
385
385
 
                                    let periodToCheckStr = toString(periodToCheck)
386
386
 
                                    let minVal = minAndMax._1
387
387
 
                                    let maxVal = minAndMax._2
388
388
 
                                    let newMinVal = getIntegerValue(this, keyStatsByPeriodMin(symbol, periodToCheckStr))
389
389
 
                                    let newMaxVal = getIntegerValue(this, keyStatsByPeriodMax(symbol, periodToCheckStr))
390
390
 
                                    $Tuple2(min([minVal, newMinVal]), max([maxVal, newMaxVal]))
391
391
 
                                    }
392
392
 
                            }
393
393
 
394
394
 
                        let price = getIntegerValue(this, keyPrice(symbol))
395
395
 
                        let minMaxSTRUCT = {
396
396
 
                            let $l = iters
397
397
 
                            let $s = size($l)
398
398
 
                            let $acc0 = $Tuple2(9223372036854775, 0)
399
399
 
                            func $f0_1 ($a,$i) =                             if (($i >= $s))
400
400
 
                                then $a
401
401
 
                                else findMinMax($a, $l[$i])
402
402
 
403
403
 
                            func $f0_2 ($a,$i) =                             if (($i >= $s))
404
404
 
                                then $a
405
405
 
                                else throw("List size exceeds 21")
406
406
 
407
407
 
                            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21)
408
408
 
                            }
409
409
 
                        $Tuple2(nil, $Tuple4(price, priceAvg, minMaxSTRUCT._1, minMaxSTRUCT._2))
410
410
 
                        }
411
411
 
                }
412
412
 
    }
413
413
 
414
414
 

github/deemru/w8io/786bc32 
57.41 ms ◑