tx · 7kApSDUeDfacUiKrBFh6BKf7mQzGc7b4eYMZbNkPdPn8

3Mzep1R5kHeC1ecKFkWjuhU3Gw4LAdCib9N:  -0.01500000 Waves

2024.02.02 15:53 [2958682] smart account 3Mzep1R5kHeC1ecKFkWjuhU3Gw4LAdCib9N > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7kApSDUeDfacUiKrBFh6BKf7mQzGc7b4eYMZbNkPdPn8",
    "fee": 1500000,
    "feeAssetId": null,
    "timestamp": 1706878424483,
    "version": 2,
    "chainId": 84,
    "sender": "3Mzep1R5kHeC1ecKFkWjuhU3Gw4LAdCib9N",
    "senderPublicKey": "41THq9VrFxHEvVGJyz2oMpJQErnSkkqJXpBypSDxa5Mv",
    "proofs": [
        "4jkjikVaE3BJ9ApSxPT9DuSpuDd7dzZdNgNSX1ZCYfPR6wYZvaVCAXjLHorT7x6skr1J7JtMuLBhpBSnzPBH1q1D"
    ],
    "script": "base64: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",
    "height": 2958682,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 9Baxx6DZuzk5XtHq4M33gUa7AX4drJS94JuNxzdoP9ew
Next: 3iP4L2rBh2y71LUyNFvSW5QSsy2rqEaX6Z7MhRfWvkYS

Diff: 
Old
New
Differences
455
455
 
    let skinTotal = valueOrElse(getInteger(powerContractAddress(factoryAddress), keySkinTotal(treasuryAddress)), 0)
456
456
 
    let pwrRemaining = (getAssetInfoOrFail(getLpAssetId(factoryAddress)).quantity / 100)
457
457
 
    let pwrAmount = (skinTotal + pwrRemaining)
458
-
    let factoryAddressWxBalanceRaw = getAssetsBalances(factoryAddress, [toBase58String(getLpAssetId(factoryAddress))])[0]
458
+
    let factoryAddressWxBalanceRaw = getAssetsBalances(factoryAddress, [toBase58String(wxAssetId)])[0]
459
459
 
    let factoryAddressWxBalance = if ((factoryAddressWxBalanceRaw > toBigInt(0)))
460
460
 
        then fromX18(factoryAddressWxBalanceRaw, pow(10, 0, usdtDecimals, 0, 0, DOWN))
461
461
 
        else throwErr("invalid factory wx balance")
487
487
 
    let skinTotal = valueOrElse(getInteger(powerContractAddress(factoryAddress), keySkinTotal(treasuryAddress)), 0)
488
488
 
    let pwrRemaining = (getAssetInfoOrFail(getLpAssetId(factoryAddress)).quantity / 100)
489
489
 
    let pwrAmount = (skinTotal + pwrRemaining)
490
-
    let factoryAddressWxBalanceRaw = getAssetsBalances(factoryAddress, [toBase58String(getLpAssetId(factoryAddress))])[0]
490
+
    let factoryAddressWxBalanceRaw = getAssetsBalances(factoryAddress, [toBase58String(wxAssetId)])[0]
491
491
 
    let factoryAddressWxBalance = if ((factoryAddressWxBalanceRaw > toBigInt(0)))
492
492
 
        then fromX18(factoryAddressWxBalanceRaw, pow(10, 0, usdtDecimals, 0, 0, DOWN))
493
493
 
        else throwErr("invalid factory wx balance")
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 7 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let chainId = take(drop(this.bytes, 1), 1)
5
5
 
6
6
 
let chainIdT = base58'2T'
7
7
 
8
8
 
let chainIdW = base58'2W'
9
9
 
10
10
 
let SEP = "__"
11
11
 
12
12
 
let WAVES = "WAVES"
13
13
 
14
14
 
let contractFilename = "wxdao_calculator.ride"
15
15
 
16
16
 
let mult8 = 100000000
17
17
 
18
18
 
let mult18 = toBigInt(1000000000000000000)
19
19
 
20
20
 
let wavesDecimals = 8
21
21
 
22
22
 
let usdtDecimals = 6
23
23
 
24
24
 
func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), mult18, toBigInt(origScaleMult))
25
25
 
26
26
 
27
27
 
func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), mult18))
28
28
 
29
29
 
30
30
 
func wrapErr (s) = ((contractFilename + ": ") + s)
31
31
 
