tx · 4bMJ1pGGg6VNhmSb5F74VxHTeVTT8WcKGE7h5qPyovJP

3MvRWw2FPEimFCTGtK7qY9uAJbM7XJ4ZfJS:  -0.04200000 Waves

2023.07.17 13:16 [2669725] smart account 3MvRWw2FPEimFCTGtK7qY9uAJbM7XJ4ZfJS > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "4bMJ1pGGg6VNhmSb5F74VxHTeVTT8WcKGE7h5qPyovJP",
    "fee": 4200000,
    "feeAssetId": null,
    "timestamp": 1689588983495,
    "version": 2,
    "chainId": 84,
    "sender": "3MvRWw2FPEimFCTGtK7qY9uAJbM7XJ4ZfJS",
    "senderPublicKey": "HP8sssVq1866F7CaPQJwgFrt6fsqhQjKwM84cL1wjD2a",
    "proofs": [
        "4GSrRJzjY7vs1zWKKeAZ8HXG7YKRRbuMYU635mf9YxQYa8ZzmWLMVGK3ssBgHmFKF45fKgS5BqdjiGv7UWZy2kt4"
    ],
    "script": "base64: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",
    "height": 2669725,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: CKegv3nBeZXNT8TaH5TS7f6RFSrBSmHpfcoQAf9CH8i2
Next: 4kDj884iCvd4ktETz2jmJpahH5QGtZSiNvwzrQYLCXaY

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let SF_POOL = "SF"
5
5
 
6
6
 
let WX_POOL = "WX"
7
7
 
8
8
 
let CAP_FEE_NO_LOAN = "capNoLoan"
9
9
 
10
10
 
let CAP_FEE_LOAN = "capLoan"
11
11
 
12
12
 
let STOPLOSS_FEE_NO_LOAN = "stopLossNoLoan"
13
13
 
14
14
 
let STOPLOSS_LOAN = "stopLossLoan"
15
15
 
16
16
 
let LOAN_FEE = "loan"
17
17
 
18
18
 
let NO_LOAN_FEE = "noLoan"
19
19
 
20
20
 
let NO_FEE = "noFee"
21
21
 
22
22
 
let SCALE8 = 100000000
23
23
 
24
24
 
let SCALE10 = 10000000000
25
25
 
26
26
 
let SCALE16 = toBigInt(10000000000000000)
27
27
 
28
28
 
let FEE_SCALE6 = 1000000
29
29
 
30
30
 
let kSFPoolAAssetBalance = "A_asset_balance"
31
31
 
32
32
 
let kSFPoolBAssetBalance = "B_asset_balance"
33
33
 
34
34
 
let kSFPoolAAssetId = "A_asset_id"
35
35
 
36
36
 
let kSFPoolBAssetId = "B_asset_id"
37
37
 
38
38
 
let kSFPoolShareId = "share_asset_id"
39
39
 
40
40
 
let kSFPoolShareSupply = "share_asset_supply"
41
41
 
42
42
 
let kSFPoolFee = "commission"
43
43
 
44
44
 
let kUserPosition = "_user_position"
45
45
 
46
46
 
let kUserPositionPool = "_user_position_pool"
47
47
 
48
48
 
let kUserBorrowAmount = "_user_position_borrow_amount"
49
49
 
50
50
 
let kUserBorrowAssetId = "_user_position_borrow_asset_id"
51
51
 
52
52
 
let kUserPositionNum = "_user_position_number"
53
53
 
54
54
 
let kUserPositionInterest = "_user_position_interest"
55
55
 
56
56
 
let kPoolTotal = "_pool_total"
57
57
 
58
58
 
let kPoolTotalLoan = "_pool_total_loan"
59
59
 
60
60
 
let kPoolInterestLoan = "_pool_interest_loan"
61
61
 
62
62
 
let kPoolInterestNoLoan = "_pool_interest_no_loan"
63
63
 
64
64
 
let kPoolCanBorrow = "_pool_can_borrow"
65
65
 
66
66
 
let kAxlyInFeeWithoutLoan = "_axly_fee_without_loan"
67
67
 
68
68
 
let kAxlyInFeeWithLoan = "_axly_fee_with_loan"
69
69
 
70
70
 
let kAxlyNoLoanCapFee = "_axly_fee_cap_with_loan"
71
71
 
72
72
 
let kAxlyWithLoanCapFee = "_axly_fee_cap_no_loan"
73
73
 
74
74
 
let kAxlyStopLossNoLoanFee = "_axly_fee_stoploss_with_loan"
75
75
 
76
76
 
let kAxlyStopLossLoanFee = "_axly_fee_stoploss_no_loan"
77
77
 
78
78
 
let kRequestId = "_request_id"
79
79
 
80
80
 
let kRequestIter = "requests_iter"
81
81
 
82
82
 
let kPool = "pool_"
83
83
 
84
84
 
let kSharePool = "_pool_share_id"
85
85
 
86
86
 
let kPoolCapChange = "_pool_cap_change"
87
87
 
88
88
 
let kTokenLastPrice = "last_price"
89
89
 
90
90
 
let kPriceInOracle = "_twap5B"
91
91
 
92
92
 
let kUserStopLoss = "_stop_loss"
93
93
 
94
94
 
let kMoneyBox = "axly_money_box"
95
95
 
96
96
 
let kSFFarmingAddr = "swopfi_farming_addr"
97
97
 
98
98
 
let kLendService = "lend_service_addr"
99
99
 
100
100
 
let kAdminCallPK = "admin_call_pub_key"
101
101
 
102
102
 
let kPriceOracle = "price_oracle"
103
103
 
104
104
 
let kExContract = "exchange_contract"
105
105
 
106
106
 
let kWxSwapContract = "wx_swap_contract"
107
107
 
108
108
 
let kSwopId = "swop_id"
109
109
 
110
110
 
let kWxId = "wx_id"
111
111
 
112
112
 
let moneyBox = Address(fromBase58String(valueOrErrorMessage(getString(this, kMoneyBox), "No axly moneyBox address")))
113
113
 
114
114
 
let exContract = Address(fromBase58String(valueOrErrorMessage(getString(this, kExContract), "No exchange contract address")))
115
115
 
116
116
 
let priceOracleAddr = Address(fromBase58String(valueOrErrorMessage(getString(this, kPriceOracle), "No price oracle address")))
117
117
 
118
118
 
let wxSwapContract = Address(fromBase58String(valueOrErrorMessage(getString(this, kWxSwapContract), "No wx swap address")))
119
119
 
120
120
 
let SWOPID = fromBase58String(valueOrErrorMessage(getString(this, kSwopId), "No swop id"))
121
121
 
122
122
 
let WXID = fromBase58String(valueOrErrorMessage(getString(this, kWxId), "No wx id"))
123
123
 
124
124
 
func getLendSrvAddr () = Address(fromBase58String(valueOrErrorMessage(getString(this, kLendService), "Can't get lend service addr")))
125
125
 
126
126
 
127
127
 
func getAdminCallAddr () = addressFromPublicKey(fromBase58String(valueOrErrorMessage(getString(this, kAdminCallPK), "Can't get admin addr")))
128
128
 
129
129
 
130
130
 
func isAdminCall (i) = if ((i.caller == getAdminCallAddr()))
131
131
 
    then unit
132
132
 
    else throw("Only admin can call this function")
133
133
 
134
134
 
135
135
 
func isSelfCall (i) = if ((i.caller == this))
136
136
 
    then unit
137
137
 
    else throw("Only contract itself can call this function")
138
138
 
139
139
 
140
140
 
func isLandCall (i) = if ((i.caller == getLendSrvAddr()))
141
141
 
    then unit
142
142
 
    else throw("Only land contract can call this function")
143
143
 
144
144
 
145
145
 
func accountBalance (assetId) = match assetId {
146
146
 
    case id: ByteVector => 
147
147
 
        assetBalance(this, id)
148
148
 
    case waves: Unit => 
149
149
 
        wavesBalance(this).available
150
150
 
    case _ => 
151
151
 
        throw("Match error")
152
152
 
}
153
153
 
154
154
 
155
155
 
func getSFPoolBalances (poolAddr) = $Tuple2(valueOrErrorMessage(getInteger(poolAddr, kSFPoolAAssetBalance), "Can't get pool A asset balance"), valueOrErrorMessage(getInteger(poolAddr, kSFPoolBAssetBalance), "Can't get pool B asset balance"))
156
156
 
157
157
 
158
158
 
func getWXPoolBalances (poolAddr,aId,bId) = $Tuple2({
159
159
 
    let @ = invoke(poolAddr, "getAccBalanceWrapperREADONLY", [aId], nil)
160
160
 
    if ($isInstanceOf(@, "Int"))
161
161
 
        then @
162
162
 
        else throw(($getType(@) + " couldn't be cast to Int"))
163
163
 
    }, {
164
164
 
    let @ = invoke(poolAddr, "getAccBalanceWrapperREADONLY", [bId], nil)
165
165
 
    if ($isInstanceOf(@, "Int"))
166
166
 
        then @
167
167
 
        else throw(($getType(@) + " couldn't be cast to Int"))
168
168
 
    })
169
169
 
170
170
 
171
171
 
func getPoolBalances (poolAddr,type,aId,bId) = if ((type == SF_POOL))
172
172
 
    then getSFPoolBalances(poolAddr)
173
173
 
    else if ((type == WX_POOL))
174
174
 
        then getWXPoolBalances(poolAddr, aId, bId)
175
175
 
        else throw("Wrong pool type")
176
176
 
177
177
 
178
178
 
func getSFPoolData (poolAddr) = {
179
179
 
    let $t061916240 = getSFPoolBalances(poolAddr)
180
180
 
    if (($t061916240 == $t061916240))
181
181
 
        then {
182
182
 
            let balB = $t061916240._2
183
183
 
            let balA = $t061916240._1
184
184
 
            $Tuple5(valueOrErrorMessage(getString(poolAddr, kSFPoolAAssetId), "Can't get pool A asset id"), valueOrErrorMessage(getString(poolAddr, kSFPoolBAssetId), "Can't get pool B asset id"), balA, balB, valueOrErrorMessage(getString(poolAddr, kSFPoolShareId), "Can't get share asset id"))
185
185
 
            }
186
186
 
        else throw("Strict value is not equal to itself.")
187
187
 
    }
