tx · BMmP5eWBec5g5G1b1Ddgwi98uGC3DENY9qSEJEFRXh8A

3MtZqXLLUERys947kWj86UzYW3t6HP2oWNZ:  -0.03400000 Waves

2022.06.16 11:41 [2098703] smart account 3MtZqXLLUERys947kWj86UzYW3t6HP2oWNZ > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BMmP5eWBec5g5G1b1Ddgwi98uGC3DENY9qSEJEFRXh8A",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1655368870174,
    "version": 2,
    "chainId": 84,
    "sender": "3MtZqXLLUERys947kWj86UzYW3t6HP2oWNZ",
    "senderPublicKey": "9dYFJoCiEobPUUCRKePf8JQ3LDNgqDrVaHjuCvj26mYV",
    "proofs": [
        "5LCMWuHDq6iA8xgv2aT88wq7TRAfe8jwBzAP1SxgKMzHuRsfT4rpWV4uLtdkqXZfJPfAn2mtf9q6eqiziMvYbqJH"
    ],
    "script": "base64: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",
    "height": 2098703,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let k_ora_key = "k_ora_key"
5+
6+let k_ora = "k_ora"
7+
8+let k_balance = "k_balance"
9+
10+let k_positionSize = "k_positionSize"
11+
12+let k_positionMargin = "k_positionMargin"
13+
14+let k_pon = "k_positionOpenNotional"
15+
16+let k_positionLstUpdCPF = "k_positionFraction"
17+
18+let k_initialized = "k_initialized"
19+
20+let k_fee = "k_fee"
21+
22+let k_fundingPeriod = "k_fundingPeriod"
23+
24+let k_initMarginRatio = "k_initMarginRatio"
25+
26+let k_mmr = "k_mmr"
27+
28+let k_liquidationFeeRatio = "k_liquidationFeeRatio"
29+
30+let k_latestCPF = "k_latestPremiumFraction"
31+
32+let k_nextFundingBlock = "k_nextFundingBlockMinTimestamp"
33+
34+let k_fundingRate = "k_fundingRate"
35+
36+let k_qtAstR = "k_qtAstR"
37+
38+let k_bsAstR = "k_bsAstR"
39+
40+let k_baseAsstFndDelt = "k_baseAssetDelta"
41+
42+let k_totalPositionSize = "k_totalPositionSize"
43+
44+let k_cumulativeNotional = "k_cumulativeNotional"
45+
46+let k_openInteresetNotional = "k_openInteresetNotional"
47+
48+let k_coordinatorAddress = "k_coordinatorAddress"
49+
50+let k_insurance_address = "k_insurance_address"
51+
52+let k_admin_address = "k_admin_address"
53+
54+let k_admin_public_key = "k_admin_public_key"
55+
56+let k_quote_asset = "k_quote_asset"
57+
58+let k_quote_staking = "k_quote_staking"
59+
60+let k_staking_address = "k_staking_address"
61+
62+func coordinator () = valueOrErrorMessage(addressFromString(getStringValue(this, k_coordinatorAddress)), "Coordinator not set")
63+
64+
65+func adminAddress () = addressFromString(getStringValue(coordinator(), k_admin_address))
66+
67+
68+func adminPublicKey () = fromBase58String(getStringValue(coordinator(), k_admin_public_key))
69+
70+
71+func quoteAsset () = fromBase58String(getStringValue(coordinator(), k_quote_asset))
72+
73+
74+func quoteAssetStaking () = valueOrErrorMessage(addressFromString(getStringValue(coordinator(), k_quote_staking)), "Quote assete staking not set")
75+
76+
77+func stakingAddress () = valueOrErrorMessage(addressFromString(getStringValue(coordinator(), k_staking_address)), "Insurance not set")
78+
79+
80+func insuranceAddress () = valueOrErrorMessage(addressFromString(getStringValue(coordinator(), k_insurance_address)), "Insurance not set")
81+
82+
83+let DIR_LONG = 1
84+
85+let DIR_SHORT = 2
86+
87+let FUNDING_BLOCK_INTERVAL = 60
88+
89+let SECONDS = 1000
90+
91+let DECIMAL_UNIT = (1 * (((((10 * 10) * 10) * 10) * 10) * 10))
92+
93+let ONE_DAY = (86400 * DECIMAL_UNIT)
94+
95+let ALL_FEES = 100
96+
97+func s (_x) = (toString(_x) + ",")
98+
99+
100+func divd (_x,_y) = fraction(_x, DECIMAL_UNIT, _y, HALFEVEN)
101+
102+
103+func muld (_x,_y) = fraction(_x, _y, DECIMAL_UNIT, HALFEVEN)
104+
105+
106+func abs (_x) = if ((_x > 0))
107+    then _x
108+    else -(_x)
109+
110+
111+func toCompositeKey (_key,_address) = ((_key + "_") + _address)
112+
113+
114+func requireMoreMarginRatio (_marginRatio,_baseMarginRatio,_largerThanOrEqualTo) = {
115+    let remainingMarginRatio = (_marginRatio - _baseMarginRatio)
116+    if (if (_largerThanOrEqualTo)
117+        then (0 > remainingMarginRatio)
118+        else false)
119+        then throw("Invalid margin")
120+        else if (if (!(_largerThanOrEqualTo))
121+            then (remainingMarginRatio >= 0)
122+            else false)
123+            then throw("Invalid margin")
124+            else true
125+    }
126+
127+
128+func int (k) = valueOrErrorMessage(getInteger(this, k), ("no value for " + k))
129+
130+
131+func cbalance () = int(k_balance)
132+
133+
134+func fee () = int(k_fee)
135+
136+
137+func initMarginRatio () = int(k_initMarginRatio)
138+
139+
140+func qtAstR () = int(k_qtAstR)
141+
142+
143+func bsAstR () = int(k_bsAstR)
144+
145+
146+func baseAsstFndDelt () = int(k_baseAsstFndDelt)
147+
148+
149+func totalPositionSize () = int(k_totalPositionSize)
150+
151+
152+func cumulativeNotional () = int(k_cumulativeNotional)
153+
154+
155+func latestCPF () = int(k_latestCPF)
156+
157+
158+func openInteresetNotional () = int(k_openInteresetNotional)
159+
160+
161+func nextFundingBlockTimestamp () = int(k_nextFundingBlock)
162+
163+
164+func fundingPeriodRaw () = int(k_fundingPeriod)
165+
166+
167+func fundingPeriodDecimal () = (fundingPeriodRaw() * DECIMAL_UNIT)
168+
169+
170+func fundingPeriodSeconds () = (fundingPeriodRaw() * SECONDS)
171+
172+
173+func mmr () = int(k_mmr)
174+
175+
176+func liquidationFeeRatio () = int(k_liquidationFeeRatio)
177+
178+
179+func getPosition (invesor) = {
180+    let positionSizeOpt = getInteger(this, toCompositeKey(k_positionSize, invesor))
181+    match positionSizeOpt {
182+        case positionSize: Int => 
183+            $Tuple4(positionSize, getIntegerValue(this, toCompositeKey(k_positionMargin, invesor)), getIntegerValue(this, toCompositeKey(k_pon, invesor)), getIntegerValue(this, toCompositeKey(k_positionLstUpdCPF, invesor)))
184+        case _ => 
185+            $Tuple4(0, 0, 0, 0)
186+    }
187+    }
188+
189+
190+func requireOpenPosition (_trader) = if ((getPosition(_trader)._1 == 0))
191+    then throw("No open position")
192+    else true
193+
194+
195+func initialized () = valueOrElse(getBoolean(this, k_initialized), false)
196+
197+
198+func updateReserve (_isAdd,_quoteAssetAmount,_baseAssetAmount) = if (_isAdd)
199+    then {
200+        let newBase = (bsAstR() - _baseAssetAmount)
201+        if ((0 >= newBase))
202+            then throw("Tx lead to base asset reserver <= 0, revert")
203+            else $Tuple5((qtAstR() + _quoteAssetAmount), newBase, (baseAsstFndDelt() - _baseAssetAmount), (totalPositionSize() + _baseAssetAmount), (cumulativeNotional() + _quoteAssetAmount))
204+        }
205+    else {
206+        let newQuote = (qtAstR() - _quoteAssetAmount)
207+        if ((0 >= newQuote))
208+            then throw("Tx lead to base quote reserver <= 0, revert")
209+            else $Tuple5(newQuote, (bsAstR() + _baseAssetAmount), (baseAsstFndDelt() + _baseAssetAmount), (totalPositionSize() - _baseAssetAmount), (cumulativeNotional() - _quoteAssetAmount))
210+        }
211+
212+
213+func swapInput (_isAdd,_quoteAssetAmoun) = {
214+    let _qtAstR = qtAstR()
215+    let _bsAstR = bsAstR()
216+    let k = muld(_qtAstR, _bsAstR)
217+    let qtAstRAfter = if (_isAdd)
218+        then (_qtAstR + _quoteAssetAmoun)
219+        else (_qtAstR - _quoteAssetAmoun)
220+    let bsAstRAfter = divd(k, qtAstRAfter)
221+    let amountBaseAssetBoughtAbs = abs((bsAstRAfter - _bsAstR))
222+    let amountBaseAssetBought = if (_isAdd)
223+        then amountBaseAssetBoughtAbs
224+        else -(amountBaseAssetBoughtAbs)
225+    let $t081718369 = updateReserve(_isAdd, _quoteAssetAmoun, amountBaseAssetBoughtAbs)
226+    let qtAstRAfter1 = $t081718369._1
227+    let bsAstRAfter1 = $t081718369._2
228+    let baseAsstFndDeltAfter1 = $t081718369._3
229+    let totalPositionSizeAfter1 = $t081718369._4
230+    let cumulativeNotionalAfter1 = $t081718369._5
231+    $Tuple6(amountBaseAssetBought, qtAstRAfter1, bsAstRAfter1, baseAsstFndDeltAfter1, totalPositionSizeAfter1, cumulativeNotionalAfter1)
232+    }
233+
234+
235+func calcRemainMarginWithFundingPayment (_oldPositionSize,_oldPositionMargin,_oldPositionLstUpdCPF,_marginDelta) = {
236+    let _latestCPF = latestCPF()
237+    let fundingPayment = if ((_oldPositionSize != 0))
238+        then muld((_latestCPF - _oldPositionLstUpdCPF), _oldPositionSize)
239+        else 0
240+    let signedMargin = ((_marginDelta - fundingPayment) + _oldPositionMargin)
241+    let $t089439070 = if ((0 > signedMargin))
242+        then $Tuple2(0, abs(signedMargin))
243+        else $Tuple2(abs(signedMargin), 0)
244+    let remainMargin = $t089439070._1
245+    let badDebt = $t089439070._2
246+    $Tuple4(remainMargin, badDebt, fundingPayment, _latestCPF)
247+    }
248+
249+
250+func getOutputPriceWithReserves (_add,_baseAssetAmount,_quoteAssetPoolAmount,_baseAssetPoolAmount) = if ((_baseAssetAmount == 0))
251+    then throw("Invalid base asset amount")
252+    else {
253+        let k = muld(_quoteAssetPoolAmount, _baseAssetPoolAmount)
254+        let baseAssetPoolAmountAfter = if (_add)
255+            then (_baseAssetPoolAmount + _baseAssetAmount)
256+            else (_baseAssetPoolAmount - _baseAssetAmount)
257+        let quoteAssetAfter = divd(k, baseAssetPoolAmountAfter)
258+        let quoteAssetSold = abs((quoteAssetAfter - _quoteAssetPoolAmount))
259+        let $t097199918 = updateReserve(!(_add), quoteAssetSold, _baseAssetAmount)
260+        let qtAstRAfter1 = $t097199918._1
261+        let bsAstRAfter1 = $t097199918._2
262+        let baseAsstFndDeltAfter1 = $t097199918._3
263+        let totalPositionSizeAfter1 = $t097199918._4
264+        let cumulativeNotionalAfter1 = $t097199918._5
265+        $Tuple6(quoteAssetSold, qtAstRAfter1, bsAstRAfter1, baseAsstFndDeltAfter1, totalPositionSizeAfter1, cumulativeNotionalAfter1)
266+        }
267+
268+
269+func getPositionNotionalAndUnrealizedPnl (_trader) = {
270+    let $t01015610267 = getPosition(_trader)
271+    let positionSize = $t01015610267._1
272+    let positionMargin = $t01015610267._2
273+    let pon = $t01015610267._3
274+    let positionLstUpdCPF = $t01015610267._4
275+    let positionSizeAbs = abs(positionSize)
276+    if ((positionSizeAbs == 0))
277+        then throw("Invalid position size")
278+        else {
279+            let isShort = (0 > positionSize)
280+            let $t01044410594 = getOutputPriceWithReserves(!(isShort), positionSizeAbs, qtAstR(), bsAstR())
281+            let positionNotional = $t01044410594._1
282+            let x1 = $t01044410594._2
283+            let x2 = $t01044410594._3
284+            let x3 = $t01044410594._4
285+            let unrealizedPnl = if (isShort)
286+                then (pon - positionNotional)
287+                else (positionNotional - pon)
288+            $Tuple2(positionNotional, unrealizedPnl)
289+            }
290+    }
291+
292+
293+func getOracleTwapPrice () = {
294+    let oracle = valueOrErrorMessage(addressFromString(getStringValue(this, k_ora)), "")
295+    let priceKey = getStringValue(this, k_ora_key)
296+    getIntegerValue(oracle, priceKey)
297+    }
298+
299+
300+func getTwapSpotPrice () = divd(qtAstR(), bsAstR())
301+
302+
303+func getMarginRatio (_trader) = {
304+    let $t01110411215 = getPosition(_trader)
305+    let positionSize = $t01110411215._1
306+    let positionMargin = $t01110411215._2
307+    let pon = $t01110411215._3
308+    let positionLstUpdCPF = $t01110411215._4
309+    let $t01122111305 = getPositionNotionalAndUnrealizedPnl(_trader)
310+    let positionNotional = $t01122111305._1
311+    let unrealizedPnl = $t01122111305._2
312+    let $t01131011476 = calcRemainMarginWithFundingPayment(positionSize, positionMargin, positionLstUpdCPF, unrealizedPnl)
313+    let remainMargin = $t01131011476._1
314+    let badDebt = $t01131011476._2
315+    divd((remainMargin - badDebt), positionNotional)
316+    }
317+
318+
319+func internalClosePosition (_trader) = {
320+    let $t01158311694 = getPosition(_trader)
321+    let positionSize = $t01158311694._1
322+    let positionMargin = $t01158311694._2
323+    let pon = $t01158311694._3
324+    let positionLstUpdCPF = $t01158311694._4
325+    let $t01170011770 = getPositionNotionalAndUnrealizedPnl(_trader)
326+    let x1 = $t01170011770._1
327+    let unrealizedPnl = $t01170011770._2
328+    let $t01177511947 = calcRemainMarginWithFundingPayment(positionSize, positionMargin, positionLstUpdCPF, unrealizedPnl)
329+    let remainMargin = $t01177511947._1
330+    let badDebt = $t01177511947._2
331+    let x2 = $t01177511947._3
332+    let exchangedPositionSize = -(positionSize)
333+    let realizedPnl = unrealizedPnl
334+    let marginToVault = -(remainMargin)
335+    let $t01207412381 = getOutputPriceWithReserves((positionSize > 0), abs(positionSize), qtAstR(), bsAstR())
336+    let exchangedQuoteAssetAmount = $t01207412381._1
337+    let quoteAssetReserveAfter = $t01207412381._2
338+    let bsAstRAfter = $t01207412381._3
339+    let baseAsstFndDeltAfter = $t01207412381._4
340+    let totalPositionSizeAfter = $t01207412381._5
341+    let cumulativeNotionalAfter = $t01207412381._6
342+    let openInteresetNotionalAfter = (openInteresetNotional() - pon)
343+    $Tuple11(exchangedPositionSize, badDebt, realizedPnl, marginToVault, quoteAssetReserveAfter, bsAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter, exchangedQuoteAssetAmount)
344+    }
345+
346+
347+func updateSettings (_initMarginRatio,_mmr,_liquidationFeeRatio,_fundingPeriod,_fee) = [IntegerEntry(k_initMarginRatio, _initMarginRatio), IntegerEntry(k_mmr, _mmr), IntegerEntry(k_liquidationFeeRatio, _liquidationFeeRatio), IntegerEntry(k_fundingPeriod, _fundingPeriod), IntegerEntry(k_fee, _fee)]
348+
349+
350+func updateFunding (_baseADTFP,_nextFundingBlock,_latestCPF,_fundingRate) = [IntegerEntry(k_baseAsstFndDelt, _baseADTFP), IntegerEntry(k_nextFundingBlock, _nextFundingBlock), IntegerEntry(k_latestCPF, _latestCPF), IntegerEntry(k_fundingRate, _fundingRate)]
351+
352+
353+func updatePosition (_address,_size,_margin,_openNotinal,_LstUpdCPF) = [IntegerEntry(toCompositeKey(k_positionSize, _address), _size), IntegerEntry(toCompositeKey(k_positionMargin, _address), _margin), IntegerEntry(toCompositeKey(k_pon, _address), _openNotinal), IntegerEntry(toCompositeKey(k_positionLstUpdCPF, _address), _LstUpdCPF)]
354+
355+
356+func updateAmm (_qtAstR,_bsAstR,_baseAsstFndDeltAfter,_totalPositionSizeAfter,_cumulativeNotionalAfter,_openInteresetNotional) = [IntegerEntry(k_qtAstR, _qtAstR), IntegerEntry(k_bsAstR, _bsAstR), IntegerEntry(k_baseAsstFndDelt, _baseAsstFndDeltAfter), IntegerEntry(k_totalPositionSize, _totalPositionSizeAfter), IntegerEntry(k_cumulativeNotional, _cumulativeNotionalAfter), IntegerEntry(k_openInteresetNotional, _openInteresetNotional)]
357+
358+
359+func deletePosition (_address) = [DeleteEntry(toCompositeKey(k_positionSize, _address)), DeleteEntry(toCompositeKey(k_positionMargin, _address)), DeleteEntry(toCompositeKey(k_pon, _address)), DeleteEntry(toCompositeKey(k_positionLstUpdCPF, _address))]
360+
361+
362+func withdraw (_address,_amount) = {
363+    let balance = assetBalance(this, quoteAsset())
364+    if ((_amount > balance))
365+        then throw(((("Unable to withdraw " + toString(_amount)) + " from contract balance ") + toString(balance)))
366+        else [ScriptTransfer(_address, _amount, quoteAsset())]
367+    }
368+
369+
370+func upblc (i) = if ((0 > i))
371+    then throw("Balance")
372+    else [IntegerEntry(k_balance, i)]
373+
374+
375+func transferFee (i) = [ScriptTransfer(stakingAddress(), i, quoteAsset())]
376+
377+
378+@Callable(i)
379+func initialize (_qtAstR,_bsAstR,_fundingPeriod,_initMarginRatio,_mmr,_liquidationFeeRatio,_fee,_oracle,_oracleKey,_coordinator) = if (if (if (if (if (if (if ((0 >= _qtAstR))
380+    then true
381+    else (0 >= _bsAstR))
382+    then true
383+    else (0 >= _fundingPeriod))
384+    then true
385+    else (0 >= _initMarginRatio))
386+    then true
387+    else (0 >= _mmr))
388+    then true
389+    else (0 >= _liquidationFeeRatio))
390+    then true
391+    else initialized())
392+    then throw("Invalid initialize parameters")
393+    else ((((updateAmm(_qtAstR, _bsAstR, 0, 0, 0, 0) ++ updateSettings(_initMarginRatio, _mmr, _liquidationFeeRatio, _fundingPeriod, _fee)) ++ updateFunding(0, (lastBlock.timestamp + _fundingPeriod), 0, 0)) ++ upblc(0)) ++ [BooleanEntry(k_initialized, true), StringEntry(k_ora, _oracle), StringEntry(k_ora_key, _oracleKey), StringEntry(k_coordinatorAddress, _coordinator)])
394+
395+
396+
397+@Callable(i)
398+func decreasePosition (_direction,_amount,_leverage,_minBaseAssetAmount) = if (if (if (if (if (if ((_direction != DIR_LONG))
399+    then (_direction != DIR_SHORT)
400+    else false)
401+    then true
402+    else (0 >= _amount))
403+    then true
404+    else if (((1 * DECIMAL_UNIT) > _leverage))
405+        then true
406+        else (_leverage > (3 * DECIMAL_UNIT)))
407+    then true
408+    else !(initialized()))
409+    then true
410+    else !(requireMoreMarginRatio(divd(DECIMAL_UNIT, _leverage), initMarginRatio(), true)))
411+    then throw("Invalid decreasePosition parameters")
412+    else {
413+        let $t01685917011 = getPosition(toString(i.caller))
414+        let oldPositionSize = $t01685917011._1
415+        let oldPositionMargin = $t01685917011._2
416+        let oldPositionOpenNotional = $t01685917011._3
417+        let oldPositionLstUpdCPF = $t01685917011._4
418+        let isNewPosition = (oldPositionSize == 0)
419+        let isSameDirection = if ((oldPositionSize > 0))
420+            then (_direction == DIR_LONG)
421+            else (_direction == DIR_SHORT)
422+        let expandExisting = if (!(isNewPosition))
423+            then isSameDirection
424+            else false
425+        let isAdd = (_direction == DIR_LONG)
426+        let $t01730020033 = if (if (isNewPosition)
427+            then true
428+            else expandExisting)
429+            then throw("Use increasePosition to open new or increase position")
430+            else {
431+                let openNotional = muld(_amount, _leverage)
432+                let $t01776817867 = getPositionNotionalAndUnrealizedPnl(toString(i.caller))
433+                let oldPositionNotional = $t01776817867._1
434+                let unrealizedPnl = $t01776817867._2
435+                if ((oldPositionNotional > openNotional))
436+                    then {
437+                        let $t01792918172 = swapInput(isAdd, openNotional)
438+                        let exchangedPositionSize = $t01792918172._1
439+                        let qtAstRAfter = $t01792918172._2
440+                        let bsAstRAfter = $t01792918172._3
441+                        let baseAsstFndDeltAfter = $t01792918172._4
442+                        let totalPositionSizeAfter = $t01792918172._5
443+                        let cumulativeNotionalAfter = $t01792918172._6
444+                        let exchangedPositionSizeAbs = abs(exchangedPositionSize)
445+                        if (if ((_minBaseAssetAmount != 0))
446+                            then (_minBaseAssetAmount > exchangedPositionSizeAbs)
447+                            else false)
448+                            then throw(((("Too little basse asset exchanged, got " + toString(exchangedPositionSizeAbs)) + " expected ") + toString(_minBaseAssetAmount)))
449+                            else {
450+                                let realizedPnl = if ((oldPositionSize != 0))
451+                                    then divd(muld(unrealizedPnl, exchangedPositionSizeAbs), oldPositionSize)
452+                                    else 0
453+                                let $t01871318984 = calcRemainMarginWithFundingPayment(oldPositionSize, oldPositionMargin, oldPositionLstUpdCPF, realizedPnl)
454+                                let remainMargin = $t01871318984._1
455+                                let badDebt = $t01871318984._2
456+                                let fundingPayment = $t01871318984._3
457+                                let oldLatestCPF = $t01871318984._4
458+                                let exchangedQuoteAssetAmount = openNotional
459+                                let unrealizedPnlAfter = (unrealizedPnl - realizedPnl)
460+                                let remainOpenNotional = if ((oldPositionSize > 0))
461+                                    then ((oldPositionNotional - exchangedQuoteAssetAmount) - unrealizedPnlAfter)
462+                                    else ((unrealizedPnlAfter + oldPositionNotional) - exchangedQuoteAssetAmount)
463+                                $Tuple10((oldPositionSize + exchangedPositionSize), remainMargin, abs(remainOpenNotional), oldLatestCPF, bsAstRAfter, qtAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, (openInteresetNotional() - openNotional))
464+                                }
465+                        }
466+                    else throw("Close position first")
467+                }
468+        let newPositionSize = $t01730020033._1
469+        let newPositionRemainMargin = $t01730020033._2
470+        let newPosiionOpenNotional = $t01730020033._3
471+        let newPositionLatestCPF = $t01730020033._4
472+        let bsAstRAfter = $t01730020033._5
473+        let qtAstRAfter = $t01730020033._6
474+        let baseAsstFndDeltAfter = $t01730020033._7
475+        let totalPositionSizeAfter = $t01730020033._8
476+        let cumulativeNotionalAfter = $t01730020033._9
477+        let openInteresetNotionalAfter = $t01730020033._10
478+        (updatePosition(toString(i.caller), newPositionSize, newPositionRemainMargin, newPosiionOpenNotional, newPositionLatestCPF) ++ updateAmm(qtAstRAfter, bsAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter))
479+        }
480+
481+
482+
483+@Callable(i)
484+func increasePosition (_direction,_leverage,_minBaseAssetAmount) = {
485+    let _rawAmount = i.payments[0].amount
486+    if (if (if (if (if (if (if ((_direction != DIR_LONG))
487+        then (_direction != DIR_SHORT)
488+        else false)
489+        then true
490+        else (0 >= _rawAmount))
491+        then true
492+        else if (((1 * DECIMAL_UNIT) > _leverage))
493+            then true
494+            else (_leverage > (3 * DECIMAL_UNIT)))
495+        then true
496+        else !(initialized()))
497+        then true
498+        else (i.payments[0].assetId != quoteAsset()))
499+        then true
500+        else !(requireMoreMarginRatio(divd(DECIMAL_UNIT, _leverage), initMarginRatio(), true)))
501+        then throw("Invalid increasePosition parameters")
502+        else {
503+            let feeAmount = muld(_rawAmount, fee())
504+            let _amount = (_rawAmount - feeAmount)
505+            let $t02101521167 = getPosition(toString(i.caller))
506+            let oldPositionSize = $t02101521167._1
507+            let oldPositionMargin = $t02101521167._2
508+            let oldPositionOpenNotional = $t02101521167._3
509+            let oldPositionLstUpdCPF = $t02101521167._4
510+            let isNewPosition = (oldPositionSize == 0)
511+            let isSameDirection = if ((oldPositionSize > 0))
512+                then (_direction == DIR_LONG)
513+                else (_direction == DIR_SHORT)
514+            let expandExisting = if (!(isNewPosition))
515+                then isSameDirection
516+                else false
517+            let isAdd = (_direction == DIR_LONG)
518+            let $t02145623580 = if (if (isNewPosition)
519+                then true
520+                else expandExisting)
521+                then {
522+                    let openNotional = muld(_amount, _leverage)
523+                    let $t02184222057 = swapInput(isAdd, openNotional)
524+                    let amountBaseAssetBought = $t02184222057._1
525+                    let qtAstRAfter = $t02184222057._2
526+                    let bsAstRAfter = $t02184222057._3
527+                    let baseAsstFndDeltAfter = $t02184222057._4
528+                    let totalPositionSizeAfter = $t02184222057._5
529+                    let cumulativeNotionalAfter = $t02184222057._6
530+                    if (if ((_minBaseAssetAmount != 0))
531+                        then (_minBaseAssetAmount > abs(amountBaseAssetBought))
532+                        else false)
533+                        then throw(((("Limit error: " + toString(abs(amountBaseAssetBought))) + " < ") + toString(_minBaseAssetAmount)))
534+                        else {
535+                            let newPositionSize = (oldPositionSize + amountBaseAssetBought)
536+                            let increaseMarginRequirement = divd(openNotional, _leverage)
537+                            let $t02243822691 = calcRemainMarginWithFundingPayment(oldPositionSize, oldPositionMargin, oldPositionLstUpdCPF, increaseMarginRequirement)
538+                            let remainMargin = $t02243822691._1
539+                            let x1 = $t02243822691._2
540+                            let x2 = $t02243822691._3
541+                            let oldLatestCPF = $t02243822691._4
542+                            $Tuple10(newPositionSize, remainMargin, (oldPositionOpenNotional + openNotional), oldLatestCPF, bsAstRAfter, qtAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, (openInteresetNotional() + openNotional))
543+                            }
544+                    }
545+                else {
546+                    let openNotional = muld(_amount, _leverage)
547+                    let $t02329023389 = getPositionNotionalAndUnrealizedPnl(toString(i.caller))
548+                    let oldPositionNotional = $t02329023389._1
549+                    let unrealizedPnl = $t02329023389._2
550+                    if ((oldPositionNotional > openNotional))
551+                        then throw("Use decreasePosition to decrease position size")
552+                        else throw("Close position first")
553+                    }
554+            let newPositionSize = $t02145623580._1
555+            let newPositionRemainMargin = $t02145623580._2
556+            let newPosiionOpenNotional = $t02145623580._3
557+            let newPositionLatestCPF = $t02145623580._4
558+            let bsAstRAfter = $t02145623580._5
559+            let qtAstRAfter = $t02145623580._6
560+            let baseAsstFndDeltAfter = $t02145623580._7
561+            let totalPositionSizeAfter = $t02145623580._8
562+            let cumulativeNotionalAfter = $t02145623580._9
563+            let openInteresetNotionalAfter = $t02145623580._10
564+            let feeToStakers = (feeAmount / 2)
565+            let feeToInsurance = (feeAmount - feeToStakers)
566+            let stake = invoke(quoteAssetStaking(), "lockNeutrinoSP", [toString(stakingAddress()), ALL_FEES], [AttachedPayment(quoteAsset(), _amount)])
567+            if ((stake == stake))
568+                then {
569+                    let depositInsurance = invoke(insuranceAddress(), "deposit", nil, [AttachedPayment(quoteAsset(), feeToInsurance)])
570+                    if ((depositInsurance == depositInsurance))
571+                        then (((updatePosition(toString(i.caller), newPositionSize, newPositionRemainMargin, newPosiionOpenNotional, newPositionLatestCPF) ++ updateAmm(qtAstRAfter, bsAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter)) ++ transferFee(feeToStakers)) ++ upblc((cbalance() + _amount)))
572+                        else throw("Strict value is not equal to itself.")
573+                    }
574+                else throw("Strict value is not equal to itself.")
575+            }
576+    }
577+
578+
579+
580+@Callable(i)
581+func addMargin () = {
582+    let _rawAmount = i.payments[0].amount
583+    if (if ((i.payments[0].assetId != quoteAsset()))
584+        then true
585+        else !(requireOpenPosition(toString(i.caller))))
586+        then throw("Invalid addMargin parameters")
587+        else {
588+            let feeAmount = muld(_rawAmount, fee())
589+            let _amount = (_rawAmount - feeAmount)
590+            let $t02477224924 = getPosition(toString(i.caller))
591+            let oldPositionSize = $t02477224924._1
592+            let oldPositionMargin = $t02477224924._2
593+            let oldPositionOpenNotional = $t02477224924._3
594+            let oldPositionLstUpdCPF = $t02477224924._4
595+            let feeToStakers = (feeAmount / 2)
596+            let feeToInsurance = (feeAmount - feeToStakers)
597+            let stake = invoke(quoteAssetStaking(), "lockNeutrinoSP", [toString(stakingAddress()), ALL_FEES], [AttachedPayment(quoteAsset(), _amount)])
598+            if ((stake == stake))
599+                then {
600+                    let depositInsurance = invoke(insuranceAddress(), "deposit", nil, [AttachedPayment(quoteAsset(), feeToInsurance)])
601+                    if ((depositInsurance == depositInsurance))
602+                        then ((updatePosition(toString(i.caller), oldPositionSize, (oldPositionMargin + i.payments[0].amount), oldPositionOpenNotional, oldPositionLstUpdCPF) ++ transferFee(feeToStakers)) ++ upblc((cbalance() + _amount)))
603+                        else throw("Strict value is not equal to itself.")
604+                    }
605+                else throw("Strict value is not equal to itself.")
606+            }
607+    }
608+
609+
610+
611+@Callable(i)
612+func removeMargin (_amount) = if (if ((0 >= _amount))
613+    then true
614+    else !(requireOpenPosition(toString(i.caller))))
615+    then throw("Invalid removeMargin parameters")
616+    else {
617+        let $t02581125963 = getPosition(toString(i.caller))
618+        let oldPositionSize = $t02581125963._1
619+        let oldPositionMargin = $t02581125963._2
620+        let oldPositionOpenNotional = $t02581125963._3
621+        let oldPositionLstUpdCPF = $t02581125963._4
622+        let marginDelta = -(_amount)
623+        let $t02600026195 = calcRemainMarginWithFundingPayment(oldPositionSize, oldPositionMargin, oldPositionLstUpdCPF, marginDelta)
624+        let remainMargin = $t02600026195._1
625+        let badDebt = $t02600026195._2
626+        let x1 = $t02600026195._3
627+        let latestCPF1 = $t02600026195._4
628+        if ((badDebt != 0))
629+            then throw("Invalid added margin amount")
630+            else {
631+                let unstake = invoke(quoteAssetStaking(), "unlockNeutrino", [_amount, toBase58String(quoteAsset())], nil)
632+                if ((unstake == unstake))
633+                    then ((updatePosition(toString(i.caller), oldPositionSize, remainMargin, oldPositionOpenNotional, latestCPF1) ++ withdraw(i.caller, _amount)) ++ upblc((cbalance() - _amount)))
634+                    else throw("Strict value is not equal to itself.")
635+                }
636+        }
637+
638+
639+
640+@Callable(i)
641+func closePosition () = if (!(requireOpenPosition(toString(i.caller))))
642+    then throw("Invalid closePosition parameters")
643+    else {
644+        let $t02686027192 = internalClosePosition(toString(i.caller))
645+        let x1 = $t02686027192._1
646+        let badDebt = $t02686027192._2
647+        let realizedPnl = $t02686027192._3
648+        let marginToVault = $t02686027192._4
649+        let quoteAssetReserveAfter = $t02686027192._5
650+        let bsAstRAfter = $t02686027192._6
651+        let baseAsstFndDeltAfter = $t02686027192._7
652+        let totalPositionSizeAfter = $t02686027192._8
653+        let cumulativeNotionalAfter = $t02686027192._9
654+        let openInteresetNotionalAfter = $t02686027192._10
655+        if ((badDebt > 0))
656+            then throw("Unable to close position with bad debt")
657+            else {
658+                let withdrawAmount = abs(marginToVault)
659+                let bd = (cbalance() - withdrawAmount)
660+                let $t02738527481 = if ((0 > bd))
661+                    then $Tuple2(0, abs(bd))
662+                    else $Tuple2(bd, 0)
663+                let nb = $t02738527481._1
664+                let fromi = $t02738527481._2
665+                let x = if ((fromi > 0))
666+                    then {
667+                        let withdrawInsurance = invoke(insuranceAddress(), "withdraw", [fromi], nil)
668+                        if ((withdrawInsurance == withdrawInsurance))
669+                            then nil
670+                            else throw("Strict value is not equal to itself.")
671+                        }
672+                    else nil
673+                if ((x == x))
674+                    then {
675+                        let unstake = invoke(quoteAssetStaking(), "unlockNeutrino", [(withdrawAmount - fromi), toBase58String(quoteAsset())], nil)
676+                        if ((unstake == unstake))
677+                            then (((deletePosition(toString(i.caller)) ++ updateAmm(quoteAssetReserveAfter, bsAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter)) ++ withdraw(i.caller, withdrawAmount)) ++ upblc(nb))
678+                            else throw("Strict value is not equal to itself.")
679+                        }
680+                    else throw("Strict value is not equal to itself.")
681+                }
682+        }
683+
684+
685+
686+@Callable(i)
687+func liquidate (_trader) = if (if (!(requireMoreMarginRatio(getMarginRatio(_trader), mmr(), false)))
688+    then true
689+    else !(initialized()))
690+    then throw("Unable to liquidate")
691+    else {
692+        let $t02843528739 = internalClosePosition(_trader)
693+        let x1 = $t02843528739._1
694+        let badDebt = $t02843528739._2
695+        let x2 = $t02843528739._3
696+        let marginToVault = $t02843528739._4
697+        let quoteAssetReserveAfter = $t02843528739._5
698+        let bsAstRAfter = $t02843528739._6
699+        let baseAsstFndDeltAfter = $t02843528739._7
700+        let totalPositionSizeAfter = $t02843528739._8
701+        let cumulativeNotionalAfter = $t02843528739._9
702+        let openInteresetNotionalAfter = $t02843528739._10
703+        let exchangedQuoteAssetAmount = $t02843528739._11
704+        let feeToLiquidator = (muld(exchangedQuoteAssetAmount, liquidationFeeRatio()) / 2)
705+        let $t02882929233 = if ((feeToLiquidator > marginToVault))
706+            then $Tuple3((feeToLiquidator - marginToVault), marginToVault, ((badDebt + feeToLiquidator) - marginToVault))
707+            else $Tuple3(0, (marginToVault - feeToLiquidator), badDebt)
708+        let liquidationBadDebt = $t02882929233._1
709+        let remainMargin = $t02882929233._2
710+        let totalBadDebt = $t02882929233._3
711+        let bd = (cbalance() - feeToLiquidator)
712+        let $t02928129369 = if ((0 > bd))
713+            then $Tuple2(0, abs(bd))
714+            else $Tuple2(bd, 0)
715+        let nb = $t02928129369._1
716+        let fromi = $t02928129369._2
717+        let x = if ((fromi > 0))
718+            then {
719+                let withdrawInsurance = invoke(insuranceAddress(), "withdraw", [fromi], nil)
720+                if ((withdrawInsurance == withdrawInsurance))
721+                    then nil
722+                    else throw("Strict value is not equal to itself.")
723+                }
724+            else nil
725+        if ((x == x))
726+            then {
727+                let unstake = invoke(quoteAssetStaking(), "unlockNeutrino", [(feeToLiquidator - fromi), toBase58String(quoteAsset())], nil)
728+                if ((unstake == unstake))
729+                    then (((deletePosition(_trader) ++ updateAmm(quoteAssetReserveAfter, bsAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter)) ++ withdraw(i.caller, feeToLiquidator)) ++ upblc(nb))
730+                    else throw("Strict value is not equal to itself.")
731+                }
732+            else throw("Strict value is not equal to itself.")
733+        }
734+
735+
736+
737+@Callable(i)
738+func payFunding () = {
739+    let fundingBlockTimestamp = nextFundingBlockTimestamp()
740+    if (if ((fundingBlockTimestamp > lastBlock.timestamp))
741+        then true
742+        else !(initialized()))
743+        then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(fundingBlockTimestamp)))
744+        else {
745+            let underlyingPrice = getOracleTwapPrice()
746+            let spotTwapPrice = getTwapSpotPrice()
747+            let premium = (spotTwapPrice - underlyingPrice)
748+            let premiumFraction = divd(muld(premium, fundingPeriodDecimal()), ONE_DAY)
749+            let totalTraderPositionSize = totalPositionSize()
750+            let ammFundingPaymentProfit = muld(premiumFraction, totalTraderPositionSize)
751+            let fundingAmount = abs(ammFundingPaymentProfit)
752+            let balanceChange = if ((0 > ammFundingPaymentProfit))
753+                then {
754+                    let withdrawInsurance = invoke(insuranceAddress(), "withdraw", [fundingAmount], nil)
755+                    if ((withdrawInsurance == withdrawInsurance))
756+                        then {
757+                            let stake = invoke(quoteAssetStaking(), "lockNeutrinoSP", [toString(stakingAddress()), ALL_FEES], [AttachedPayment(quoteAsset(), fundingAmount)])
758+                            if ((stake == stake))
759+                                then upblc((cbalance() + fundingAmount))
760+                                else throw("Strict value is not equal to itself.")
761+                            }
762+                        else throw("Strict value is not equal to itself.")
763+                    }
764+                else if ((ammFundingPaymentProfit != 0))
765+                    then {
766+                        let unstake = invoke(quoteAssetStaking(), "unlockNeutrino", [fundingAmount, toBase58String(quoteAsset())], nil)
767+                        if ((unstake == unstake))
768+                            then {
769+                                let depositInsurance = invoke(insuranceAddress(), "deposit", nil, [AttachedPayment(quoteAsset(), fundingAmount)])
770+                                if ((depositInsurance == depositInsurance))
771+                                    then upblc((cbalance() - fundingAmount))
772+                                    else throw("Strict value is not equal to itself.")
773+                                }
774+                            else throw("Strict value is not equal to itself.")
775+                        }
776+                    else upblc((cbalance() - fundingAmount))
777+            (balanceChange ++ updateFunding(0, (fundingBlockTimestamp + fundingPeriodSeconds()), (latestCPF() + premiumFraction), divd(premiumFraction, underlyingPrice)))
778+            }
779+    }
780+
781+
782+
783+@Callable(i)
784+func v_get (_trader) = {
785+    let $t03205132104 = internalClosePosition(_trader)
786+    let x1 = $t03205132104._1
787+    let x2 = $t03205132104._2
788+    let x3 = $t03205132104._3
789+    let x4 = $t03205132104._4
790+    throw((((s(x2) + s(x3)) + s(x4)) + s(getMarginRatio(_trader))))
791+    }
792+
793+
794+@Verifier(tx)
795+func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], adminPublicKey())
796+
github/deemru/w8io/169f3d6 
38.94 ms ◑