32
32
 
33
33
 
func throwErr (s) = throw(wrapErr(s))
34
34
 
35
35
 
36
36
 
let wxAssetId = if ((chainId == chainIdW))
37
37
 
    then base58'Atqv59EYzjFGuitKVnMRk6H8FukjoV3ktPorbEys25on'
38
38
 
    else if ((chainId == chainIdT))
39
39
 
        then base58'EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc'
40
40
 
        else throwErr("invalid chain id")
41
41
 
42
42
 
func keyCurrentPeriod () = makeString(["%s", "currentPeriod"], SEP)
43
43
 
44
44
 
45
45
 
func keyStartHeightByPeriod (period) = makeString(["%s%d", "startHeight", toString(period)], SEP)
46
46
 
47
47
 
48
48
 
func keyPeriodLength () = makeString(["%s", "periodLength"], SEP)
49
49
 
50
50
 
51
51
 
func keyTreasuryValueByPeriod (period) = makeString(["%s%d", "treasuryValue", toString(period)], SEP)
52
52
 
53
53
 
54
54
 
func keySkinTotal (treasuryAddress) = ("skin_total_" + toString(treasuryAddress))
55
55
 
56
56
 
57
57
 
func keyPowerConfigAddress () = "%s__powerConfigAddress"
58
58
 
59
59
 
60
60
 
func powerConfigAddress (factoryAddress) = valueOrErrorMessage(match getString(factoryAddress, keyPowerConfigAddress()) {
61
61
 
    case s: String => 
62
62
 
        addressFromString(s)
63
63
 
    case _: Unit => 
64
64
 
        unit
65
65
 
    case _ => 
66
66
 
        throw("Match error")
67
67
 
}, wrapErr("invalid power config address"))
68
68
 
69
69
 
70
70
 
func keyPowerAssetId () = "powerAssetId"
71
71
 
72
72
 
73
73
 
func getPowerAssetId (factoryAddress) = fromBase58String(valueOrErrorMessage(getString(powerConfigAddress(factoryAddress), keyPowerAssetId()), wrapErr("invalid power asset id")))
74
74
 
75
75
 
76
76
 
func keyPowerContractAddress () = "%s__powerContractAddress"
77
77
 
78
78
 
79
79
 
func powerContractAddress (factoryAddress) = valueOrErrorMessage(match getString(factoryAddress, keyPowerContractAddress()) {
80
80
 
    case s: String => 
81
81
 
        addressFromString(s)
82
82
 
    case _: Unit => 
83
83
 
        unit
84
84
 
    case _ => 
85
85
 
        throw("Match error")
86
86
 
}, wrapErr("invalid power contract address"))
87
87
 
88
88
 
89
89
 
func keyPoolsFactoryAddress () = "%s__poolsFactoryAddress"
90
90
 
91
91
 
92
92
 
func getPoolsFactoryAddress (factoryAddress) = valueOrErrorMessage(match getString(factoryAddress, keyPoolsFactoryAddress()) {
93
93
 
    case s: String => 
94
94
 
        addressFromString(s)
95
95
 
    case _: Unit => 
96
96
 
        unit
97
97
 
    case _ => 
98
98
 
        throw("Match error")
99
99
 
}, wrapErr("invalid pools factory address"))
100
100
 
101
101
 
102
102
 
func keyTreasuryAddress () = "%s__treasuryAddress"
103
103
 
104
104
 
105
105
 
func getTreasuryAddress (factoryAddress) = valueOrErrorMessage(match getString(factoryAddress, keyTreasuryAddress()) {
106
106
 
    case s: String => 
107
107
 
        addressFromString(s)
108
108
 
    case _: Unit => 
109
109
 
        unit
110
110
 
    case _ => 
111
111
 
        throw("Match error")
112
112
 
}, wrapErr("invalid treasury address"))
113
113
 
114
114
 
115
115
 
func keyAssets () = "%s__assets"
116
116
 
117
117
 
118
118
 
func getAssetsStr (factoryAddress) = valueOrErrorMessage(getString(factoryAddress, keyAssets()), wrapErr("invalid assets"))
119
119
 
120
120
 
121
121
 
func keyLpAssetId () = "%s__lpAssetId"
122
122
 
123
123
 
124
124
 
func getLpAssetId (factoryAddress) = fromBase58String(valueOrErrorMessage(getString(factoryAddress, keyLpAssetId()), wrapErr("invalid lp asset id")))
125
125
 