188
188
 
189
189
 
190
190
 
func getWXPoolData (poolAddr) = {
191
191
 
    let cfg = {
192
192
 
        let @ = invoke(poolAddr, "getPoolConfigWrapperREADONLY", nil, nil)
193
193
 
        if ($isInstanceOf(@, "List[Any]"))
194
194
 
            then @
195
195
 
            else throw(($getType(@) + " couldn't be cast to List[Any]"))
196
196
 
        }
197
197
 
    if ((cfg == cfg))
198
198
 
        then {
199
199
 
            let aId = valueOrErrorMessage({
200
200
 
                let @ = cfg[4]
201
201
 
                if ($isInstanceOf(@, "String"))
202
202
 
                    then @
203
203
 
                    else unit
204
204
 
                }, "Can't get pool A asset id")
205
205
 
            let bId = valueOrErrorMessage({
206
206
 
                let @ = cfg[5]
207
207
 
                if ($isInstanceOf(@, "String"))
208
208
 
                    then @
209
209
 
                    else unit
210
210
 
                }, "Can't get pool B asset id")
211
211
 
            let shareId = valueOrErrorMessage({
212
212
 
                let @ = cfg[3]
213
213
 
                if ($isInstanceOf(@, "String"))
214
214
 
                    then @
215
215
 
                    else unit
216
216
 
                }, "Can't get pool LP asset id")
217
217
 
            let $t069376996 = getWXPoolBalances(poolAddr, aId, bId)
218
218
 
            if (($t069376996 == $t069376996))
219
219
 
                then {
220
220
 
                    let balB = $t069376996._2
221
221
 
                    let balA = $t069376996._1
222
222
 
                    $Tuple5(aId, bId, balA, balB, shareId)
223
223
 
                    }
224
224
 
                else throw("Strict value is not equal to itself.")
225
225
 
            }
226
226
 
        else throw("Strict value is not equal to itself.")
227
227
 
    }
228
228
 
229
229
 
230
230
 
func getPoolData (poolAddr,type) = if ((type == SF_POOL))
231
231
 
    then getSFPoolData(poolAddr)
232
232
 
    else if ((type == WX_POOL))
233
233
 
        then getWXPoolData(poolAddr)
234
234
 
        else throw("Wrong pool type")
235
235
 
236
236
 
237
237
 
func getShareSupply (poolAddr,type,shareId) = if ((type == SF_POOL))
238
238
 
    then valueOrErrorMessage(getInteger(poolAddr, kSFPoolShareSupply), "Can't get share asset supply")
239
239
 
    else if ((type == WX_POOL))
240
240
 
        then valueOrErrorMessage(assetInfo(fromBase58String(shareId)), "Wrong ShareId").quantity
241
241
 
        else throw("Wrong pool type")
242
242
 
243
243
 
244
244
 
func getPoolTotalShare (pool) = valueOrElse(getInteger(this, (pool + kPoolTotal)), 0)
245
245
 
246
246
 
247
247
 
func getPoolTotalShareWithLoan (pool) = valueOrElse(getInteger(this, (pool + kPoolTotalLoan)), 0)
248
248
 
249
249
 
250
250
 
func getNewUserPositionNumber (user) = (valueOrElse(getInteger(this, (user + kUserPositionNum)), 0) + 1)
251
251
 
252
252
 
253
253
 
func getAxlyFee (pool,feeType) = if ((feeType == CAP_FEE_LOAN))
254
254
 
    then getIntegerValue(this, (pool + kAxlyWithLoanCapFee))
255
255
 
    else if ((feeType == CAP_FEE_NO_LOAN))
256
256
 
        then getIntegerValue(this, (pool + kAxlyNoLoanCapFee))
257
257
 
        else if ((feeType == LOAN_FEE))
258
258
 
            then getIntegerValue(this, (pool + kAxlyInFeeWithLoan))
259
259
 
            else if ((feeType == NO_LOAN_FEE))
260
260
 
                then getIntegerValue(this, (pool + kAxlyInFeeWithoutLoan))
261
261
 
                else if ((feeType == NO_FEE))
262
262
 
                    then 0
263
263
 
                    else throw("Wrong fee type")
264
264
 
265
265
 
266
266
 
func getSFFarmingAddr () = Address(fromBase58String(valueOrErrorMessage(getString(this, kSFFarmingAddr), "Can't get swopfi farming addr")))
267
267
 
268
268
 
269
269
 
func getWXFarmingAddr (poolAddr) = {
270
270
 
    let fContract = Address(fromBase58String(valueOrErrorMessage(getString(poolAddr, "%s__factoryContract"), "Can't get WX factory contract addr")))
271
271
 
    let factroyCfg = split(valueOrErrorMessage(getString(fContract, "%s__factoryConfig"), "Can't get WX factory cfg"), "__")
272
272
 
    Address(fromBase58String(factroyCfg[1]))
273
273
 
    }
274
274
 
275
275
 
276
276
 
func assetIdToStr (assetId) = match assetId {
277
277
 
    case id: ByteVector => 
278
278
 
        toBase58String(id)
279
279
 
    case waves: Unit => 
280
280
 
        "WAVES"
281
281
 
    case _ => 
282
282
 
        throw("Not Asset id")
283
283
 
}
284
284
 
285
285
 
286
286
 
func assetIdFromStr (assetId) = if ((assetId == "WAVES"))
287
287
 
    then unit
288
288
 
    else fromBase58String(assetId)
289
289
 
290
290
 
291
291
 
func getAssetDecimals (assetId) = if ((assetId == "WAVES"))
292
292
 
    then 8
293
293
 
    else     match assetInfo(fromBase58String(assetId)) {
294
294
 
        case asset: Asset => 
295
295
 
            asset.decimals
296
296
 
        case _ => 
297
297
 
            throw("Can't find asset")
298
298
 
    }
299
299
 
300
300
 
301
301
 
func getAssetPrecition (assetId) = pow(10, 0, getAssetDecimals(assetId), 0, 0, DOWN)
302
302
 
303
303
 
304
304
 
