tx · CpCL6K9PHDTUaYAMzRtLaF7TDy8nnHvFMHKBCnx7N953

3Myy5WAmTTRosypUGxdmNzL6VmFUe63qTca:  -0.03400000 Waves

2022.06.15 21:34 [2097861] smart account 3Myy5WAmTTRosypUGxdmNzL6VmFUe63qTca > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CpCL6K9PHDTUaYAMzRtLaF7TDy8nnHvFMHKBCnx7N953",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1655318069147,
    "version": 2,
    "chainId": 84,
    "sender": "3Myy5WAmTTRosypUGxdmNzL6VmFUe63qTca",
    "senderPublicKey": "3RcS69NxQweUbxj8b8GNVPJ7UebqyagVDQDREXYg5jyD",
    "proofs": [
        "2bb8So8xuqu7YunMaJWTHwMUvVGmicZuJ8kNB4Qj1v47FsTiMmYZjP8Ke1XL5cat1Uz58VqpvjY62aagzCaBivvi"
    ],
    "script": "base64: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",
    "height": 2097861,
    "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 (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 (i.caller != adminAddress()))
392+    then true
393+    else initialized())
394+    then throw("Invalid initialize parameters")
395+    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)])
396+
397+
398+
399+@Callable(i)
400+func decreasePosition (_direction,_amount,_leverage,_minBaseAssetAmount) = if (if (if (if (if (if ((_direction != DIR_LONG))
401+    then (_direction != DIR_SHORT)
402+    else false)
403+    then true
404+    else (0 >= _amount))
405+    then true
406+    else if (((1 * DECIMAL_UNIT) > _leverage))
407+        then true
408+        else (_leverage > (3 * DECIMAL_UNIT)))
409+    then true
410+    else !(initialized()))
411+    then true
412+    else !(requireMoreMarginRatio(divd(DECIMAL_UNIT, _leverage), initMarginRatio(), true)))
413+    then throw("Invalid decreasePosition parameters")
414+    else {
415+        let $t01689317045 = getPosition(toString(i.caller))
416+        let oldPositionSize = $t01689317045._1
417+        let oldPositionMargin = $t01689317045._2
418+        let oldPositionOpenNotional = $t01689317045._3
419+        let oldPositionLstUpdCPF = $t01689317045._4
420+        let isNewPosition = (oldPositionSize == 0)
421+        let isSameDirection = if ((oldPositionSize > 0))
422+            then (_direction == DIR_LONG)
423+            else (_direction == DIR_SHORT)
424+        let expandExisting = if (!(isNewPosition))
425+            then isSameDirection
426+            else false
427+        let isAdd = (_direction == DIR_LONG)
428+        let $t01733420067 = if (if (isNewPosition)
429+            then true
430+            else expandExisting)
431+            then throw("Use increasePosition to open new or increase position")
432+            else {
433+                let openNotional = muld(_amount, _leverage)
434+                let $t01780217901 = getPositionNotionalAndUnrealizedPnl(toString(i.caller))
435+                let oldPositionNotional = $t01780217901._1
436+                let unrealizedPnl = $t01780217901._2
437+                if ((oldPositionNotional > openNotional))
438+                    then {
439+                        let $t01796318206 = swapInput(isAdd, openNotional)
440+                        let exchangedPositionSize = $t01796318206._1
441+                        let qtAstRAfter = $t01796318206._2
442+                        let bsAstRAfter = $t01796318206._3
443+                        let baseAsstFndDeltAfter = $t01796318206._4
444+                        let totalPositionSizeAfter = $t01796318206._5
445+                        let cumulativeNotionalAfter = $t01796318206._6
446+                        let exchangedPositionSizeAbs = abs(exchangedPositionSize)
447+                        if (if ((_minBaseAssetAmount != 0))
448+                            then (_minBaseAssetAmount > exchangedPositionSizeAbs)
449+                            else false)
450+                            then throw(((("Too little basse asset exchanged, got " + toString(exchangedPositionSizeAbs)) + " expected ") + toString(_minBaseAssetAmount)))
451+                            else {
452+                                let realizedPnl = if ((oldPositionSize != 0))
453+                                    then divd(muld(unrealizedPnl, exchangedPositionSizeAbs), oldPositionSize)
454+                                    else 0
455+                                let $t01874719018 = calcRemainMarginWithFundingPayment(oldPositionSize, oldPositionMargin, oldPositionLstUpdCPF, realizedPnl)
456+                                let remainMargin = $t01874719018._1
457+                                let badDebt = $t01874719018._2
458+                                let fundingPayment = $t01874719018._3
459+                                let oldLatestCPF = $t01874719018._4
460+                                let exchangedQuoteAssetAmount = openNotional
461+                                let unrealizedPnlAfter = (unrealizedPnl - realizedPnl)
462+                                let remainOpenNotional = if ((oldPositionSize > 0))
463+                                    then ((oldPositionNotional - exchangedQuoteAssetAmount) - unrealizedPnlAfter)
464+                                    else ((unrealizedPnlAfter + oldPositionNotional) - exchangedQuoteAssetAmount)
465+                                $Tuple10((oldPositionSize + exchangedPositionSize), remainMargin, abs(remainOpenNotional), oldLatestCPF, bsAstRAfter, qtAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, (openInteresetNotional() - openNotional))
466+                                }
467+                        }
468+                    else throw("Close position first")
469+                }
470+        let newPositionSize = $t01733420067._1
471+        let newPositionRemainMargin = $t01733420067._2
472+        let newPosiionOpenNotional = $t01733420067._3
473+        let newPositionLatestCPF = $t01733420067._4
474+        let bsAstRAfter = $t01733420067._5
475+        let qtAstRAfter = $t01733420067._6
476+        let baseAsstFndDeltAfter = $t01733420067._7
477+        let totalPositionSizeAfter = $t01733420067._8
478+        let cumulativeNotionalAfter = $t01733420067._9
479+        let openInteresetNotionalAfter = $t01733420067._10
480+        (updatePosition(toString(i.caller), newPositionSize, newPositionRemainMargin, newPosiionOpenNotional, newPositionLatestCPF) ++ updateAmm(qtAstRAfter, bsAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter))
481+        }
482+
483+
484+
485+@Callable(i)
486+func increasePosition (_direction,_leverage,_minBaseAssetAmount) = {
487+    let _rawAmount = i.payments[0].amount
488+    if (if (if (if (if (if (if ((_direction != DIR_LONG))
489+        then (_direction != DIR_SHORT)
490+        else false)
491+        then true
492+        else (0 >= _rawAmount))
493+        then true
494+        else if (((1 * DECIMAL_UNIT) > _leverage))
495+            then true
496+            else (_leverage > (3 * DECIMAL_UNIT)))
497+        then true
498+        else !(initialized()))
499+        then true
500+        else (i.payments[0].assetId != quoteAsset()))
501+        then true
502+        else !(requireMoreMarginRatio(divd(DECIMAL_UNIT, _leverage), initMarginRatio(), true)))
503+        then throw("Invalid increasePosition parameters")
504+        else {
505+            let feeAmount = muld(_rawAmount, fee())
506+            let _amount = (_rawAmount - feeAmount)
507+            let $t02104921201 = getPosition(toString(i.caller))
508+            let oldPositionSize = $t02104921201._1
509+            let oldPositionMargin = $t02104921201._2
510+            let oldPositionOpenNotional = $t02104921201._3
511+            let oldPositionLstUpdCPF = $t02104921201._4
512+            let isNewPosition = (oldPositionSize == 0)
513+            let isSameDirection = if ((oldPositionSize > 0))
514+                then (_direction == DIR_LONG)
515+                else (_direction == DIR_SHORT)
516+            let expandExisting = if (!(isNewPosition))
517+                then isSameDirection
518+                else false
519+            let isAdd = (_direction == DIR_LONG)
520+            let $t02149023614 = if (if (isNewPosition)
521+                then true
522+                else expandExisting)
523+                then {
524+                    let openNotional = muld(_amount, _leverage)
525+                    let $t02187622091 = swapInput(isAdd, openNotional)
526+                    let amountBaseAssetBought = $t02187622091._1
527+                    let qtAstRAfter = $t02187622091._2
528+                    let bsAstRAfter = $t02187622091._3
529+                    let baseAsstFndDeltAfter = $t02187622091._4
530+                    let totalPositionSizeAfter = $t02187622091._5
531+                    let cumulativeNotionalAfter = $t02187622091._6
532+                    if (if ((_minBaseAssetAmount != 0))
533+                        then (_minBaseAssetAmount > abs(amountBaseAssetBought))
534+                        else false)
535+                        then throw(((("Limit error: " + toString(abs(amountBaseAssetBought))) + " < ") + toString(_minBaseAssetAmount)))
536+                        else {
537+                            let newPositionSize = (oldPositionSize + amountBaseAssetBought)
538+                            let increaseMarginRequirement = divd(openNotional, _leverage)
539+                            let $t02247222725 = calcRemainMarginWithFundingPayment(oldPositionSize, oldPositionMargin, oldPositionLstUpdCPF, increaseMarginRequirement)
540+                            let remainMargin = $t02247222725._1
541+                            let x1 = $t02247222725._2
542+                            let x2 = $t02247222725._3
543+                            let oldLatestCPF = $t02247222725._4
544+                            $Tuple10(newPositionSize, remainMargin, (oldPositionOpenNotional + openNotional), oldLatestCPF, bsAstRAfter, qtAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, (openInteresetNotional() + openNotional))
545+                            }
546+                    }
547+                else {
548+                    let openNotional = muld(_amount, _leverage)
549+                    let $t02332423423 = getPositionNotionalAndUnrealizedPnl(toString(i.caller))
550+                    let oldPositionNotional = $t02332423423._1
551+                    let unrealizedPnl = $t02332423423._2
552+                    if ((oldPositionNotional > openNotional))
553+                        then throw("Use decreasePosition to decrease position size")
554+                        else throw("Close position first")
555+                    }
556+            let newPositionSize = $t02149023614._1
557+            let newPositionRemainMargin = $t02149023614._2
558+            let newPosiionOpenNotional = $t02149023614._3
559+            let newPositionLatestCPF = $t02149023614._4
560+            let bsAstRAfter = $t02149023614._5
561+            let qtAstRAfter = $t02149023614._6
562+            let baseAsstFndDeltAfter = $t02149023614._7
563+            let totalPositionSizeAfter = $t02149023614._8
564+            let cumulativeNotionalAfter = $t02149023614._9
565+            let openInteresetNotionalAfter = $t02149023614._10
566+            let feeToStakers = (feeAmount / 2)
567+            let feeToInsurance = (feeAmount - feeToStakers)
568+            let stake = invoke(quoteAssetStaking(), "lockNeutrinoSP", [toString(stakingAddress()), ALL_FEES], [AttachedPayment(quoteAsset(), _amount)])
569+            if ((stake == stake))
570+                then {
571+                    let depositInsurance = invoke(insuranceAddress(), "deposit", nil, [AttachedPayment(quoteAsset(), feeToInsurance)])
572+                    if ((depositInsurance == depositInsurance))
573+                        then (((updatePosition(toString(i.caller), newPositionSize, newPositionRemainMargin, newPosiionOpenNotional, newPositionLatestCPF) ++ updateAmm(qtAstRAfter, bsAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter)) ++ transferFee(feeToStakers)) ++ upblc((cbalance() + _amount)))
574+                        else throw("Strict value is not equal to itself.")
575+                    }
576+                else throw("Strict value is not equal to itself.")
577+            }
578+    }
579+
580+
581+
582+@Callable(i)
583+func addMargin () = {
584+    let _rawAmount = i.payments[0].amount
585+    if (if ((i.payments[0].assetId != quoteAsset()))
586+        then true
587+        else !(requireOpenPosition(toString(i.caller))))
588+        then throw("Invalid addMargin parameters")
589+        else {
590+            let feeAmount = muld(_rawAmount, fee())
591+            let _amount = (_rawAmount - feeAmount)
592+            let $t02480624958 = getPosition(toString(i.caller))
593+            let oldPositionSize = $t02480624958._1
594+            let oldPositionMargin = $t02480624958._2
595+            let oldPositionOpenNotional = $t02480624958._3
596+            let oldPositionLstUpdCPF = $t02480624958._4
597+            let feeToStakers = (feeAmount / 2)
598+            let feeToInsurance = (feeAmount - feeToStakers)
599+            let stake = invoke(quoteAssetStaking(), "lockNeutrinoSP", [toString(stakingAddress()), ALL_FEES], [AttachedPayment(quoteAsset(), _amount)])
600+            if ((stake == stake))
601+                then {
602+                    let depositInsurance = invoke(insuranceAddress(), "deposit", nil, [AttachedPayment(quoteAsset(), feeToInsurance)])
603+                    if ((depositInsurance == depositInsurance))
604+                        then ((updatePosition(toString(i.caller), oldPositionSize, (oldPositionMargin + i.payments[0].amount), oldPositionOpenNotional, oldPositionLstUpdCPF) ++ transferFee(feeToStakers)) ++ upblc((cbalance() + _amount)))
605+                        else throw("Strict value is not equal to itself.")
606+                    }
607+                else throw("Strict value is not equal to itself.")
608+            }
609+    }
610+
611+
612+
613+@Callable(i)
614+func removeMargin (_amount) = if (if ((0 >= _amount))
615+    then true
616+    else !(requireOpenPosition(toString(i.caller))))
617+    then throw("Invalid removeMargin parameters")
618+    else {
619+        let $t02584525997 = getPosition(toString(i.caller))
620+        let oldPositionSize = $t02584525997._1
621+        let oldPositionMargin = $t02584525997._2
622+        let oldPositionOpenNotional = $t02584525997._3
623+        let oldPositionLstUpdCPF = $t02584525997._4
624+        let marginDelta = -(_amount)
625+        let $t02603426229 = calcRemainMarginWithFundingPayment(oldPositionSize, oldPositionMargin, oldPositionLstUpdCPF, marginDelta)
626+        let remainMargin = $t02603426229._1
627+        let badDebt = $t02603426229._2
628+        let x1 = $t02603426229._3
629+        let latestCPF1 = $t02603426229._4
630+        if ((badDebt != 0))
631+            then throw("Invalid added margin amount")
632+            else {
633+                let unstake = invoke(quoteAssetStaking(), "unlockNeutrino", [_amount, toBase58String(quoteAsset())], nil)
634+                if ((unstake == unstake))
635+                    then ((updatePosition(toString(i.caller), oldPositionSize, remainMargin, oldPositionOpenNotional, latestCPF1) ++ withdraw(i.caller, _amount)) ++ upblc((cbalance() - _amount)))
636+                    else throw("Strict value is not equal to itself.")
637+                }
638+        }
639+
640+
641+
642+@Callable(i)
643+func closePosition () = if (!(requireOpenPosition(toString(i.caller))))
644+    then throw("Invalid closePosition parameters")
645+    else {
646+        let $t02689427226 = internalClosePosition(toString(i.caller))
647+        let x1 = $t02689427226._1
648+        let badDebt = $t02689427226._2
649+        let realizedPnl = $t02689427226._3
650+        let marginToVault = $t02689427226._4
651+        let quoteAssetReserveAfter = $t02689427226._5
652+        let bsAstRAfter = $t02689427226._6
653+        let baseAsstFndDeltAfter = $t02689427226._7
654+        let totalPositionSizeAfter = $t02689427226._8
655+        let cumulativeNotionalAfter = $t02689427226._9
656+        let openInteresetNotionalAfter = $t02689427226._10
657+        if ((badDebt > 0))
658+            then throw("Unable to close position with bad debt")
659+            else {
660+                let withdrawAmount = abs(marginToVault)
661+                let bd = (cbalance() - withdrawAmount)
662+                let $t02741927515 = if ((0 > bd))
663+                    then $Tuple2(0, abs(bd))
664+                    else $Tuple2(bd, 0)
665+                let nb = $t02741927515._1
666+                let fromi = $t02741927515._2
667+                let x = if ((fromi > 0))
668+                    then {
669+                        let withdrawInsurance = invoke(insuranceAddress(), "withdraw", [fromi], nil)
670+                        if ((withdrawInsurance == withdrawInsurance))
671+                            then nil
672+                            else throw("Strict value is not equal to itself.")
673+                        }
674+                    else nil
675+                if ((x == x))
676+                    then {
677+                        let unstake = invoke(quoteAssetStaking(), "unlockNeutrino", [(withdrawAmount - fromi), toBase58String(quoteAsset())], nil)
678+                        if ((unstake == unstake))
679+                            then (((deletePosition(toString(i.caller)) ++ updateAmm(quoteAssetReserveAfter, bsAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter)) ++ withdraw(i.caller, withdrawAmount)) ++ upblc(nb))
680+                            else throw("Strict value is not equal to itself.")
681+                        }
682+                    else throw("Strict value is not equal to itself.")
683+                }
684+        }
685+
686+
687+
688+@Callable(i)
689+func liquidate (_trader) = if (if (!(requireMoreMarginRatio(getMarginRatio(_trader), mmr(), false)))
690+    then true
691+    else !(initialized()))
692+    then throw("Unable to liquidate")
693+    else {
694+        let $t02846928773 = internalClosePosition(_trader)
695+        let x1 = $t02846928773._1
696+        let badDebt = $t02846928773._2
697+        let x2 = $t02846928773._3
698+        let marginToVault = $t02846928773._4
699+        let quoteAssetReserveAfter = $t02846928773._5
700+        let bsAstRAfter = $t02846928773._6
701+        let baseAsstFndDeltAfter = $t02846928773._7
702+        let totalPositionSizeAfter = $t02846928773._8
703+        let cumulativeNotionalAfter = $t02846928773._9
704+        let openInteresetNotionalAfter = $t02846928773._10
705+        let exchangedQuoteAssetAmount = $t02846928773._11
706+        let feeToLiquidator = (muld(exchangedQuoteAssetAmount, liquidationFeeRatio()) / 2)
707+        let $t02886329267 = if ((feeToLiquidator > marginToVault))
708+            then $Tuple3((feeToLiquidator - marginToVault), marginToVault, ((badDebt + feeToLiquidator) - marginToVault))
709+            else $Tuple3(0, (marginToVault - feeToLiquidator), badDebt)
710+        let liquidationBadDebt = $t02886329267._1
711+        let remainMargin = $t02886329267._2
712+        let totalBadDebt = $t02886329267._3
713+        let bd = (cbalance() - feeToLiquidator)
714+        let $t02931529403 = if ((0 > bd))
715+            then $Tuple2(0, abs(bd))
716+            else $Tuple2(bd, 0)
717+        let nb = $t02931529403._1
718+        let fromi = $t02931529403._2
719+        let x = if ((fromi > 0))
720+            then {
721+                let withdrawInsurance = invoke(insuranceAddress(), "withdraw", [fromi], nil)
722+                if ((withdrawInsurance == withdrawInsurance))
723+                    then nil
724+                    else throw("Strict value is not equal to itself.")
725+                }
726+            else nil
727+        if ((x == x))
728+            then {
729+                let unstake = invoke(quoteAssetStaking(), "unlockNeutrino", [(feeToLiquidator - fromi), toBase58String(quoteAsset())], nil)
730+                if ((unstake == unstake))
731+                    then (((deletePosition(_trader) ++ updateAmm(quoteAssetReserveAfter, bsAstRAfter, baseAsstFndDeltAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter)) ++ withdraw(i.caller, feeToLiquidator)) ++ upblc(nb))
732+                    else throw("Strict value is not equal to itself.")
733+                }
734+            else throw("Strict value is not equal to itself.")
735+        }
736+
737+
738+
739+@Callable(i)
740+func payFunding () = {
741+    let fundingBlockTimestamp = nextFundingBlockTimestamp()
742+    if (if ((fundingBlockTimestamp > lastBlock.timestamp))
743+        then true
744+        else !(initialized()))
745+        then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(fundingBlockTimestamp)))
746+        else {
747+            let underlyingPrice = getOracleTwapPrice()
748+            let spotTwapPrice = getTwapSpotPrice()
749+            let premium = (spotTwapPrice - underlyingPrice)
750+            let premiumFraction = divd(muld(premium, fundingPeriodDecimal()), ONE_DAY)
751+            let totalTraderPositionSize = totalPositionSize()
752+            let ammFundingPaymentProfit = muld(premiumFraction, totalTraderPositionSize)
753+            let fundingAmount = abs(ammFundingPaymentProfit)
754+            let balanceChange = if ((0 > ammFundingPaymentProfit))
755+                then {
756+                    let withdrawInsurance = invoke(insuranceAddress(), "withdraw", [fundingAmount], nil)
757+                    if ((withdrawInsurance == withdrawInsurance))
758+                        then {
759+                            let stake = invoke(quoteAssetStaking(), "lockNeutrinoSP", [toString(stakingAddress()), ALL_FEES], [AttachedPayment(quoteAsset(), fundingAmount)])
760+                            if ((stake == stake))
761+                                then upblc((cbalance() + fundingAmount))
762+                                else throw("Strict value is not equal to itself.")
763+                            }
764+                        else throw("Strict value is not equal to itself.")
765+                    }
766+                else if ((ammFundingPaymentProfit != 0))
767+                    then {
768+                        let unstake = invoke(quoteAssetStaking(), "unlockNeutrino", [fundingAmount, toBase58String(quoteAsset())], nil)
769+                        if ((unstake == unstake))
770+                            then {
771+                                let depositInsurance = invoke(insuranceAddress(), "deposit", nil, [AttachedPayment(quoteAsset(), fundingAmount)])
772+                                if ((depositInsurance == depositInsurance))
773+                                    then upblc((cbalance() - fundingAmount))
774+                                    else throw("Strict value is not equal to itself.")
775+                                }
776+                            else throw("Strict value is not equal to itself.")
777+                        }
778+                    else upblc((cbalance() - fundingAmount))
779+            (balanceChange ++ updateFunding(0, (fundingBlockTimestamp + fundingPeriodSeconds()), (latestCPF() + premiumFraction), divd(premiumFraction, underlyingPrice)))
780+            }
781+    }
782+
783+
784+
785+@Callable(i)
786+func v_get (_trader) = {
787+    let $t03208532138 = internalClosePosition(_trader)
788+    let x1 = $t03208532138._1
789+    let x2 = $t03208532138._2
790+    let x3 = $t03208532138._3
791+    let x4 = $t03208532138._4
792+    throw((((s(x2) + s(x3)) + s(x4)) + s(getMarginRatio(_trader))))
793+    }
794+
795+
796+@Verifier(tx)
797+func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], adminPublicKey())
798+
github/deemru/w8io/169f3d6 
60.67 ms ◑