126
126
 
127
127
 
func getAssetInfoOrFail (assetId) = valueOrErrorMessage(assetInfo(assetId), wrapErr("invalid asset info"))
128
128
 
129
129
 
130
130
 
func getAssetsBalances (targetAddress,assetIdList) = {
131
131
 
    func map (acc,nextAssetIdStr) =     {
132
132
 
        let balance = if ((nextAssetIdStr == WAVES))
133
133
 
            then toX18(wavesBalance(targetAddress).available, pow(10, 0, wavesDecimals, 0, 0, DOWN))
134
134
 
            else {
135
135
 
                let assetId = fromBase58String(nextAssetIdStr)
136
136
 
                let assetDecimals = getAssetInfoOrFail(assetId).decimals
137
137
 
                toX18(assetBalance(targetAddress, assetId), pow(10, 0, assetDecimals, 0, 0, DOWN))
138
138
 
                }
139
139
 
        (acc :+ balance)
140
140
 
        }
141
141
 
142
142
 
    let $l = assetIdList
143
143
 
    let $s = size($l)
144
144
 
    let $acc0 = nil
145
145
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
146
146
 
        then $a
147
147
 
        else map($a, $l[$i])
148
148
 
149
149
 
    func $f0_2 ($a,$i) =     if (($i >= $s))
150
150
 
        then $a
151
151
 
        else throw("List size exceeds 10")
152
152
 
153
153
 
    $f0_2($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)
154
154
 
    }
155
155
 
156
156
 
157
157
 