func getAssetsPrice (assetIds) = {
305
305
 
    func getPrices (a,assetId) =     {
306
306
 
        let assetPrice = getIntegerValue(priceOracleAddr, (assetId + kPriceInOracle))
307
307
 
        (a :+ assetPrice)
308
308
 
        }
309
309
 
310
310
 
    let $l = assetIds
311
311
 
    let $s = size($l)
312
312
 
    let $acc0 = nil
313
313
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
314
314
 
        then $a
315
315
 
        else getPrices($a, $l[$i])
316
316
 
317
317
 
    func $f0_2 ($a,$i) =     if (($i >= $s))
318
318
 
        then $a
319
319
 
        else throw("List size exceeds 50")
320
320
 
321
321
 
    $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($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($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), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
322
322
 
    }
323
323
 
324
324
 
325
325
 
func getSharePrice (shareId) = {
326
326
 
    let pool = valueOrErrorMessage(getString(this, (shareId + kSharePool)), "Can't find pool addr by share id")
327
327
 
    let poolAddr = Address(fromBase58String(pool))
328
328
 
    let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Pool is not inited")
329
329
 
    let $t0998810053 = getPoolData(poolAddr, pType)
330
330
 
    let aId = $t0998810053._1
331
331
 
    let bId = $t0998810053._2
332
332
 
    let aBalance = $t0998810053._3
333
333
 
    let bBalance = $t0998810053._4
334
334
 
    let dPriceA = getIntegerValue(priceOracleAddr, (aId + kPriceInOracle))
335
335
 
    let dPriceB = getIntegerValue(priceOracleAddr, (bId + kPriceInOracle))
336
336
 
    let shareSupply = getShareSupply(poolAddr, pType, shareId)
337
337
 
    let APrecision = pow(10, 0, getAssetDecimals(aId), 0, 0, DOWN)
338
338
 
    let BPrecision = pow(10, 0, getAssetDecimals(bId), 0, 0, DOWN)
339
339
 
    let sharePrecision = pow(10, 0, getAssetDecimals(shareId), 0, 0, DOWN)
340
340
 
    let sum = (fraction(aBalance, dPriceA, APrecision) + fraction(bBalance, dPriceB, BPrecision))
341
341
 
    fraction(sum, sharePrecision, shareSupply)
342
342
 
    }
343
343
 
344
344
 
345
345
 
func getSharePrices (shareIds) = {
346
346
 
    func getPrices (a,shareId) =     (a :+ getSharePrice(shareId))
347
347
 
348
348
 
    let $l = shareIds
349
349
 
    let $s = size($l)
350
350
 
    let $acc0 = nil
351
351
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
352
352
 
        then $a
353
353
 
        else getPrices($a, $l[$i])
354
354
 
355
355
 
    func $f0_2 ($a,$i) =     if (($i >= $s))
356
356
 
        then $a
357
357
 
        else throw("List size exceeds 20")
358
358
 
359
359
 
    $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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
360
360
 
    }
361
361
 
362
362
 
363
363
 
func getCursEntries (aId,bId,shareId,wAmounts) = {
364
364
 
    let assetsPrices = getAssetsPrice([aId, bId])
365
365
 
    let sharePrice = getSharePrice(shareId)
366
366
 
    let prices = ([toString(assetsPrices[0]), toString(assetsPrices[1]), toString(sharePrice)] ++ wAmounts)
367
367
 
[StringEntry(kTokenLastPrice, makeString(prices, ","))]
368
368
 
    }
369
369
 
370
370
 
371
371
 
func calcReplenishByTwoTokens (pType,poolAddr,pmtA,aId,pmtB,bId,balA,balB) = if ((pType == SF_POOL))
372
372
 
    then {
373
373
 
        let repl = {
374
374
 
            let @ = invoke(poolAddr, "callFunction", ["calcLPReplenishTwoTokensREADONLY", [toString(pmtA), toString(pmtB)]], nil)
375
375
 
            if ($isInstanceOf(@, "List[Any]"))
376
376
 
                then @
377
377
 
                else throw(($getType(@) + " couldn't be cast to List[Any]"))
378
378
 
            }
379
379
 
        if ((repl == repl))
380
380
 
            then $Tuple5({
381
381
 
                let @ = repl[3]
382
382
 
                if ($isInstanceOf(@, "Int"))
383
383
 
                    then @
384
384
 
                    else throw(($getType(@) + " couldn't be cast to Int"))
385
385
 
                }, {
386
386
 
                let @ = repl[4]
387
387
 
                if ($isInstanceOf(@, "Int"))
388
388
 
                    then @
389
389
 
                    else throw(($getType(@) + " couldn't be cast to Int"))
390
390
 
                }, {
391
391
 
                let @ = repl[1]
392
392
 
                if ($isInstanceOf(@, "Int"))
393
393
 
                    then @
394
394
 
                    else throw(($getType(@) + " couldn't be cast to Int"))
395
395
 
                }, assetIdToStr(repl[2]), {
396
396
 
                let @ = repl[0]
397
397
 
                if ($isInstanceOf(@, "Int"))
398
398
 
                    then @
399
399
 
                    else throw(($getType(@) + " couldn't be cast to Int"))
400
400
 
                })
401
401
 
            else throw("Strict value is not equal to itself.")
402
402
 
        }
403
403
 
    else {
404
404
 
        let $t01157311823 = $Tuple2(split({
405
405
 
            let @ = invoke(poolAddr, "evaluatePutByAmountAssetREADONLY", [pmtA], nil)
406
406
 
            if ($isInstanceOf(@, "String"))
407
407
 
                then @
408
408
 
                else throw(($getType(@) + " couldn't be cast to String"))
409
409
 
            }, "__"), split({
410
410
 
            let @ = invoke(poolAddr, "evaluatePutByPriceAssetREADONLY", [pmtB], nil)
411
411
 
            if ($isInstanceOf(@, "String"))
412
412
 
                then @
413
413
 
                else throw(($getType(@) + " couldn't be cast to String"))
414
414
 
            }, "__"))
415
415
 
        if (($t01157311823 == $t01157311823))
416
416
 
            then {
417
417
 
                let evalPutInB = $t01157311823._2
418
418
 
                let evalPutInA = $t01157311823._1
419
419
 
                let lpInA = parseIntValue(evalPutInA[1])
420
420
 
                let lpInB = parseIntValue(evalPutInB[1])
421
421
 
                if ((lpInB > lpInA))
422
422
 
                    then {
423
423
 
                        let pmt = parseIntValue(evalPutInA[8])
424
424
 
                        $Tuple5(pmtA, pmt, (pmtB - pmt), bId, lpInB)
425
425
 
                        }
426
426
 
                    else {
427
427
 
                        let pmt = parseIntValue(evalPutInB[7])
428
428
 
                        $Tuple5(pmt, pmtB, (pmtA - pmt), aId, lpInA)
429
429
 
                        }
430
430
 
                }
431
431
 
            else throw("Strict value is not equal to itself.")
432
432
 
        }
433
433
 
434
434
 
435
435
 
func replenishTwoTokensByType (poolAddr,pType,pmtA,aId,pmtB,bId) = {
436
436
 
    let payments = [AttachedPayment(assetIdFromStr(aId), pmtA), AttachedPayment(assetIdFromStr(bId), pmtB)]
437
437
 
    if ((pType == SF_POOL))
438
438
 
        then invoke(poolAddr, "callFunction", ["replenishWithTwoTokens", ["false", "0"]], payments)
439
439
 
        else invoke(poolAddr, "put", [1000000, false], payments)
440
440
 
    }
441
441
 
442
442
 
443
443
 
func replenishOneTokenByType (poolAddr,pType,pmt,pmtId) = {
444
444
 
    let payments = [AttachedPayment(assetIdFromStr(pmtId), pmt)]
445
445
 
    if ((pType == SF_POOL))
446
446
 
        then invoke(poolAddr, "callFunction", ["replenishWithOneToken", ["0", "false", "0"]], payments)
447
447
 
        else invoke(poolAddr, "putOneTkn", [0, false], payments)
448
448
 
    }
449
449
 
450
450
 
451
451
 
func stakeLP (pool,pType,shareId,amount) = {
452
452
 
    let payments = [AttachedPayment(fromBase58String(shareId), amount)]
453
453
 
    if ((pType == SF_POOL))
454
454
 
        then invoke(getSFFarmingAddr(), "lockShareTokens", [pool, 0], payments)
455
455
 
        else invoke(getWXFarmingAddr(addressFromStringValue(pool)), "stake", nil, payments)
456
456
 
    }
457
457
 
458
458
 
459
459
 
func unstakeLP (pool,pType,shareId,amount) = {
460
460
 
    let $t01330813665 = if ((pType == SF_POOL))
461
461
 
        then $Tuple3(getSFFarmingAddr(), "withdrawShareTokens", [pool, amount])
462
462
 
        else if ((pType == WX_POOL))
463
463
 
            then $Tuple3(getWXFarmingAddr(Address(fromBase58String(pool))), "unstake", [shareId, amount])
464
464
 
            else throw("Wrong pool type")
465
465
 
    let farmAddr = $t01330813665._1
466
466
 
    let fName = $t01330813665._2
467
467
 
    let params = $t01330813665._3
468
468
 
    let inv = invoke(farmAddr, fName, params, nil)
469
469
 
    if ((inv == inv))
470
470
 
        then amount
471
471
 
        else throw("Strict value is not equal to itself.")
472
472
 
    }
473
473
 
474
474
 
475
475
 
func calcAmountToPaySF (pool,assetIdA,assetIdB,balA,balB,amountTokenToGet,assetTokenToGet) = {
476
476
 
    let poolAddr = Address(fromBase58String(pool))
477
477
 
    let feeScale6 = 1000000
478
478
 
    let fee = getIntegerValue(poolAddr, kSFPoolFee)
479
479
 
    let amntGetNoFee = fraction(amountTokenToGet, feeScale6, (feeScale6 - fee), CEILING)
480
480
 
    let $t01408714393 = if ((assetTokenToGet == assetIdA))
481
481
 
        then {
482
482
 
            let amountToPay = fraction(amntGetNoFee, balB, (balA - amntGetNoFee), CEILING)
483
483
 
            $Tuple2(amountToPay, assetIdB)
484
484
 
            }
485
485
 
        else {
486
486
 
            let amountToPay = fraction(amntGetNoFee, balA, (balB - amntGetNoFee), CEILING)
487
487
 
            $Tuple2(amountToPay, assetIdA)
488
488
 
            }
489
489
 
    let amountToPay = $t01408714393._1
490
490
 
    let assetToPay = $t01408714393._2
491
491
 
    $Tuple2(assetToPay, amountToPay)
492
492
 
    }
493
493
 
494
494
 
495
495
 
func calcAmountToPayWX (pool,assetIdA,assetIdB,balA,balB,amountTokenToGet,assetTokenToGet) = {
496
496
 
    let prFee = getIntegerValue(wxSwapContract, "%s__protocolFee")
497
497
 
    let pFee = getIntegerValue(wxSwapContract, "%s__poolFee")
498
498
 
    let feeScale = toBigInt(100000000)
499
499
 
    let $t01473215040 = if ((assetTokenToGet == assetIdA))
500
500
 
        then {
501
501
 
            let amountToPay = fraction(amountTokenToGet, balB, (balA - amountTokenToGet))
502
502
 
            $Tuple2(amountToPay, assetIdB)
503
503
 
            }
504
504
 
        else {
505
505
 
            let amountToPay = fraction(amountTokenToGet, balA, (balB - amountTokenToGet))
506
506
 
            $Tuple2(amountToPay, assetIdA)
507
507
 
            }
508
508
 
    let amountToPay = $t01473215040._1
509
509
 
    let assetToPay = $t01473215040._2
510
510
 
    let amountToPayWithFee = toInt(fraction(toBigInt(amountToPay), feeScale, (feeScale - toBigInt((prFee + pFee))), CEILING))
511
511
 
    $Tuple2(assetToPay, amountToPayWithFee)
512
512
 
    }
513
513
 
514
514
 
515
515
 
func exchangeDirectly (type,pool,assetIdA,assetIdB,balA,balB,amountTokenToGet,assetTokenToGet) = if ((type == SF_POOL))
516
516
 
    then {
517
517
 
        let $t01538515507 = calcAmountToPaySF(pool, assetIdA, assetIdB, balA, balB, amountTokenToGet, assetTokenToGet)
518
518
 
        let assetToPay = $t01538515507._1
519
519
 
        let amountToPay = $t01538515507._2
520
520
 
        invoke(addressFromStringValue(pool), "callFunction", ["exchange", [toString(amountTokenToGet)]], [AttachedPayment(assetIdFromStr(assetToPay), amountToPay)])
521
521
 
        }
522
522
 
    else {
523
523
 
        let $t01568215804 = calcAmountToPayWX(pool, assetIdA, assetIdB, balA, balB, amountTokenToGet, assetTokenToGet)
524
524
 
        let assetToPay = $t01568215804._1
525
525
 
        let amountToPay = $t01568215804._2
526
526
 
        invoke(wxSwapContract, "swap", [amountTokenToGet, assetTokenToGet, toString(this)], [AttachedPayment(assetIdFromStr(assetToPay), amountToPay)])
527
527
 
        }
528
528
 
529
529
 
530
530
 
func calcWithdrawLPFromPoolVirt (poolAddr,pType,shareId,userCanWithdraw) = {
531
531
 
    let $t01606616453 = if ((pType == SF_POOL))
532
532
 
        then {
533
533
 
            let inv = {
534
534
 
                let @ = invoke(poolAddr, "callFunction", ["withdrawREADONLY", [toString(userCanWithdraw)]], nil)
535
535
 
                if ($isInstanceOf(@, "(Int, Int)"))
536
536
 
                    then @
537
537
 
                    else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
538
538
 
                }
539
539
 
            if ((inv == inv))
540
540
 
                then $Tuple2(inv._1, inv._2)
541
541
 
                else throw("Strict value is not equal to itself.")
542
542
 
            }
543
543
 
        else {
544
544
 
            let inv = split({
545
545
 
                let @ = invoke(poolAddr, "evaluateGetREADONLY", [shareId, userCanWithdraw], nil)
546
546
 
                if ($isInstanceOf(@, "String"))
547
547
 
                    then @
548
548
 
                    else throw(($getType(@) + " couldn't be cast to String"))
549
549
 
                }, "__")
550
550
 
            if ((inv == inv))
551
551
 
                then $Tuple2(parseIntValue(inv[1]), parseIntValue(inv[2]))
552
552
 
                else throw("Strict value is not equal to itself.")
553
553
 
            }
554
554
 
    let amountA = $t01606616453._1
555
555
 
    let amountB = $t01606616453._2
556
556
 
    $Tuple2(amountA, amountB)
557
557
 
    }
558
558
 
559
559
 
560
560
 
func claimFarmed (type,pool) = if ((type == SF_POOL))
561
561
 
    then {
562
562
 
        let balBefore = accountBalance(SWOPID)
563
563
 
        if ((balBefore == balBefore))
564
564
 
            then {
565
565
 
                let inv = invoke(getSFFarmingAddr(), "claim", [pool], nil)
566
566
 
                if ((inv == inv))
567
567
 
                    then {
568
568
 
                        let balAfter = accountBalance(SWOPID)
569
569
 
                        $Tuple2((balAfter - balBefore), SWOPID)
570
570
 
                        }
571
571
 
                    else throw("Strict value is not equal to itself.")
572
572
 
                }
573
573
 
            else throw("Strict value is not equal to itself.")
574
574
 
        }
575
575
 
    else if ((type == WX_POOL))
576
576
 
        then {
577
577
 
            let balBefore = accountBalance(WXID)
578
578
 
            if ((balBefore == balBefore))
579
579
 
                then {
580
580
 
                    let inv = invoke(getWXFarmingAddr(Address(fromBase58String(pool))), "claimWX", [pool], nil)
581
581
 
                    if ((inv == inv))
582
582
 
                        then {
583
583
 
                            let balAfter = accountBalance(WXID)
584
584
 
                            $Tuple2((balAfter - balBefore), WXID)
585
585
 
                            }
586
586
 
                        else throw("Strict value is not equal to itself.")
587
587
 
                    }
588
588
 
                else throw("Strict value is not equal to itself.")
589
589
 
            }
590
590
 
        else throw("Wrong pool type")
591
591
 
592
592
 
593
593
 
func replenishByType (pType,pool,feeType,pmtA,aId,pmtB,bId,balA,balB,LPId) = {
594
594
 
    let lpBalanceBefore = accountBalance(fromBase58String(LPId))
595
595
 
    if ((lpBalanceBefore == lpBalanceBefore))
596
596
 
        then {
597
597
 
            let poolAddr = addressFromStringValue(pool)
598
598
 
            let $t01743917855 = if (if ((pmtA > 0))
599
599
 
                then (pmtB > 0)
600
600
 
                else false)
601
601
 
                then {
602
602
 
                    let $t01750517621 = calcReplenishByTwoTokens(pType, poolAddr, pmtA, aId, pmtB, bId, balA, balB)
603
603
 
                    let pmtInA = $t01750517621._1
604
604
 
                    let pmtInB = $t01750517621._2
605
605
 
                    let change = $t01750517621._3
606
606
 
                    let changeId = $t01750517621._4
607
607
 
                    let inv = replenishTwoTokensByType(poolAddr, pType, pmtInA, aId, pmtInB, bId)
608
608
 
                    if ((inv == inv))
609
609
 
                        then $Tuple2(change, changeId)
610
610
 
                        else throw("Strict value is not equal to itself.")
611
611
 
                    }
612
612
 
                else if ((pmtA > 0))
613
613
 
                    then $Tuple2(pmtA, aId)
614
614
 
                    else if ((pmtB > 0))
615
615
 
                        then $Tuple2(pmtB, bId)
616
616
 
                        else throw("pmts must be > 0")
617
617
 
            let change = $t01743917855._1
618
618
 
            let changeId = $t01743917855._2
619
619
 
            let inv = if ((change > 0))
620
620
 
                then replenishOneTokenByType(poolAddr, pType, change, changeId)
621
621
 
                else nil
622
622
 
            if ((inv == inv))
623
623
 
                then {
624
624
 
                    let lpBalanceAfter = accountBalance(fromBase58String(LPId))
625
625
 
                    let totalStaked = (lpBalanceAfter - lpBalanceBefore)
626
626
 
                    let axlyFeeAmount = fraction(totalStaked, getAxlyFee(pool, feeType), FEE_SCALE6)
627
627
 
                    let userShareForStake = (totalStaked - axlyFeeAmount)
628
628
 
                    if ((0 >= userShareForStake))
629
629
 
                        then throw("amount of staked sharetokens must be > 0")
630
630
 
                        else {
631
631
 
                            let invLP = stakeLP(pool, pType, LPId, userShareForStake)
632
632
 
                            if ((invLP == invLP))
633
633
 
                                then $Tuple2(userShareForStake, axlyFeeAmount)
634
634
 
                                else throw("Strict value is not equal to itself.")
635
635
 
                            }
636
636
 
                    }
637
637
 
                else throw("Strict value is not equal to itself.")
638
638
 
            }
639
639
 
        else throw("Strict value is not equal to itself.")
640
640
 
    }
641
641
 
642
642
 
643
643
 
func replenishEntries (pool,user,stakedAmount,axlyFeeAmount,posNum,shareId,type,withLoan) = {
644
644
 
    let totalAmount = getPoolTotalShare(pool)
645
645
 
    let totalAmountLoan = getPoolTotalShareWithLoan(pool)
646
646
 
    let $t01871318951 = if (withLoan)
647
647
 
        then $Tuple2(getIntegerValue(this, (pool + kPoolInterestLoan)), (totalAmountLoan + stakedAmount))
648
648
 
        else $Tuple2(getIntegerValue(this, (pool + kPoolInterestNoLoan)), totalAmountLoan)
649
649
 
    let curPoolInterest = $t01871318951._1
650
650
 
    let totalStakedWithLoan = $t01871318951._2
651
651
 
[IntegerEntry((pool + kPoolTotal), (totalAmount + stakedAmount)), IntegerEntry((pool + kPoolTotalLoan), totalStakedWithLoan), IntegerEntry((((((pool + "_") + user) + "_") + toString(posNum)) + kUserPosition), stakedAmount), IntegerEntry((((((pool + "_") + user) + "_") + toString(posNum)) + kUserPositionInterest), curPoolInterest), StringEntry((((user + "_") + toString(posNum)) + kUserPositionPool), pool), IntegerEntry((user + kUserPositionNum), posNum), ScriptTransfer(moneyBox, axlyFeeAmount, fromBase58String(shareId))]
652
652
 
    }
653
653
 
654
654
 
655
655
 
func exchangeKeeper (toToken,pmtAmount,pmtAsset,amountsIn,addresses,assetsToReceive,estReceived,slippageTolerance,minReceived,options) = {
656
656
 
    let tokenBalanceBefore = accountBalance(assetIdFromStr(toToken))
657
657
 
    if ((tokenBalanceBefore == tokenBalanceBefore))
658
658
 
        then {
659
659
 
            let inv = invoke(exContract, "swap", [amountsIn, addresses, assetsToReceive, estReceived, slippageTolerance, minReceived, options], [AttachedPayment(pmtAsset, pmtAmount)])
660
660
 
            if ((inv == inv))
661
661
 
                then (accountBalance(assetIdFromStr(toToken)) - tokenBalanceBefore)
662
662
 
                else throw("Strict value is not equal to itself.")
663
663
 
            }
664
664
 
        else throw("Strict value is not equal to itself.")
665
665
 
    }
666
666
 
667
667
 
668
668
 
func exchangePuzzle (toToken,pmtAmount,pmtAsset,routesStr,minToReceive,options) = {
669
669
 
    let tokenBalanceBefore = accountBalance(assetIdFromStr(toToken))
670
670
 
    if ((tokenBalanceBefore == tokenBalanceBefore))
671
671
 
        then {
672
672
 
            let inv = invoke(exContract, "puzzleSwap", [routesStr, minToReceive, options], [AttachedPayment(pmtAsset, pmtAmount)])
673
673
 
            if ((inv == inv))
674
674
 
                then (accountBalance(assetIdFromStr(toToken)) - tokenBalanceBefore)
675
675
 
                else throw("Strict value is not equal to itself.")
676
676
 
            }
677
677
 
        else throw("Strict value is not equal to itself.")
678
678
 
    }
679
679
 
680
680
 
681
681
 
func exchangeSwopFi (toToken,pmtAmount,pmtAsset,exchangers,exchangersType,args1,args2,routingAssetsKeys,minAmountToReceive,options) = {
682
682
 
    let tokenBalanceBefore = accountBalance(assetIdFromStr(toToken))
683
683
 
    if ((tokenBalanceBefore == tokenBalanceBefore))
684
684
 
        then {
685
685
 
            let inv = invoke(exContract, "swopfiSwap", [exchangers, exchangersType, args1, args2, routingAssetsKeys, minAmountToReceive, options], [AttachedPayment(pmtAsset, pmtAmount)])
686
686
 
            if ((inv == inv))
687
687
 
                then (accountBalance(assetIdFromStr(toToken)) - tokenBalanceBefore)
688
688
 
                else throw("Strict value is not equal to itself.")
689
689
 
            }
690
690
 
        else throw("Strict value is not equal to itself.")
691
691
 
    }
692
692
 
693
693
 
694
694
 
func capitalize (pool,pType,tokenId,tokenAmount) = {
695
695
 
    let poolAddr = Address(fromBase58String(pool))
696
696
 
    let $t02130221368 = getPoolData(poolAddr, pType)
697
697
 
    let AId = $t02130221368._1
698
698
 
    let BId = $t02130221368._2
699
699
 
    let balA = $t02130221368._3
700
700
 
    let balB = $t02130221368._4
701
701
 
    let shareId = $t02130221368._5
702
702
 
    if (if ((tokenId != AId))
703
703
 
        then (tokenId != BId)
704
704
 
        else false)
705
705
 
        then throw("Wrong asset")
706
706
 
        else {
707
707
 
            let $t02145321533 = if ((tokenId == AId))
708
708
 
                then $Tuple2(tokenAmount, 0)
709
709
 
                else $Tuple2(0, tokenAmount)
710
710
 
            let pmtA = $t02145321533._1
711
711
 
            let pmtB = $t02145321533._2
712
712
 
            let $t02153621640 = replenishByType(pType, pool, NO_FEE, pmtA, AId, pmtB, BId, balA, balB, shareId)
713
713
 
            let stakedAmount = $t02153621640._1
714
714
 
            let nf = $t02153621640._2
715
715
 
            let curPoolInterestLoan = valueOrElse(getInteger(this, (pool + kPoolInterestLoan)), 0)
716
716
 
            let curPoolInterestNoLoan = valueOrElse(getInteger(this, (pool + kPoolInterestNoLoan)), 0)
717
717
 
            let totalShareAmount = getPoolTotalShare(pool)
718
718
 
            let totalShareAmountWithLoan = getPoolTotalShareWithLoan(pool)
719
719
 
            let loanPercent = fraction(totalShareAmountWithLoan, SCALE8, totalShareAmount)
720
720
 
            let stakedLoan = fraction(stakedAmount, loanPercent, SCALE8)
721
721
 
            let stakedNoLoan = (stakedAmount - stakedLoan)
722
722
 
            let newInterestLoan = if ((totalShareAmountWithLoan > 0))
723
723
 
                then (curPoolInterestLoan + fraction(stakedLoan, SCALE10, totalShareAmountWithLoan))
724
724
 
                else 0
725
725
 
            let newInterestNoLoan = if (((totalShareAmount - totalShareAmountWithLoan) > 0))
726
726
 
                then (curPoolInterestNoLoan + fraction(stakedNoLoan, SCALE10, (totalShareAmount - totalShareAmountWithLoan)))
727
727
 
                else 0
728
728
 
            let axlyFeeLoan = fraction(stakedLoan, getAxlyFee(pool, CAP_FEE_LOAN), FEE_SCALE6)
729
729
 
            let axlyFeeNoLoan = fraction(stakedNoLoan, getAxlyFee(pool, CAP_FEE_NO_LOAN), FEE_SCALE6)
730
730
 
            let axlyFee = unstakeLP(pool, pType, shareId, (axlyFeeLoan + axlyFeeNoLoan))
731
731
 
            if ((axlyFee == axlyFee))
732
732
 
                then ([IntegerEntry((pool + kPoolInterestLoan), newInterestLoan), IntegerEntry((pool + kPoolInterestNoLoan), newInterestNoLoan), IntegerEntry((pool + kPoolTotal), ((totalShareAmount + stakedAmount) - axlyFee)), IntegerEntry((pool + kPoolTotalLoan), ((totalShareAmountWithLoan + stakedLoan) - axlyFeeLoan)), ScriptTransfer(moneyBox, (axlyFeeLoan + axlyFeeNoLoan), fromBase58String(shareId))] ++ getCursEntries(AId, BId, shareId, nil))
733
733
 
                else throw("Strict value is not equal to itself.")
734
734
 
            }
735
735
 
    }
736
736
 
737
737
 
738
738
 
func withdrawAmountCalc (pool,userCanWithdraw,debt,borrowAsset) = {
739
739
 
    let poolAddr = Address(fromBase58String(pool))
740
740
 
    let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Unknown pool")
741
741
 
    let $t02341223488 = getPoolData(poolAddr, pType)
742
742
 
    let assetIdA = $t02341223488._1
743
743
 
    let assetIdB = $t02341223488._2
744
744
 
    let balA = $t02341223488._3
745
745
 
    let balB = $t02341223488._4
746
746
 
    let shareId = $t02341223488._5
747
747
 
    let cBalABefore = accountBalance(assetIdFromStr(assetIdA))
748
748
 
    if ((cBalABefore == cBalABefore))
749
749
 
        then {
750
750
 
            let cBalBBefore = accountBalance(assetIdFromStr(assetIdB))
751
751
 
            if ((cBalBBefore == cBalBBefore))
752
752
 
                then {
753
753
 
                    let inv = if ((pType == SF_POOL))
754
754
 
                        then invoke(poolAddr, "callFunction", ["withdraw", [toString(userCanWithdraw)]], nil)
755
755
 
                        else {
756
756
 
                            let inv = unstakeLP(pool, pType, shareId, userCanWithdraw)
757
757
 
                            if ((inv == inv))
758
758
 
                                then invoke(poolAddr, "get", nil, [AttachedPayment(assetIdFromStr(shareId), userCanWithdraw)])
759
759
 
                                else throw("Strict value is not equal to itself.")
760
760
 
                            }
761
761
 
                    if ((inv == inv))
762
762
 
                        then {
763
763
 
                            let cBalAAfter = accountBalance(assetIdFromStr(assetIdA))
764
764
 
                            let cBalBAfter = accountBalance(assetIdFromStr(assetIdB))
765
765
 
                            let $t02405124140 = $Tuple2((cBalAAfter - cBalABefore), (cBalBAfter - cBalBBefore))
766
766
 
                            let tokensAmountA = $t02405124140._1
767
767
 
                            let tokensAmountB = $t02405124140._2
768
768
 
                            let $t02414324997 = if ((debt > 0))
769
769
 
                                then {
770
770
 
                                    let amountToGetEx = if (if ((borrowAsset == assetIdA))
771
771
 
                                        then (debt > tokensAmountA)
772
772
 
                                        else false)
773
773
 
                                        then (debt - tokensAmountA)
774
774
 
                                        else if (if ((borrowAsset == assetIdB))
775
775
 
                                            then (debt > tokensAmountB)
776
776
 
                                            else false)
777
777
 
                                            then (debt - tokensAmountB)
778
778
 
                                            else 0
779
779
 
                                    let exInv = if ((amountToGetEx > 0))
780
780
 
                                        then exchangeDirectly(pType, pool, assetIdA, assetIdB, (balA - tokensAmountA), (balB - tokensAmountB), amountToGetEx, borrowAsset)
781
781
 
                                        else nil
782
782
 
                                    if ((exInv == exInv))
783
783
 
                                        then {
784
784
 
                                            let cBalAAfterRepay = accountBalance(assetIdFromStr(assetIdA))
785
785
 
                                            let cBalBAfterRepay = accountBalance(assetIdFromStr(assetIdB))
786
786
 
                                            if ((borrowAsset == assetIdA))
787
787
 
                                                then $Tuple2(((cBalAAfterRepay - cBalABefore) - debt), (cBalBAfterRepay - cBalBBefore))
788
788
 
                                                else $Tuple2((cBalAAfterRepay - cBalABefore), ((cBalBAfterRepay - cBalBBefore) - debt))
789
789
 
                                            }
790
790
 
                                        else throw("Strict value is not equal to itself.")
791
791
 
                                    }
792
792
 
                                else $Tuple2(tokensAmountA, tokensAmountB)
793
793
 
                            let toUserA = $t02414324997._1
794
794
 
                            let toUserB = $t02414324997._2
795
795
 
                            $Tuple7(toUserA, assetIdA, toUserB, assetIdB, cBalAAfter, cBalBAfter, shareId)
796
796
 
                            }
797
797
 
                        else throw("Strict value is not equal to itself.")
798
798
 
                    }
799
799
 
                else throw("Strict value is not equal to itself.")
800
800
 
            }
801
801
 
        else throw("Strict value is not equal to itself.")
802
802
 
    }
803
803
 
804
804
 
805
805
 
func userCanWithdrawShareCalc (user,pool,posId,borrowed) = {
806
806
 
    let pAmount = valueOrErrorMessage(getInteger(this, (((((pool + "_") + user) + "_") + posId) + kUserPosition)), "Unknown position")
807
807
 
    let userInterest = getIntegerValue(this, (((((pool + "_") + user) + "_") + posId) + kUserPositionInterest))
808
808
 
    let poolInterest = if (borrowed)
809
809
 
        then getIntegerValue(this, (pool + kPoolInterestLoan))
810
810
 
        else getIntegerValue(this, (pool + kPoolInterestNoLoan))
811
811
 
    (pAmount + fraction(pAmount, (poolInterest - userInterest), SCALE10))
812
812
 
    }
813
813
 
814
814
 
815
815
 
func withdrawToUser (user,pool,posId,stopLoss) = {
816
816
 
    let pAmount = valueOrErrorMessage(getInteger(this, (((((pool + "_") + user) + "_") + posId) + kUserPosition)), "Unknown position")
817
817
 
    let borrowAmount = valueOrElse(getInteger(this, (((((pool + "_") + user) + "_") + posId) + kUserBorrowAmount)), 0)
818
818
 
    let userCanWithdraw = userCanWithdrawShareCalc(user, pool, posId, (borrowAmount > 0))
819
819
 
    let poolTotalShare = getPoolTotalShare(pool)
820
820
 
    let userAddr = Address(fromBase58String(user))
821
821
 
    let borrowAsset = valueOrElse(getString(this, (((((pool + "_") + user) + "_") + posId) + kUserBorrowAssetId)), "")
822
822
 
    let debt = if ((borrowAmount > 0))
823
823
 
        then {
824
824
 
            let @ = invoke(getLendSrvAddr(), "getAssetDebt", [false, ((user + "_") + posId), borrowAsset], nil)
825
825
 
            if ($isInstanceOf(@, "Int"))
826
826
 
                then @
827
827
 
                else throw(($getType(@) + " couldn't be cast to Int"))
828
828
 
            }
829
829
 
        else 0
830
830
 
    let $t02638526538 = withdrawAmountCalc(pool, userCanWithdraw, debt, borrowAsset)
831
831
 
    if (($t02638526538 == $t02638526538))
832
832
 
        then {
833
833
 
            let shareId = $t02638526538._7
834
834
 
            let cBalBAfter = $t02638526538._6
835
835
 
            let cBalAAfter = $t02638526538._5
836
836
 
            let assetIdB = $t02638526538._4
837
837
 
            let toUserAmountB = $t02638526538._3
838
838
 
            let assetIdA = $t02638526538._2
839
839
 
            let toUserAmountA = $t02638526538._1
840
840
 
            let closeDbtInv = if ((debt > 0))
841
841
 
                then invoke(getLendSrvAddr(), "repayFor", [((user + "_") + posId)], [AttachedPayment(assetIdFromStr(borrowAsset), debt)])
842
842
 
                else 0
843
843
 
            if ((closeDbtInv == closeDbtInv))
844
844
 
                then ([DeleteEntry((((((pool + "_") + user) + "_") + posId) + kUserPosition)), DeleteEntry((((((pool + "_") + user) + "_") + posId) + kUserPositionInterest)), IntegerEntry((pool + kPoolTotal), (poolTotalShare - userCanWithdraw)), ScriptTransfer(userAddr, toUserAmountA, assetIdFromStr(assetIdA)), ScriptTransfer(userAddr, toUserAmountB, assetIdFromStr(assetIdB))] ++ getCursEntries(assetIdA, assetIdB, shareId, nil))
845
845
 
                else throw("Strict value is not equal to itself.")
846
846
 
            }
847
847
 
        else throw("Strict value is not equal to itself.")
848
848
 
    }
849
849
 
850
850
 
851
851
 
func parseRequest (requestId) = {
852
852
 
    let request = split(valueOrErrorMessage(getString(this, (requestId + kRequestId)), ("No request with id " + requestId)), ",")
853
853
 
    let user = request[0]
854
854
 
    let pool = request[1]
855
855
 
    let pmtA = parseIntValue(request[2])
856
856
 
    let AId = request[3]
857
857
 
    let pmtB = parseIntValue(request[4])
858
858
 
    let BId = request[5]
859
859
 
    let balA = parseIntValue(request[6])
860
860
 
    let balB = parseIntValue(request[7])
861
861
 
    let shareId = request[8]
862
862
 
    let bwAsset = request[9]
863
863
 
    let bwAmount = parseIntValue(request[10])
864
864
 
    $Tuple11(user, pool, pmtA, AId, pmtB, BId, balA, balB, shareId, bwAsset, bwAmount)
865
865
 
    }
866
866
 
867
867
 
868
868
 
func calcBorrowAmount (pmtA,pmtB,aId,bId,leverage,borrowId) = {
869
869
 
    let dPriceA = getIntegerValue(priceOracleAddr, (aId + kPriceInOracle))
870
870
 
    let dPriceB = getIntegerValue(priceOracleAddr, (bId + kPriceInOracle))
871
871
 
    let decPrA = pow(10, 0, getAssetDecimals(aId), 0, 0, DOWN)
872
872
 
    let decPrB = pow(10, 0, getAssetDecimals(bId), 0, 0, DOWN)
873
873
 
    let paydInDollar = (fraction(dPriceA, pmtA, decPrA) + fraction(dPriceB, pmtB, decPrB))
874
874
 
    let $t02818228279 = if ((borrowId == aId))
875
875
 
        then $Tuple2(dPriceA, decPrA)
876
876
 
        else $Tuple2(dPriceB, decPrB)
877
877
 
    let borrowPrice = $t02818228279._1
878
878
 
    let borrowDecPr = $t02818228279._2
879
879
 
    fraction(fraction(paydInDollar, (leverage - 100), 100), borrowDecPr, borrowPrice)
880
880
 
    }
881
881
 
882
882
 
883
883
 
func parseReplenishPmts (pmts,AId,BId) = if ((size(pmts) == 2))
884
884
 
    then if ((assetIdToStr(pmts[0].assetId) != AId))
885
885
 
        then throw("Wrong payment asset A")
886
886
 
        else if ((assetIdToStr(pmts[1].assetId) != BId))
887
887
 
            then throw("Wrong payment asset B")
888
888
 
            else $Tuple4(pmts[0].amount, AId, pmts[1].amount, BId)
889
889
 
    else if ((size(pmts) == 1))
890
890
 
        then if ((assetIdToStr(pmts[0].assetId) == AId))
891
891
 
            then $Tuple4(pmts[0].amount, AId, 0, BId)
892
892
 
            else if ((assetIdToStr(pmts[0].assetId) == BId))
893
893
 
                then $Tuple4(0, AId, pmts[0].amount, BId)
894
894
 
                else throw("Wrong payment")
895
895
 
        else throw("One or two payments expected")
896
896
 
897
897
 
898
898
 
func calcPriceImpact (balA,balB,newBalA,newBalB) = {
899
899
 
    let pri = ((SCALE8 - fraction(fraction(balB, SCALE8, balA), SCALE8, fraction(newBalB, SCALE8, newBalA))) * 100)
900
900
 
    if ((0 > pri))
901
901
 
        then (pri * -1)
902
902
 
        else pri
903
903
 
    }
904
904
 
905
905
 
906
906
 
@Callable(i)
907
907
 
func getShareAssetPriceREADONLY (shareId) = {
908
908
 
    let sharePrices = getSharePrice(shareId)
909
909
 
    $Tuple2(nil, sharePrices)
910
910
 
    }
911
911
 
912
912
 
913
913
 
914
914
 
@Callable(i)
915
915
 
func getUserPositionShareAmountREADONLY (user,posNum) = {
916
916
 
    let pool = valueOrErrorMessage(getString(this, (((user + "_") + posNum) + kUserPositionPool)), "Unknown position")
917
917
 
    let borrowAmount = getIntegerValue(this, (((((pool + "_") + user) + "_") + posNum) + kUserBorrowAmount))
918
918
 
    let userCanWithdraw = userCanWithdrawShareCalc(user, pool, posNum, (borrowAmount > 0))
919
919
 
    $Tuple2(nil, userCanWithdraw)
920
920
 
    }
921
921
 
922
922
 
923
923
 
924
924
 
@Callable(i)
925
925
 
func getUserPositionInDollarsREADONLY (user,pools,posNum) = {
926
926
 
    func userPos (a,pool) =     {
927
927
 
        let $t02997830012 = a
928
928
 
        let totalPos = $t02997830012._1
929
929
 
        let posDebt = $t02997830012._2
930
930
 
        let index = $t02997830012._3
931
931
 
        let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Pool is not inited")
932
932
 
        let $t03010430194 = getPoolData(Address(fromBase58String(pool)), pType)
933
933
 
        let AId = $t03010430194._1
934
934
 
        let BId = $t03010430194._2
935
935
 
        let balA = $t03010430194._3
936
936
 
        let balB = $t03010430194._4
937
937
 
        let shareId = $t03010430194._5
938
938
 
        let borrowAmount = valueOrElse(getInteger(this, (((((pool + "_") + user) + "_") + posNum[index]) + kUserBorrowAmount)), 0)
939
939
 
        let userCanWithdraw = userCanWithdrawShareCalc(user, pool, posNum[index], (borrowAmount > 0))
940
940
 
        let sharePrices = getSharePrice(shareId)
941
941
 
        let decPrShare = pow(10, 0, getAssetDecimals(shareId), 0, 0, DOWN)
942
942
 
        let shareD = fraction(userCanWithdraw, sharePrices, decPrShare)
943
943
 
        if ((borrowAmount == 0))
944
944
 
            then $Tuple3((totalPos :+ shareD), (posDebt :+ 0), (index + 1))
945
945
 
            else {
946
946
 
                let borrowAsset = getStringValue(this, (((((pool + "_") + user) + "_") + posNum[index]) + kUserBorrowAssetId))
947
947
 
                let debt = {
948
948
 
                    let @ = invoke(getLendSrvAddr(), "getAssetDebt", [false, ((user + "_") + posNum[index]), borrowAsset], nil)
949
949
 
                    if ($isInstanceOf(@, "Int"))
950
950
 
                        then @
951
951
 
                        else throw(($getType(@) + " couldn't be cast to Int"))
952
952
 
                    }
953
953
 
                let borrowAssetPrice = getIntegerValue(priceOracleAddr, (borrowAsset + kPriceInOracle))
954
954
 
                let decPrBorrowId = pow(10, 0, getAssetDecimals(borrowAsset), 0, 0, DOWN)
955
955
 
                let debtD = fraction(debt, borrowAssetPrice, decPrBorrowId)
956
956
 
                $Tuple3((totalPos :+ shareD), (posDebt :+ debtD), (index + 1))
957
957
 
                }
958
958
 
        }
959
959
 
960
960
 
    let $t03121431269 = {
961
961
 
        let $l = pools
962
962
 
        let $s = size($l)
963
963
 
        let $acc0 = $Tuple3(nil, nil, 0)
964
964
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
965
965
 
            then $a
966
966
 
            else userPos($a, $l[$i])
967
967
 
968
968
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
969
969
 
            then $a
970
970
 
            else throw("List size exceeds 20")
971
971
 
972
972
 
        $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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
973
973
 
        }
974
974
 
    let pos = $t03121431269._1
975
975
 
    let debt = $t03121431269._2
976
976
 
    $Tuple2(nil, $Tuple2(pos, debt))
977
977
 
    }
978
978
 
979
979
 
980
980
 
981
981
 
@Callable(i)
982
982
 
func replenish (pool,leverage,borrowId) = if (if ((100 > leverage))
983
983
 
    then true
984
984
 
    else (leverage > 300))
985
985
 
    then throw("Leverage can't be <100 and >300")
986
986
 
    else if (if (!(getBooleanValue(this, (pool + kPoolCanBorrow))))
987
987
 
        then (leverage > 100)
988
988
 
        else false)
989
989
 
        then throw("You can't borrow in this pool")
990
990
 
        else {
991
991
 
            let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Pool is not inited")
992
992
 
            let $t03170931799 = getPoolData(Address(fromBase58String(pool)), pType)
993
993
 
            let AId = $t03170931799._1
994
994
 
            let BId = $t03170931799._2
995
995
 
            let balA = $t03170931799._3
996
996
 
            let balB = $t03170931799._4
997
997
 
            let shareId = $t03170931799._5
998
998
 
            let $t03180231883 = parseReplenishPmts(i.payments, AId, BId)
999
999
 
            let pmtA = $t03180231883._1
1000
1000
 
            let pmtAssetA = $t03180231883._2
1001
1001
 
            let pmtB = $t03180231883._3
1002
1002
 
            let pmtAssetB = $t03180231883._4
1003
1003
 
            let user = toString(i.caller)
1004
1004
 
            let newPosNum = getNewUserPositionNumber(user)
1005
1005
 
            if ((leverage > 100))
1006
1006
 
                then {
1007
1007
 
                    let borrowAmount = calcBorrowAmount(pmtA, pmtB, pmtAssetA, pmtAssetB, leverage, borrowId)
1008
1008
 
                    let request = makeString([user, pool, toString(pmtA), pmtAssetA, toString(pmtB), pmtAssetB, toString(balA), toString(balB), shareId, borrowId, toString(borrowAmount)], ",")
1009
1009
 
                    let newRequestId = {
1010
1010
 
                        let @ = invoke(this, "createNewRequest", [request], nil)
1011
1011
 
                        if ($isInstanceOf(@, "Int"))
1012
1012
 
                            then @
1013
1013
 
                            else throw(($getType(@) + " couldn't be cast to Int"))
1014
1014
 
                        }
1015
1015
 
                    if ((newRequestId == newRequestId))
1016
1016
 
                        then {
1017
1017
 
                            let args = [((user + "_") + toString(newPosNum)), shareId, borrowId, borrowAmount, toString(this), "replenishFromLand", toString(valueOrErrorMessage(newRequestId, "Can't create new request"))]
1018
1018
 
                            let inv = reentrantInvoke(getLendSrvAddr(), "flashPosition", args, nil)
1019
1019
 
                            if ((inv == inv))
1020
1020
 
                                then {
1021
1021
 
                                    let userStaked = getIntegerValue(this, (((((pool + "_") + user) + "_") + toString(newPosNum)) + kUserPosition))
1022
1022
 
                                    let $t03289632990 = getPoolBalances(Address(fromBase58String(pool)), pType, AId, BId)
1023
1023
 
                                    if (($t03289632990 == $t03289632990))
1024
1024
 
                                        then {
1025
1025
 
                                            let newBalB = $t03289632990._2
1026
1026
 
                                            let newBalA = $t03289632990._1
1027
1027
 
                                            let prImpact = calcPriceImpact(balA, balB, newBalA, newBalB)
1028
1028
 
                                            let $t03306033175 = calcWithdrawLPFromPoolVirt(Address(fromBase58String(pool)), pType, shareId, userStaked)
1029
1029
 
                                            let wAmountA = $t03306033175._1
1030
1030
 
                                            let wAmountB = $t03306033175._2
1031
1031
 
                                            $Tuple2(nil, [prImpact, wAmountA, wAmountB])
1032
1032
 
                                            }
1033
1033
 
                                        else throw("Strict value is not equal to itself.")
1034
1034
 
                                    }
1035
1035
 
                                else throw("Strict value is not equal to itself.")
1036
1036
 
                            }
1037
1037
 
                        else throw("Strict value is not equal to itself.")
1038
1038
 
                    }
1039
1039
 
                else {
1040
1040
 
                    let $t03322833340 = replenishByType(pType, pool, NO_LOAN_FEE, pmtA, AId, pmtB, BId, balA, balB, shareId)
1041
1041
 
                    let userStaked = $t03322833340._1
1042
1042
 
                    let axlyFee = $t03322833340._2
1043
1043
 
                    let $t03334633440 = getPoolBalances(Address(fromBase58String(pool)), pType, AId, BId)
1044
1044
 
                    if (($t03334633440 == $t03334633440))
1045
1045
 
                        then {
1046
1046
 
                            let newBalB = $t03334633440._2
1047
1047
 
                            let newBalA = $t03334633440._1
1048
1048
 
                            let prImpact = calcPriceImpact(balA, balB, newBalA, newBalB)
1049
1049
 
                            let $t03351033625 = calcWithdrawLPFromPoolVirt(Address(fromBase58String(pool)), pType, shareId, userStaked)
1050
1050
 
                            let wAmountA = $t03351033625._1
1051
1051
 
                            let wAmountB = $t03351033625._2
1052
1052
 
                            $Tuple2((replenishEntries(pool, user, userStaked, axlyFee, newPosNum, shareId, pType, false) ++ getCursEntries(AId, BId, shareId, [toString(wAmountA), toString(wAmountB)])), [prImpact, wAmountA, wAmountB])
1053
1053
 
                            }
1054
1054
 
                        else throw("Strict value is not equal to itself.")
1055
1055
 
                    }
1056
1056
 
            }
1057
1057
 
1058
1058
 
1059
1059
 
1060
1060
 
@Callable(i)
1061
1061
 
func withdraw (pool,posId) = withdrawToUser(toString(i.caller), pool, toString(posId), false)
1062
1062
 
1063
1063
 
1064
1064
 
1065
1065
 
@Callable(i)
1066
1066
 
func createUpdateStopLoss (posId,poolId,assetId,price) = {
1067
1067
 
    let tokenOraclePrice = getIntegerValue(priceOracleAddr, (assetId + kPriceInOracle))
1068
1068
 
    if (!(isDefined(getInteger(this, (((((poolId + "_") + toString(i.caller)) + "_") + toString(posId)) + kUserPosition)))))
1069
1069
 
        then throw("There are no user position")
1070
1070
 
        else if ((0 >= price))
1071
1071
 
            then throw("Price must be greater than 0")
1072
1072
 
            else if ((price > tokenOraclePrice))
1073
1073
 
                then throw("Price must be less than current token price")
1074
1074
 
                else [IntegerEntry((((((((toString(i.caller) + "_") + toString(posId)) + "_") + poolId) + "_") + assetId) + kUserStopLoss), price)]
1075
1075
 
    }
1076
1076
 
1077
1077
 
1078
1078
 
1079
1079
 
@Callable(i)
1080
1080
 
func deleteStopLoss (posId,poolId,assetId) = if (!(isDefined(getInteger(this, (((((((toString(i.caller) + "_") + toString(posId)) + "_") + poolId) + "_") + assetId) + kUserStopLoss)))))
1081
1081
 
    then throw("No entry")
1082
1082
 
    else [DeleteEntry((((((((toString(i.caller) + "_") + toString(posId)) + "_") + poolId) + "_") + assetId) + kUserStopLoss))]
1083
1083
 
1084
1084
 
1085
1085
 
1086
1086
 
@Callable(i)
1087
1087
 
func init (moneyBoxAddr,sfFarmingAddr,lendAddr,priceOracleAddr,keeperExContract,wxSwapContract,swopAssetId,wxAssetId,adminPubKey) = if (isDefined(getString(kMoneyBox)))
1088
1088
 
    then throw("Already inited")
1089
1089
 
    else [StringEntry(kMoneyBox, moneyBoxAddr), StringEntry(kSFFarmingAddr, sfFarmingAddr), StringEntry(kLendService, lendAddr), StringEntry(kPriceOracle, priceOracleAddr), StringEntry(kExContract, keeperExContract), StringEntry(kWxSwapContract, wxSwapContract), StringEntry(kSwopId, swopAssetId), StringEntry(kWxId, wxAssetId), StringEntry(kAdminCallPK, adminPubKey)]
1090
1090
 
1091
1091
 
1092
1092
 
1093
1093
 
@Callable(i)
1094
1094
 
func createNewRequest (params) = valueOrElse(isSelfCall(i), {
1095
1095
 
    let newRequestId = (valueOrElse(getInteger(this, kRequestIter), 0) + 1)
1096
1096
 
    $Tuple2([StringEntry((toString(newRequestId) + kRequestId), params), IntegerEntry(kRequestIter, newRequestId)], newRequestId)
1097
1097
 
    })
1098
1098
 
1099
1099
 
1100
1100
 
1101
1101
 
@Callable(i)
1102
1102
 
func replenishFromLand (requestId) = valueOrElse(isLandCall(i), {
1103
1103
 
    let $t03615136255 = parseRequest(requestId)
1104
1104
 
    let user = $t03615136255._1
1105
1105
 
    let pool = $t03615136255._2
1106
1106
 
    let pmtA = $t03615136255._3
1107
1107
 
    let AId = $t03615136255._4
1108
1108
 
    let pmtB = $t03615136255._5
1109
1109
 
    let BId = $t03615136255._6
1110
1110
 
    let balA = $t03615136255._7
1111
1111
 
    let balB = $t03615136255._8
1112
1112
 
    let shareId = $t03615136255._9
1113
1113
 
    let bwAsset = $t03615136255._10
1114
1114
 
    let bwAmount = $t03615136255._11
1115
1115
 
    if ((size(i.payments) != 1))
1116
1116
 
        then throw("Wrong payment size")
1117
1117
 
        else if (if ((assetIdToStr(i.payments[0].assetId) != bwAsset))
1118
1118
 
            then true
1119
1119
 
            else (i.payments[0].amount != bwAmount))
1120
1120
 
            then throw("Wrong payment")
1121
1121
 
            else {
1122
1122
 
                let $t03644536569 = if ((AId == bwAsset))
1123
1123
 
                    then $Tuple2((pmtA + i.payments[0].amount), pmtB)
1124
1124
 
                    else $Tuple2(pmtA, (pmtB + i.payments[0].amount))
1125
1125
 
                let pmtAllA = $t03644536569._1
1126
1126
 
                let pmtAllB = $t03644536569._2
1127
1127
 
                let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Unknown pool")
1128
1128
 
                let $t03665136766 = replenishByType(pType, pool, LOAN_FEE, pmtAllA, AId, pmtAllB, BId, balA, balB, shareId)
1129
1129
 
                let userStaked = $t03665136766._1
1130
1130
 
                let axlyFee = $t03665136766._2
1131
1131
 
                let posNum = getNewUserPositionNumber(user)
1132
1132
 
                let borrowEntries = [IntegerEntry((((((pool + "_") + user) + "_") + toString(posNum)) + kUserBorrowAmount), bwAmount), StringEntry((((((pool + "_") + user) + "_") + toString(posNum)) + kUserBorrowAssetId), bwAsset)]
1133
1133
 
                let entries = replenishEntries(pool, user, userStaked, axlyFee, posNum, shareId, pType, true)
1134
1134
 
                let $t03712637241 = calcWithdrawLPFromPoolVirt(Address(fromBase58String(pool)), pType, shareId, userStaked)
1135
1135
 
                let wAmountA = $t03712637241._1
1136
1136
 
                let wAmountB = $t03712637241._2
1137
1137
 
                $Tuple2((((entries ++ getCursEntries(AId, BId, shareId, [toString(wAmountA), toString(wAmountB)])) ++ borrowEntries) :+ DeleteEntry((requestId + kRequestId))), userStaked)
1138
1138
 
                }
1139
1139
 
    })
1140
1140
 
1141
1141
 
1142
1142
 
1143
1143
 
@Callable(i)
1144
1144
 
func liquidate (user,posId,liquidateAmount) = valueOrElse(isLandCall(i), {
1145
1145
 
    let pool = valueOrErrorMessage(getString(this, (((user + "_") + posId) + kUserPositionPool)), "no position")
1146
1146
 
    let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Pool is not inited")
1147
1147
 
    let $t03773637826 = getPoolData(Address(fromBase58String(pool)), pType)
1148
1148
 
    let AId = $t03773637826._1
1149
1149
 
    let BId = $t03773637826._2
1150
1150
 
    let balA = $t03773637826._3
1151
1151
 
    let balB = $t03773637826._4
1152
1152
 
    let shareId = $t03773637826._5
1153
1153
 
    let amount = unstakeLP(pool, pType, shareId, liquidateAmount)
1154
1154
 
    let borrowAmount = getIntegerValue(this, (((((pool + "_") + user) + "_") + posId) + kUserBorrowAmount))
1155
1155
 
    let borrowAsset = getStringValue(this, (((((pool + "_") + user) + "_") + posId) + kUserBorrowAssetId))
1156
1156
 
    let userCanWithdraw = userCanWithdrawShareCalc(user, pool, posId, (borrowAmount > 0))
1157
1157
 
    if ((borrowAmount == 0))
1158
1158
 
        then throw("You can't liquidate position without borrow")
1159
1159
 
        else [IntegerEntry((((((pool + "_") + user) + "_") + posId) + kUserPositionInterest), getIntegerValue(this, (pool + kPoolInterestLoan))), IntegerEntry((pool + kPoolTotalLoan), (getPoolTotalShareWithLoan(pool) - liquidateAmount)), IntegerEntry((pool + kPoolTotal), (getPoolTotalShare(pool) - liquidateAmount)), IntegerEntry((((((pool + "_") + user) + "_") + posId) + kUserPosition), (userCanWithdraw - liquidateAmount)), ScriptTransfer(i.caller, amount, fromBase58String(shareId))]
1160
1160
 
    })
1161
1161
 
1162
1162
 
1163
1163
 
1164
1164
 
@Callable(i)
1165
1165
 
func stopLoss (user,posId,pool,assetId) = valueOrElse(isAdminCall(i), {
1166
1166
 
    let tokenOraclePrice = getIntegerValue(priceOracleAddr, (assetId + kPriceInOracle))
1167
1167
 
    if (!(isDefined(getInteger(this, (((((((user + "_") + toString(posId)) + "_") + pool) + "_") + assetId) + kUserStopLoss)))))
1168
1168
 
        then throw("No entry")
1169
1169
 
        else (withdrawToUser(toString(i.caller), pool, toString(posId), true) :+ DeleteEntry((((((((user + "_") + toString(posId)) + "_") + pool) + "_") + assetId) + kUserStopLoss)))
1170
1170
 
    })
1171
1171
 
1172
1172
 
1173
1173
 
1174
1174
 
@Callable(i)
1175
1175
 
func capitalizeExKeeper (pool,tokenToId,amountToExchange,claim,amountsIn,addresses,assetsToReceive,estReceived,slippageTolerance,minReceived,options) = valueOrElse(isAdminCall(i), {
1176
1176
 
    let type = getStringValue(this, (kPool + pool))
1177
1177
 
    let $t03961939813 = if (claim)
1178
1178
 
        then claimFarmed(type, pool)
1179
1179
 
        else {
1180
1180
 
            let claimedAsset = if ((type == SF_POOL))
1181
1181
 
                then SWOPID
1182
1182
 
                else WXID
1183
1183
 
            $Tuple2(amountToExchange, claimedAsset)
1184
1184
 
            }
1185
1185
 
    let claimedAmount = $t03961939813._1
1186
1186
 
    let claimedAsset = $t03961939813._2
1187
1187
 
    let exchangedAmount = exchangeKeeper(tokenToId, amountToExchange, claimedAsset, amountsIn, addresses, assetsToReceive, estReceived, slippageTolerance, minReceived, options)
1188
1188
 
    let change = (claimedAmount - amountToExchange)
1189
1189
 
    let changeEntry = if ((change > 0))
1190
1190
 
        then [IntegerEntry((pool + kPoolCapChange), (change + valueOrElse(getInteger(this, (pool + kPoolCapChange)), 0)))]
1191
1191
 
        else nil
1192
1192
 
    (capitalize(pool, type, tokenToId, exchangedAmount) ++ changeEntry)
1193
1193
 
    })
1194
1194
 
1195
1195
 
1196
1196
 
1197
1197
 
@Callable(i)
1198
1198
 
func capitalizeExPuzzle (pool,tokenToId,amountToExchange,claim,routesStr,minToReceive,options) = valueOrElse(isAdminCall(i), {
1199
1199
 
    let type = getStringValue(this, (kPool + pool))
1200
1200
 
    let $t04052840722 = if (claim)
1201
1201
 
        then claimFarmed(type, pool)
1202
1202
 
        else {
1203
1203
 
            let claimedAsset = if ((type == SF_POOL))
1204
1204
 
                then SWOPID
1205
1205
 
                else WXID
1206
1206
 
            $Tuple2(amountToExchange, claimedAsset)
1207
1207
 
            }
1208
1208
 
    let claimedAmount = $t04052840722._1
1209
1209
 
    let claimedAsset = $t04052840722._2
1210
1210
 
    let exchangedAmount = exchangePuzzle(tokenToId, amountToExchange, claimedAsset, routesStr, minToReceive, options)
1211
1211
 
    let change = (claimedAmount - amountToExchange)
1212
1212
 
    let changeEntry = if ((change > 0))
1213
1213
 
        then [IntegerEntry((pool + kPoolCapChange), (change + valueOrElse(getInteger(this, (pool + kPoolCapChange)), 0)))]
1214
1214
 
        else nil
1215
1215
 
    (capitalize(pool, type, tokenToId, exchangedAmount) ++ changeEntry)
1216
1216
 
    })
1217
1217
 
1218
1218
 
1219
1219
 
1220
1220
 
@Callable(i)
1221
1221
 
func capitalizeExSwopFi (pool,tokenToId,amountToExchange,claim,exchangers,exchangersType,args1,args2,routingAssetsKeys,minAmountToReceive,options) = valueOrElse(isAdminCall(i), {
1222
1222
 
    let type = getStringValue(this, (kPool + pool))
1223
1223
 
    let $t04150441698 = if (claim)
1224
1224
 
        then claimFarmed(type, pool)
1225
1225
 
        else {
1226
1226
 
            let claimedAsset = if ((type == SF_POOL))
1227
1227
 
                then SWOPID
1228
1228
 
                else WXID
1229
1229
 
            $Tuple2(amountToExchange, claimedAsset)
1230
1230
 
            }
1231
1231
 
    let claimedAmount = $t04150441698._1
1232
1232
 
    let claimedAsset = $t04150441698._2
1233
1233
 
    let exchangedAmount = exchangeSwopFi(tokenToId, amountToExchange, claimedAsset, exchangers, exchangersType, args1, args2, routingAssetsKeys, minAmountToReceive, options)
1234
1234
 
    let change = (claimedAmount - amountToExchange)
1235
1235
 
    let changeEntry = if ((change > 0))
1236
1236
 
        then [IntegerEntry((pool + kPoolCapChange), (change + valueOrElse(getInteger(this, (pool + kPoolCapChange)), 0)))]
1237
1237
 
        else nil
1238
1238
 
    (capitalize(pool, type, tokenToId, exchangedAmount) ++ changeEntry)
1239
1239
 
    })
1240
1240
 
1241
1241
 
1242
1242
 
1243
1243
 
@Callable(i)
1244
1244
 
func initNewPool (type,poolAddr,inFeeNoLoan,inFeeLoan,capFeeNoLoan,capFeeWithLoan,stoplossFeeNoLoan,stoplossFeeWithLoan,canBorrow) = valueOrElse(isAdminCall(i), if (if ((type != SF_POOL))
1245
1245
 
    then (type != WX_POOL)
1246
1246
 
    else false)
1247
1247
 
    then throw("Wrong type")
1248
1248
 
    else {
1249
1249
 
        let $t04243942533 = getPoolData(Address(fromBase58String(poolAddr)), type)
1250
1250
 
        let aId = $t04243942533._1
1251
1251
 
        let bId = $t04243942533._2
1252
1252
 
        let aBal = $t04243942533._3
1253
1253
 
        let bBal = $t04243942533._4
1254
1254
 
        let shareId = $t04243942533._5
1255
1255
 
[IntegerEntry((poolAddr + kAxlyInFeeWithoutLoan), inFeeNoLoan), IntegerEntry((poolAddr + kAxlyInFeeWithLoan), inFeeLoan), IntegerEntry((poolAddr + kAxlyNoLoanCapFee), capFeeNoLoan), IntegerEntry((poolAddr + kAxlyWithLoanCapFee), capFeeWithLoan), IntegerEntry((poolAddr + kAxlyStopLossNoLoanFee), stoplossFeeNoLoan), IntegerEntry((poolAddr + kAxlyStopLossLoanFee), stoplossFeeWithLoan), IntegerEntry((poolAddr + kPoolInterestLoan), 0), IntegerEntry((poolAddr + kPoolInterestNoLoan), 0), StringEntry((kPool + poolAddr), type), StringEntry((shareId + kSharePool), poolAddr), BooleanEntry((poolAddr + kPoolCanBorrow), canBorrow)]
1256
1256
 
        })
1257
1257
 
1258
1258
 
1259
1259
 
@Verifier(tx)
1260
1260
 
func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
1261
1261
 

github/deemru/w8io/026f985 
100.53 ms ◑