func getAssetsPrices (poolsFactoryAddress,assetIdList) = if ((chainId == chainIdW))
158
158
 
    then {
159
159
 
        let wavesUsdtAddressStr = "3PKfrupEydU2nZAghVjZAfvCwMBkzuR1F52"
160
160
 
        let wavesUsdtPrice = parseBigIntValue({
161
161
 
            let @ = invoke(poolsFactoryAddress, "getPrice", [wavesUsdtAddressStr], nil)
162
162
 
            if ($isInstanceOf(@, "String"))
163
163
 
                then @
164
164
 
                else throw(($getType(@) + " couldn't be cast to String"))
165
165
 
            })
166
166
 
        let wavesXtnAddressStr = "3PPZWgFNRKHLvM51pwS934C8VZ7d2F4Z58g"
167
167
 
        let wavesXtnPrice = parseBigIntValue({
168
168
 
            let @ = invoke(poolsFactoryAddress, "getPrice", [wavesXtnAddressStr], nil)
169
169
 
            if ($isInstanceOf(@, "String"))
170
170
 
                then @
171
171
 
                else throw(($getType(@) + " couldn't be cast to String"))
172
172
 
            })
173
173
 
        let xtnUsdtPrice = fraction(wavesUsdtPrice, mult18, wavesXtnPrice)
174
174
 
        func map (acc,nextAssetId) =         {
175
175
 
            let price =             match nextAssetId {
176
176
 
                case _ => 
177
177
 
                    if (("2thsACuHmzDMuNezPM32wg9a3BwUzBWDeSKakgz3cw21" == $match0))
178
178
 
                        then {
179
179
 
                            let pwrWavesAddressStr = "3PDi7Qq8pLQYvtKyTfQuqqPUWyhoYbU957t"
180
180
 
                            let pwrWavesPrice = parseBigIntValue({
181
181
 
                                let @ = invoke(poolsFactoryAddress, "getPrice", [pwrWavesAddressStr], nil)
182
182
 
                                if ($isInstanceOf(@, "String"))
183
183
 
                                    then @
184
184
 
                                    else throw(($getType(@) + " couldn't be cast to String"))
185
185
 
                                })
186
186
 
                            fraction(pwrWavesPrice, wavesUsdtPrice, mult18)
187
187
 
                            }
188
188
 
                        else if (("Atqv59EYzjFGuitKVnMRk6H8FukjoV3ktPorbEys25on" == $match0))
189
189
 
                            then {
190
190
 
                                let wxWavesAddressStr = "3PFzaH2ghpwANHFgjeva83N1yxzErELx2eh"
191
191
 
                                let wxWavesPrice = parseBigIntValue({
192
192
 
                                    let @ = invoke(poolsFactoryAddress, "getPrice", [wxWavesAddressStr], nil)
193
193
 
                                    if ($isInstanceOf(@, "String"))
194
194
 
                                        then @
195
195
 
                                        else throw(($getType(@) + " couldn't be cast to String"))
196
196
 
                                    })
197
197
 
                                fraction(wxWavesPrice, wavesUsdtPrice, mult18)
198
198
 
                                }
199
199
 
                            else if (("34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ" == $match0))
200
200
 
                                then {
201
201
 
                                    let wavesUsdtwxgAddressStr = "3PKMVZ7kQeaREajYi8Yc25Ro6mcNw5D6QSa"
202
202
 
                                    let wavesUsdtwxgPrice = parseBigIntValue({
203
203
 
                                        let @ = invoke(poolsFactoryAddress, "getPrice", [wavesUsdtwxgAddressStr], nil)
204
204
 
                                        if ($isInstanceOf(@, "String"))
205
205
 
                                            then @
206
206
 
                                            else throw(($getType(@) + " couldn't be cast to String"))
207
207
 
                                        })
208
208
 
                                    fraction(wavesUsdtPrice, mult18, wavesUsdtwxgPrice)
209
209
 
                                    }
210
210
 
                                else if (("6XtHjpXbs9RRJP2Sr9GUyVqzACcby9TkThHXnjVC5CDJ" == $match0))
211
211
 
                                    then {
212
212
 
                                        let wavesUsdcwxgAddressStr = "3P3g3eipfG2NZKKQE8DZXt2E9tRJqii9jcX"
213
213
 
                                        let wavesUsdcwxgPrice = parseBigIntValue({
214
214
 
                                            let @ = invoke(poolsFactoryAddress, "getPrice", [wavesUsdcwxgAddressStr], nil)
215
215
 
                                            if ($isInstanceOf(@, "String"))
216
216
 
                                                then @
217
217
 
                                                else throw(($getType(@) + " couldn't be cast to String"))
218
218
 
                                            })
219
219
 
                                        fraction(wavesUsdtPrice, mult18, wavesUsdcwxgPrice)
220
220
 
                                        }
221
221
 
                                    else if (("HZk1mbfuJpmxU1Fs4AX5MWLVYtctsNcg6e2C6VKqK8zk" == $match0))
222
222
 
                                        then {
223
223
 
                                            let ltcwxgXtnAddressStr = "3P94wvu5gA7VhjPgAB3twaeqdwHCwNK2vsn"
224
224
 
                                            let ltcwxgXtnPrice = parseBigIntValue({
225
225
 
                                                let @ = invoke(poolsFactoryAddress, "getPrice", [ltcwxgXtnAddressStr], nil)
226
226
 
                                                if ($isInstanceOf(@, "String"))
227
227
 
                                                    then @
228
228
 
                                                    else throw(($getType(@) + " couldn't be cast to String"))
229
229
 
                                                })
230
230
 
                                            fraction(ltcwxgXtnPrice, xtnUsdtPrice, mult18)
231
231
 
                                            }
232
232
 
                                        else if (("474jTeYx2r2Va35794tCScAXWJG9hU2HcgxzMowaZUnu" == $match0))
233
233
 
                                            then {
234
234
 
                                                let ethwxgWavesAddressStr = "3P3XGTN6s292g9iwYhs3TEqJqHiffQYojuE"
235
235
 
                                                let ethwxgWavesPrice = parseBigIntValue({
236
236
 
                                                    let @ = invoke(poolsFactoryAddress, "getPrice", [ethwxgWavesAddressStr], nil)
237
237
 
                                                    if ($isInstanceOf(@, "String"))
238
238
 
                                                        then @
239
239
 
                                                        else throw(($getType(@) + " couldn't be cast to String"))
240
240
 
                                                    })
241
241
 
                                                fraction(ethwxgWavesPrice, wavesUsdtPrice, mult18)
242
242
 
                                                }
243
243
 
                                            else if (("8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS" == $match0))
244
244
 
                                                then {
245
245
 
                                                    let btcwxgXtnAddressStr = "3PCBWDTA6jrFswd7gQgaE3Xk7gLM5RKofvp"
246
246
 
                                                    let btcwxgXtnPrice = parseBigIntValue({
247
247
 
                                                        let @ = invoke(poolsFactoryAddress, "getPrice", [btcwxgXtnAddressStr], nil)
248
248
 
                                                        if ($isInstanceOf(@, "String"))
249
249
 
                                                            then @
250
250
 
                                                            else throw(($getType(@) + " couldn't be cast to String"))
251
251
 
                                                        })
252
252
 
                                                    fraction(btcwxgXtnPrice, xtnUsdtPrice, mult18)
253
253
 
                                                    }
254
254
 
                                                else throwErr("invalid asset id")
255
255
 
            }
256
256
 
            (acc :+ price)
257
257
 
            }
258
258
 
259
259
 
        let $l = assetIdList
260
260
 
        let $s = size($l)
261
261
 
        let $acc0 = nil
262
262
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
263
263
 
            then $a
264
264
 
            else map($a, $l[$i])
265
265
 
266
266
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
267
267
 
            then $a
268
268
 
            else throw("List size exceeds 10")
269
269
 
270
270
 
        $f0_2($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)
271
271
 
        }
272
272
 
    else if ((chainId == chainIdT))
273
273
 
        then {
274
274
 
            func map (acc,nextAssetId) =             {
275
275
 
                let price =                 match nextAssetId {
276
276
 
                    case _ => 
277
277
 
                        if (("EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc" == $match0))
278
278
 
                            then {
279
279
 
                                let wxUsdtAddressStr = "3MrULQRLc52GWrJF1tMcAm4M78fPe57o9Kt"
280
280
 
                                let wxUsdtPrice = parseBigIntValue({
281
281
 
                                    let @ = invoke(poolsFactoryAddress, "getPrice", [wxUsdtAddressStr], nil)
282
282
 
                                    if ($isInstanceOf(@, "String"))
283
283
 
                                        then @
284
284
 
                                        else throw(($getType(@) + " couldn't be cast to String"))
285
285
 
                                    })
286
286
 
                                wxUsdtPrice
287
287
 
                                }
288
288
 
                            else if (("A7Ksh7fXyqm1KhKAiK3bAB2aiPSitQQF6v1pyu9SS3FR" == $match0))
289
289
 
                                then {
290
290
 
                                    let usdcUsdtAddressStr = "3MzKSdTH2jFbypLsoNfrH7QgkzSbx3EYwCA"
291
291
 
                                    let usdcUsdtPrice = parseBigIntValue({
292
292
 
                                        let @ = invoke(poolsFactoryAddress, "getPrice", [usdcUsdtAddressStr], nil)
293
293
 
                                        if ($isInstanceOf(@, "String"))
294
294
 
                                            then @
295
295
 
                                            else throw(($getType(@) + " couldn't be cast to String"))
296
296
 
                                        })
297
297
 
                                    usdcUsdtPrice
298
298
 
                                    }
299
299
 
                                else if (("8Q6SE2ANebufw8JuPjJVRjZD6drD8ihjNjM8xaGUSfdR" == $match0))
300
300
 
                                    then {
301
301
 
                                        let price = toBigInt(100000000)
302
302
 
                                        price
303
303
 
                                        }
304
304
 
                                    else throwErr("invalid asset id")
305
305
 
                }
306
306
 
                (acc :+ price)
307
307
 
                }
308
308
 
309
309
 
            let $l = assetIdList
310
310
 
            let $s = size($l)
311
311
 
            let $acc0 = nil
312
312
 
            func $f0_1 ($a,$i) =             if (($i >= $s))
313
313
 
                then $a
314
314
 
                else map($a, $l[$i])
315
315
 
316
316
 
            func $f0_2 ($a,$i) =             if (($i >= $s))
317
317
 
                then $a
318
318
 
                else throw("List size exceeds 10")
319
319
 
320
320
 
            $f0_2($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)
321
321
 
            }
322
322
 
        else throwErr("invalid chain id")
323
323
 
324
324
 
325
325
 
func calcTreasuryValue (factoryAddress) = {
326
326
 
    let treasuryAddress = getTreasuryAddress(factoryAddress)
327
327
 
    let poolsFactoryAddress = getPoolsFactoryAddress(factoryAddress)
328
328
 
    let assetsStr = split(getAssetsStr(factoryAddress), SEP)
329
329
 
    let assetsBalances = getAssetsBalances(treasuryAddress, assetsStr)
330
330
 
    let assetsPrices = getAssetsPrices(poolsFactoryAddress, assetsStr)
331
331
 
    func reduce (acc,nextAssetIdStr) =     {
332
332
 
        let assetId = fromBase58String(nextAssetIdStr)
333
333
 
        let index = valueOrErrorMessage(indexOf(assetsStr, nextAssetIdStr), wrapErr("invalid asset id"))
334
334
 
        let balance = assetsBalances[index]
335
335
 
        let price = assetsPrices[index]
336
336
 
        let assetValue = fraction(balance, price, mult18)
337
337
 
        (acc + assetValue)
338
338
 
        }
339
339
 
340
340
 
    let treasuryValue = {
341
341
 
        let $l = assetsStr
342
342
 
        let $s = size($l)
343
343
 
        let $acc0 = toBigInt(0)
344
344
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
345
345
 
            then $a
346
346
 
            else reduce($a, $l[$i])
347
347
 
348
348
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
349
349
 
            then $a
350
350
 
            else throw("List size exceeds 10")
351
351
 
352
352
 
        $f0_2($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)
353
353
 
        }
354
354
 
    treasuryValue
355
355
 
    }
356
356
 
357
357
 
358
358
 
@Callable(i)
359
359
 
func withdraw (args) = {
360
360
 
    let recipient = addressFromStringValue(args[0])
361
361
 
    let amount = parseIntValue(args[1])
362
362
 
    let result = invoke(i.caller, "transferWaves", [recipient.bytes, amount], nil)
363
363
 
    $Tuple2(nil, result)
364
364
 
    }
365
365
 
366
366
 
367
367
 
368
368
 
@Callable(i)
369
369
 
func setIntParam (args) = {
370
370
 
    let key = args[0]
371
371
 
    let val = parseIntValue(args[1])
372
372
 
    let result = invoke(i.caller, "integerEntry", [key, val], nil)
373
373
 
    $Tuple2(nil, result)
374
374
 
    }
375
375
 
376
376
 
377
377
 
378
378
 
@Callable(i)
379
379
 
func swap (callerPublicKey,args) = {
380
380
 
    let factoryAddress = i.caller
381
381
 
    let userAddress = addressFromPublicKey(callerPublicKey)
382
382
 
    let payment = if ((size(i.payments) == 1))
383
383
 
        then i.payments[0]
384
384
 
        else throwErr("1 payment is required")
385
385
 
    let err = wrapErr("invalid payment asset id")
386
386
 
    let paymentAssetId = if ((valueOrErrorMessage(payment.assetId, err) == getLpAssetId(factoryAddress)))
387
387
 
        then value(payment.assetId)
388
388
 
        else throwErr(err)
389
389
 
    let pwrPrice = 100
390
390
 
    let pwrAmount = (payment.amount / pwrPrice)
391
391
 
    let assetsStr = split(getAssetsStr(factoryAddress), SEP)
392
392
 
    let pwrBalance = assetBalance(factoryAddress, getPowerAssetId(factoryAddress))
393
393
 
    if ((pwrBalance == pwrBalance))
394
394
 
        then {
395
395
 
            let wxdaoQuantity = getAssetInfoOrFail(getLpAssetId(factoryAddress)).quantity
396
396
 
            if ((wxdaoQuantity == wxdaoQuantity))
397
397
 
                then {
398
398
 
                    let assetsBalances = getAssetsBalances(factoryAddress, assetsStr)
399
399
 
                    func map (acc,nextAssetIdStr) =                     {
400
400
 
                        let assetId = fromBase58String(nextAssetIdStr)
401
401
 
                        let index = valueOrErrorMessage(indexOf(assetsStr, nextAssetIdStr), wrapErr("invalid asset balance"))
402
402
 
                        let assetDecimals = getAssetInfoOrFail(assetId).decimals
403
403
 
                        let balance = fromX18(assetsBalances[index], pow(10, 0, assetDecimals, 0, 0, DOWN))
404
404
 
                        let amount = fraction(balance, payment.amount, wxdaoQuantity)
405
405
 
                        if ((amount > 0))
406
406
 
                            then $Tuple2((acc._1 :+ assetId), (acc._2 :+ amount))
407
407
 
                            else acc
408
408
 
                        }
409
409
 
410
410
 
                    let transfers = {
411
411
 
                        let $l = assetsStr
412
412
 
                        let $s = size($l)
413
413
 
                        let $acc0 = $Tuple2(nil, nil)
414
414
 
                        func $f0_1 ($a,$i) =                         if (($i >= $s))
415
415
 
                            then $a
416
416
 
                            else map($a, $l[$i])
417
417
 
418
418
 
                        func $f0_2 ($a,$i) =                         if (($i >= $s))
419
419
 
                            then $a
420
420
 
                            else throw("List size exceeds 6")
421
421
 
422
422
 
                        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
423
423
 
                        }
424
424
 
                    if ((transfers == transfers))
425
425
 
                        then {
426
426
 
                            let additionalLockRounds = 0
427
427
 
                            let factoryActions = ([invoke(factoryAddress, "commitAfterStartWithLockRoundFor", [toString(powerContractAddress(factoryAddress)), toString(factoryAddress), toString(userAddress), additionalLockRounds, getPowerAssetId(factoryAddress), pwrAmount], nil)] ++ (if ((size(transfers._1) == 0))
428
428
 
                                then nil
429
429
 
                                else [invoke(factoryAddress, "transferAssets", [userAddress.bytes, transfers._1, transfers._2], nil)]))
430
430
 
                            $Tuple2([Burn(paymentAssetId, payment.amount)], factoryActions)
431
431
 
                            }
432
432
 
                        else throw("Strict value is not equal to itself.")
433
433
 
                    }
434
434
 
                else throw("Strict value is not equal to itself.")
435
435
 
            }
436
436
 
        else throw("Strict value is not equal to itself.")
437
437
 
    }
438
438
 
439
439
 
440
440
 
441
441
 
@Callable(i)
442
442
 
func price (callerPublicKey,args) = {
443
443
 
    let factoryAddress = i.caller
444
444
 
    let poolsFactoryAddress = getPoolsFactoryAddress(factoryAddress)
445
445
 
    let currentPeriod = valueOrErrorMessage(getInteger(factoryAddress, keyCurrentPeriod()), wrapErr("invalid current period"))
446
446
 
    let startTreasuryValue = valueOrErrorMessage(getInteger(factoryAddress, keyTreasuryValueByPeriod(currentPeriod)), wrapErr(("invalid treasury value for period " + toString(currentPeriod))))
447
447
 
    let treasuryValue = fromX18(calcTreasuryValue(factoryAddress), pow(10, 0, usdtDecimals, 0, 0, DOWN))
448
448
 
    let treasuryValueDiff = (treasuryValue - startTreasuryValue)
449
449
 
    let pwrAssetId = getPowerAssetId(factoryAddress)
450
450
 
    let pwrPriceRaw = getAssetsPrices(poolsFactoryAddress, [toBase58String(pwrAssetId)])[0]
451
451
 
    let pwrPrice = if ((pwrPriceRaw > toBigInt(0)))
452
452
 
        then fromX18(pwrPriceRaw, pow(10, 0, usdtDecimals, 0, 0, DOWN))
453
453
 
        else throwErr("invalid PWR price")
454
454
 
    let treasuryAddress = getTreasuryAddress(factoryAddress)
455
455
 
    let skinTotal = valueOrElse(getInteger(powerContractAddress(factoryAddress), keySkinTotal(treasuryAddress)), 0)
456
456
 
    let pwrRemaining = (getAssetInfoOrFail(getLpAssetId(factoryAddress)).quantity / 100)
457
457
 
    let pwrAmount = (skinTotal + pwrRemaining)
458
-
    let factoryAddressWxBalanceRaw = getAssetsBalances(factoryAddress, [toBase58String(getLpAssetId(factoryAddress))])[0]
458
+
    let factoryAddressWxBalanceRaw = getAssetsBalances(factoryAddress, [toBase58String(wxAssetId)])[0]
459
459
 
    let factoryAddressWxBalance = if ((factoryAddressWxBalanceRaw > toBigInt(0)))
460
460
 
        then fromX18(factoryAddressWxBalanceRaw, pow(10, 0, usdtDecimals, 0, 0, DOWN))
461
461
 
        else throwErr("invalid factory wx balance")
462
462
 
    let wxPriceRaw = getAssetsPrices(poolsFactoryAddress, [toBase58String(wxAssetId)])[0]
463
463
 
    let wxPrice = if ((wxPriceRaw > toBigInt(0)))
464
464
 
        then fromX18(wxPriceRaw, pow(10, 0, usdtDecimals, 0, 0, DOWN))
465
465
 
        else throwErr("invalid wx price")
466
466
 
    let wxdaoQuantity = getAssetInfoOrFail(getLpAssetId(factoryAddress)).quantity
467
467
 
    let price = (((pwrPrice / 100) + fraction(factoryAddressWxBalance, wxPrice, wxdaoQuantity)) + fraction(max([treasuryValueDiff, 0]), 2, (1000 * pwrAmount)))
468
468
 
    $Tuple2(nil, price)
469
469
 
    }
470
470
 
471
471
 
472
472
 
473
473
 
@Callable(i)
474
474
 
func priceDebug (callerPublicKey,args) = {
475
475
 
    let factoryAddress = i.caller
476
476
 
    let poolsFactoryAddress = getPoolsFactoryAddress(factoryAddress)
477
477
 
    let currentPeriod = valueOrErrorMessage(getInteger(factoryAddress, keyCurrentPeriod()), wrapErr("invalid current period"))
478
478
 
    let startTreasuryValue = valueOrErrorMessage(getInteger(factoryAddress, keyTreasuryValueByPeriod(currentPeriod)), wrapErr(("invalid treasury value for period " + toString(currentPeriod))))
479
479
 
    let treasuryValue = fromX18(calcTreasuryValue(factoryAddress), pow(10, 0, usdtDecimals, 0, 0, DOWN))
480
480
 
    let treasuryValueDiff = (treasuryValue - startTreasuryValue)
481
481
 
    let pwrAssetId = getPowerAssetId(factoryAddress)
482
482
 
    let pwrPriceRaw = getAssetsPrices(poolsFactoryAddress, [toBase58String(pwrAssetId)])[0]
483
483
 
    let pwrPrice = if ((pwrPriceRaw > toBigInt(0)))
484
484
 
        then fromX18(pwrPriceRaw, pow(10, 0, usdtDecimals, 0, 0, DOWN))
485
485
 
        else throwErr("invalid PWR price")
486
486
 
    let treasuryAddress = getTreasuryAddress(factoryAddress)
487
487
 
    let skinTotal = valueOrElse(getInteger(powerContractAddress(factoryAddress), keySkinTotal(treasuryAddress)), 0)
488
488
 
    let pwrRemaining = (getAssetInfoOrFail(getLpAssetId(factoryAddress)).quantity / 100)
489
489
 
    let pwrAmount = (skinTotal + pwrRemaining)
490
-
    let factoryAddressWxBalanceRaw = getAssetsBalances(factoryAddress, [toBase58String(getLpAssetId(factoryAddress))])[0]
490
+
    let factoryAddressWxBalanceRaw = getAssetsBalances(factoryAddress, [toBase58String(wxAssetId)])[0]
491
491
 
    let factoryAddressWxBalance = if ((factoryAddressWxBalanceRaw > toBigInt(0)))
492
492
 
        then fromX18(factoryAddressWxBalanceRaw, pow(10, 0, usdtDecimals, 0, 0, DOWN))
493
493
 
        else throwErr("invalid factory wx balance")
494
494
 
    let wxPriceRaw = getAssetsPrices(poolsFactoryAddress, [toBase58String(wxAssetId)])[0]
495
495
 
    let wxPrice = if ((wxPriceRaw > toBigInt(0)))
496
496
 
        then fromX18(wxPriceRaw, pow(10, 0, usdtDecimals, 0, 0, DOWN))
497
497
 
        else throwErr("invalid wx price")
498
498
 
    let wxdaoQuantity = getAssetInfoOrFail(getLpAssetId(factoryAddress)).quantity
499
499
 
    let price = (((pwrPrice / 100) + fraction(factoryAddressWxBalance, wxPrice, wxdaoQuantity)) + fraction(max([treasuryValueDiff, 0]), 2, (1000 * pwrAmount)))
500
500
 
    $Tuple2(nil, [price, pwrPrice, factoryAddressWxBalance, wxPrice, wxdaoQuantity, treasuryValueDiff, pwrAmount])
501
501
 
    }
502
502
 
503
503
 
504
504
 
505
505
 
@Callable(i)
506
506
 
func getTreasuryValue (callerPublicKey,args) = {
507
507
 
    let factoryAddress = i.caller
508
508
 
    let treasuryValue = fromX18(calcTreasuryValue(factoryAddress), pow(10, 0, usdtDecimals, 0, 0, DOWN))
509
509
 
    $Tuple2(nil, treasuryValue)
510
510
 
    }
511
511
 
512
512
 
513
513
 
@Verifier(tx)
514
514
 
func verify () = (chainId == chainIdT)
515
515
 

github/deemru/w8io/c3f4982 
61.46 ms ◑