tx · GfwCVHcqSonWqAw5iAhtpRQLAuWt55D6N7n6uH6jeFPK

3Mp4WatZzHNtYW4JAm5vvtRCmnkKmqbFFsF:  -0.03200000 Waves

2022.05.23 11:56 [2064122] smart account 3Mp4WatZzHNtYW4JAm5vvtRCmnkKmqbFFsF > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "GfwCVHcqSonWqAw5iAhtpRQLAuWt55D6N7n6uH6jeFPK",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1653296264658,
    "version": 2,
    "chainId": 84,
    "sender": "3Mp4WatZzHNtYW4JAm5vvtRCmnkKmqbFFsF",
    "senderPublicKey": "3Ct61ciyTWAurVnqkawNteS6Kg2wdGLyvPDRZGPagYni",
    "proofs": [
        "27DkaogRuXn56hH1C4tdhSNZE8mxvPr4kfsXxixupyNvyk1tTb9USZASQWt5APLmmLUn3UksZEYrt4crrM2CagGu"
    ],
    "script": "base64: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",
    "height": 2064122,
    "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 ora_k_price = "price"
5+
6+let k_balance = "k_balance"
7+
8+let k_positionSize = "k_positionSize"
9+
10+let k_positionMargin = "k_positionMargin"
11+
12+let k_pon = "k_pon"
13+
14+let k_positionLstUpdCPF = "k_positionFraction"
15+
16+let k_initialized = "k_initialized"
17+
18+let k_fee = "k_fee"
19+
20+let k_fundingPeriod = "k_fundingPeriod"
21+
22+let k_initMarginRatio = "k_initMarginRatio"
23+
24+let k_mmr = "k_mmr"
25+
26+let k_liquidationFeeRatio = "k_liquidationFeeRatio"
27+
28+let k_insurance = "k_insurance"
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_baseAssetDeltaThisFundingPeriod = "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 ADMIN_ADDRESS = Address(base58'3N4RABjANLWJyQAf8kvxUZk82UALxFbR9FM')
49+
50+let ADMIN_PUBLIC_KEY = base58'A6ZtwikNTr19YpC1t6HnNGCBJF6GTx62DhEkJpgpzpmL'
51+
52+let USDN = base58'HezsdQuRDtzksAYUy97gfhKy7Z1NW2uXYSHA3bgqenNZ'
53+
54+let USDN_STAKING = Address(base58'3N9LkJahTMx41wGhSxLS42prCZtRCp4dhTs')
55+
56+let ORACLE = Address(base58'3N4NS7d4Jo9a6F14LiFUKKYVdUkkf2eP4Zx')
57+
58+let FEES_ACCOUNT = Address(base58'3MseEJNEHkYhvcHre6Mann1F8e27S1qptdg')
59+
60+let DIR_LONG = 1
61+
62+let DIR_SHORT = 2
63+
64+let FUNDING_BLOCK_INTERVAL = 60
65+
66+let SECONDS = 1000
67+
68+let DECIMAL_UNIT = (1 * (((((10 * 10) * 10) * 10) * 10) * 10))
69+
70+let ONE_DAY = (86400 * DECIMAL_UNIT)
71+
72+func divd (_x,_y) = fraction(_x, DECIMAL_UNIT, _y, HALFEVEN)
73+
74+
75+func muld (_x,_y) = fraction(_x, _y, DECIMAL_UNIT, HALFEVEN)
76+
77+
78+func abs (_x) = if ((_x > 0))
79+    then _x
80+    else -(_x)
81+
82+
83+func toCompositeKey (_key,_address) = ((_key + "_") + _address)
84+
85+
86+func requireMoreMarginRatio (_marginRatio,_baseMarginRatio,_largerThanOrEqualTo) = {
87+    let remainingMarginRatio = (_marginRatio - _baseMarginRatio)
88+    if (if (_largerThanOrEqualTo)
89+        then (0 > remainingMarginRatio)
90+        else false)
91+        then throw("Invalid margin")
92+        else if (if (!(_largerThanOrEqualTo))
93+            then (remainingMarginRatio >= 0)
94+            else false)
95+            then throw("Invalid margin")
96+            else true
97+    }
98+
99+
100+func int (k) = valueOrErrorMessage(getInteger(this, k), ("no value for " + k))
101+
102+
103+func cbalance () = int(k_balance)
104+
105+
106+func insurance () = int(k_insurance)
107+
108+
109+func fee () = int(k_fee)
110+
111+
112+func initMarginRatio () = int(k_initMarginRatio)
113+
114+
115+func qtAstR () = int(k_qtAstR)
116+
117+
118+func bsAstR () = int(k_bsAstR)
119+
120+
121+func baseAssetDeltaThisFundingPeriod () = int(k_baseAssetDeltaThisFundingPeriod)
122+
123+
124+func totalPositionSize () = int(k_totalPositionSize)
125+
126+
127+func cumulativeNotional () = int(k_cumulativeNotional)
128+
129+
130+func latestCPF () = int(k_latestCPF)
131+
132+
133+func openInteresetNotional () = int(k_openInteresetNotional)
134+
135+
136+func nextFundingBlockTimestamp () = int(k_nextFundingBlock)
137+
138+
139+func fundingPeriodRaw () = int(k_fundingPeriod)
140+
141+
142+func fundingPeriodDecimal () = (fundingPeriodRaw() * DECIMAL_UNIT)
143+
144+
145+func fundingPeriodSeconds () = (fundingPeriodRaw() * SECONDS)
146+
147+
148+func mmr () = int(k_mmr)
149+
150+
151+func liquidationFeeRatio () = int(k_liquidationFeeRatio)
152+
153+
154+func getPosition (invesor) = {
155+    let positionSizeOpt = getInteger(this, toCompositeKey(k_positionSize, invesor))
156+    match positionSizeOpt {
157+        case positionSize: Int => 
158+            $Tuple4(positionSize, getIntegerValue(this, toCompositeKey(k_positionMargin, invesor)), getIntegerValue(this, toCompositeKey(k_pon, invesor)), getIntegerValue(this, toCompositeKey(k_positionLstUpdCPF, invesor)))
159+        case _ => 
160+            $Tuple4(0, 0, 0, 0)
161+    }
162+    }
163+
164+
165+func requireOpenPosition (_trader) = {
166+    let $t039934104 = getPosition(_trader)
167+    let positionSize = $t039934104._1
168+    let positionMargin = $t039934104._2
169+    let pon = $t039934104._3
170+    let positionLstUpdCPF = $t039934104._4
171+    if ((positionSize == 0))
172+        then throw("No open position")
173+        else true
174+    }
175+
176+
177+func initialized () = valueOrElse(getBoolean(this, k_initialized), false)
178+
179+
180+func updateReserve (_isAdd,_quoteAssetAmount,_baseAssetAmount) = if (_isAdd)
181+    then $Tuple5((qtAstR() + _quoteAssetAmount), (bsAstR() - _baseAssetAmount), (baseAssetDeltaThisFundingPeriod() - _baseAssetAmount), (totalPositionSize() + _baseAssetAmount), (cumulativeNotional() + _quoteAssetAmount))
182+    else $Tuple5((qtAstR() - _quoteAssetAmount), (bsAstR() + _baseAssetAmount), (baseAssetDeltaThisFundingPeriod() + _baseAssetAmount), (totalPositionSize() - _baseAssetAmount), (cumulativeNotional() - _quoteAssetAmount))
183+
184+
185+func swapInput (_isAdd,_quoteAssetAmoun) = {
186+    let _qtAstR = qtAstR()
187+    let _bsAstR = bsAstR()
188+    let k = muld(_qtAstR, _bsAstR)
189+    let qtAstRAfter = if (_isAdd)
190+        then (_qtAstR + _quoteAssetAmoun)
191+        else (_qtAstR - _quoteAssetAmoun)
192+    let bsAstRAfter = divd(k, qtAstRAfter)
193+    let amountBaseAssetBoughtAbs = abs((bsAstRAfter - _bsAstR))
194+    let amountBaseAssetBought = if (_isAdd)
195+        then amountBaseAssetBoughtAbs
196+        else -(amountBaseAssetBoughtAbs)
197+    let $t053925606 = updateReserve(_isAdd, _quoteAssetAmoun, amountBaseAssetBoughtAbs)
198+    let qtAstRAfter1 = $t053925606._1
199+    let bsAstRAfter1 = $t053925606._2
200+    let baseAssetDeltaThisFundingPeriodAfter1 = $t053925606._3
201+    let totalPositionSizeAfter1 = $t053925606._4
202+    let cumulativeNotionalAfter1 = $t053925606._5
203+    $Tuple6(amountBaseAssetBought, qtAstRAfter1, bsAstRAfter1, baseAssetDeltaThisFundingPeriodAfter1, totalPositionSizeAfter1, cumulativeNotionalAfter1)
204+    }
205+
206+
207+func calcRemainMarginWithFundingPayment (_oldPositionSize,_oldPositionMargin,_oldPositionLstUpdCPF,_marginDelta) = {
208+    let _latestCPF = latestCPF()
209+    let fundingPayment = if ((_oldPositionSize != 0))
210+        then muld((_latestCPF - _oldPositionLstUpdCPF), _oldPositionSize)
211+        else 0
212+    let signedMargin = ((_marginDelta - fundingPayment) + _oldPositionMargin)
213+    let $t061966323 = if ((0 > signedMargin))
214+        then $Tuple2(0, abs(signedMargin))
215+        else $Tuple2(abs(signedMargin), 0)
216+    let remainMargin = $t061966323._1
217+    let badDebt = $t061966323._2
218+    $Tuple4(remainMargin, badDebt, fundingPayment, _latestCPF)
219+    }
220+
221+
222+func getOutputPriceWithReserves (_add,_baseAssetAmount,_quoteAssetPoolAmount,_baseAssetPoolAmount) = if ((_baseAssetAmount == 0))
223+    then throw("Invalid base asset amount")
224+    else {
225+        let k = muld(_quoteAssetPoolAmount, _baseAssetPoolAmount)
226+        let baseAssetPoolAmountAfter = if (_add)
227+            then (_baseAssetPoolAmount + _baseAssetAmount)
228+            else (_baseAssetPoolAmount - _baseAssetAmount)
229+        let quoteAssetAfter = divd(k, baseAssetPoolAmountAfter)
230+        let quoteAssetSold = abs((quoteAssetAfter - _quoteAssetPoolAmount))
231+        let $t069727187 = updateReserve(!(_add), quoteAssetSold, _baseAssetAmount)
232+        let qtAstRAfter1 = $t069727187._1
233+        let bsAstRAfter1 = $t069727187._2
234+        let baseAssetDeltaThisFundingPeriodAfter1 = $t069727187._3
235+        let totalPositionSizeAfter1 = $t069727187._4
236+        let cumulativeNotionalAfter1 = $t069727187._5
237+        $Tuple6(quoteAssetSold, qtAstRAfter1, bsAstRAfter1, baseAssetDeltaThisFundingPeriodAfter1, totalPositionSizeAfter1, cumulativeNotionalAfter1)
238+        }
239+
240+
241+func getPositionNotionalAndUnrealizedPnl (_trader) = {
242+    let $t074417552 = getPosition(_trader)
243+    let positionSize = $t074417552._1
244+    let positionMargin = $t074417552._2
245+    let pon = $t074417552._3
246+    let positionLstUpdCPF = $t074417552._4
247+    let positionSizeAbs = abs(positionSize)
248+    if ((positionSizeAbs == 0))
249+        then throw("Invalid position size")
250+        else {
251+            let isShort = (0 > positionSize)
252+            let $t077297879 = getOutputPriceWithReserves(!(isShort), positionSizeAbs, qtAstR(), bsAstR())
253+            let positionNotional = $t077297879._1
254+            let x1 = $t077297879._2
255+            let x2 = $t077297879._3
256+            let x3 = $t077297879._4
257+            let unrealizedPnl = if (isShort)
258+                then (pon - positionNotional)
259+                else (positionNotional - pon)
260+            $Tuple2(positionNotional, unrealizedPnl)
261+            }
262+    }
263+
264+
265+func getOracleTwapPrice () = getIntegerValue(ORACLE, ora_k_price)
266+
267+
268+func getTwapSpotPrice () = divd(qtAstR(), bsAstR())
269+
270+
271+func getMarginRatio (_trader) = {
272+    let $t082598370 = getPosition(_trader)
273+    let positionSize = $t082598370._1
274+    let positionMargin = $t082598370._2
275+    let pon = $t082598370._3
276+    let positionLstUpdCPF = $t082598370._4
277+    let $t083768460 = getPositionNotionalAndUnrealizedPnl(_trader)
278+    let positionNotional = $t083768460._1
279+    let unrealizedPnl = $t083768460._2
280+    let $t084658631 = calcRemainMarginWithFundingPayment(positionSize, positionMargin, positionLstUpdCPF, unrealizedPnl)
281+    let remainMargin = $t084658631._1
282+    let badDebt = $t084658631._2
283+    divd((remainMargin - badDebt), positionNotional)
284+    }
285+
286+
287+func internalClosePosition (_trader) = {
288+    let $t087388849 = getPosition(_trader)
289+    let positionSize = $t087388849._1
290+    let positionMargin = $t087388849._2
291+    let pon = $t087388849._3
292+    let positionLstUpdCPF = $t087388849._4
293+    let $t088558925 = getPositionNotionalAndUnrealizedPnl(_trader)
294+    let x1 = $t088558925._1
295+    let unrealizedPnl = $t088558925._2
296+    let $t089309102 = calcRemainMarginWithFundingPayment(positionSize, positionMargin, positionLstUpdCPF, unrealizedPnl)
297+    let remainMargin = $t089309102._1
298+    let badDebt = $t089309102._2
299+    let x2 = $t089309102._3
300+    let exchangedPositionSize = -(positionSize)
301+    let realizedPnl = unrealizedPnl
302+    let marginToVault = -(remainMargin)
303+    let $t092299552 = getOutputPriceWithReserves((positionSize > 0), abs(positionSize), qtAstR(), bsAstR())
304+    let exchangedQuoteAssetAmount = $t092299552._1
305+    let quoteAssetReserveAfter = $t092299552._2
306+    let bsAstRAfter = $t092299552._3
307+    let baseAssetDeltaThisFundingPeriodAfter = $t092299552._4
308+    let totalPositionSizeAfter = $t092299552._5
309+    let cumulativeNotionalAfter = $t092299552._6
310+    let openInteresetNotionalAfter = (openInteresetNotional() - pon)
311+    $Tuple11(exchangedPositionSize, badDebt, realizedPnl, marginToVault, quoteAssetReserveAfter, bsAstRAfter, baseAssetDeltaThisFundingPeriodAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter, exchangedQuoteAssetAmount)
312+    }
313+
314+
315+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)]
316+
317+
318+func updateFunding (_baseADTFP,_nextFundingBlock,_latestCPF,_fundingRate) = [IntegerEntry(k_baseAssetDeltaThisFundingPeriod, _baseADTFP), IntegerEntry(k_nextFundingBlock, _nextFundingBlock), IntegerEntry(k_latestCPF, _latestCPF), IntegerEntry(k_fundingRate, _fundingRate)]
319+
320+
321+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)]
322+
323+
324+func updateAmm (_qtAstR,_bsAstR,_baseAssetDeltaThisFundingPeriodAfter,_totalPositionSizeAfter,_cumulativeNotionalAfter,_openInteresetNotional) = [IntegerEntry(k_qtAstR, _qtAstR), IntegerEntry(k_bsAstR, _bsAstR), IntegerEntry(k_baseAssetDeltaThisFundingPeriod, _baseAssetDeltaThisFundingPeriodAfter), IntegerEntry(k_totalPositionSize, _totalPositionSizeAfter), IntegerEntry(k_cumulativeNotional, _cumulativeNotionalAfter), IntegerEntry(k_openInteresetNotional, _openInteresetNotional)]
325+
326+
327+func deletePosition (_address) = [DeleteEntry(toCompositeKey(k_positionSize, _address)), DeleteEntry(toCompositeKey(k_positionMargin, _address)), DeleteEntry(toCompositeKey(k_pon, _address)), DeleteEntry(toCompositeKey(k_positionLstUpdCPF, _address))]
328+
329+
330+func withdraw (_address,_amount) = {
331+    let balance = assetBalance(this, USDN)
332+    if ((_amount > balance))
333+        then throw(((("Unable to withdraw " + toString(_amount)) + " from contract balance ") + toString(balance)))
334+        else [ScriptTransfer(_address, _amount, USDN)]
335+    }
336+
337+
338+func writeConstants () = [StringEntry("ADMIN_ADDRESS", toString(ADMIN_ADDRESS)), StringEntry("USDN", toBase58String(USDN)), StringEntry("USDN_STAKING", toString(USDN_STAKING)), StringEntry("ORACLE", toString(ORACLE))]
339+
340+
341+func updateInsr (i) = [IntegerEntry(k_insurance, i)]
342+
343+
344+func upblc (i) = if ((0 > i))
345+    then throw("Balance")
346+    else [IntegerEntry(k_balance, i)]
347+
348+
349+func transferFee (i) = [ScriptTransfer(FEES_ACCOUNT, i, USDN)]
350+
351+
352+@Callable(i)
353+func initialize (_qtAstR,_bsAstR,_fundingPeriod,_initMarginRatio,_mmr,_liquidationFeeRatio,_fee) = if (if (if (if (if (if (if (if ((0 >= _qtAstR))
354+    then true
355+    else (0 >= _bsAstR))
356+    then true
357+    else (0 >= _fundingPeriod))
358+    then true
359+    else (0 >= _initMarginRatio))
360+    then true
361+    else (0 >= _mmr))
362+    then true
363+    else (0 >= _liquidationFeeRatio))
364+    then true
365+    else (i.caller != ADMIN_ADDRESS))
366+    then true
367+    else initialized())
368+    then throw("Invalid initialize parameters")
369+    else ((((((updateAmm(_qtAstR, _bsAstR, 0, 0, 0, 0) ++ updateSettings(_initMarginRatio, _mmr, _liquidationFeeRatio, _fundingPeriod, _fee)) ++ updateFunding(0, (lastBlock.timestamp + _fundingPeriod), 0, 0)) ++ updateInsr(0)) ++ upblc(0)) ++ writeConstants()) ++ [BooleanEntry(k_initialized, true)])
370+
371+
372+
373+@Callable(i)
374+func decreasePosition (_direction,_amount,_leverage,_minBaseAssetAmount) = if (if (if (if (if (if ((_direction != DIR_LONG))
375+    then (_direction != DIR_SHORT)
376+    else false)
377+    then true
378+    else (0 >= _amount))
379+    then true
380+    else if (((1 * DECIMAL_UNIT) > _leverage))
381+        then true
382+        else (_leverage > (3 * DECIMAL_UNIT)))
383+    then true
384+    else !(initialized()))
385+    then true
386+    else !(requireMoreMarginRatio(divd(DECIMAL_UNIT, _leverage), initMarginRatio(), true)))
387+    then throw("Invalid decreasePosition parameters")
388+    else {
389+        let $t01405014202 = getPosition(toString(i.caller))
390+        let oldPositionSize = $t01405014202._1
391+        let oldPositionMargin = $t01405014202._2
392+        let oldPositionOpenNotional = $t01405014202._3
393+        let oldPositionLstUpdCPF = $t01405014202._4
394+        let isNewPosition = (oldPositionSize == 0)
395+        let isSameDirection = if ((oldPositionSize > 0))
396+            then (_direction == DIR_LONG)
397+            else (_direction == DIR_SHORT)
398+        let expandExisting = if (!(isNewPosition))
399+            then isSameDirection
400+            else false
401+        let isAdd = (_direction == DIR_LONG)
402+        let $t01449117288 = if (if (isNewPosition)
403+            then true
404+            else expandExisting)
405+            then throw("Use increasePosition to open new or increase position")
406+            else {
407+                let openNotional = muld(_amount, _leverage)
408+                let $t01497515074 = getPositionNotionalAndUnrealizedPnl(toString(i.caller))
409+                let oldPositionNotional = $t01497515074._1
410+                let unrealizedPnl = $t01497515074._2
411+                if ((oldPositionNotional > openNotional))
412+                    then {
413+                        let $t01513615395 = swapInput(isAdd, openNotional)
414+                        let exchangedPositionSize = $t01513615395._1
415+                        let qtAstRAfter = $t01513615395._2
416+                        let bsAstRAfter = $t01513615395._3
417+                        let baseAssetDeltaThisFundingPeriodAfter = $t01513615395._4
418+                        let totalPositionSizeAfter = $t01513615395._5
419+                        let cumulativeNotionalAfter = $t01513615395._6
420+                        let exchangedPositionSizeAbs = abs(exchangedPositionSize)
421+                        if (if ((_minBaseAssetAmount != 0))
422+                            then (_minBaseAssetAmount > exchangedPositionSizeAbs)
423+                            else false)
424+                            then throw(((("Too little basse asset exchanged, got " + toString(exchangedPositionSizeAbs)) + " expected ") + toString(_minBaseAssetAmount)))
425+                            else {
426+                                let realizedPnl = if ((oldPositionSize != 0))
427+                                    then divd(muld(unrealizedPnl, exchangedPositionSizeAbs), oldPositionSize)
428+                                    else 0
429+                                let $t01593616207 = calcRemainMarginWithFundingPayment(oldPositionSize, oldPositionMargin, oldPositionLstUpdCPF, realizedPnl)
430+                                let remainMargin = $t01593616207._1
431+                                let badDebt = $t01593616207._2
432+                                let fundingPayment = $t01593616207._3
433+                                let oldLatestCPF = $t01593616207._4
434+                                let exchangedQuoteAssetAmount = openNotional
435+                                let unrealizedPnlAfter = (unrealizedPnl - realizedPnl)
436+                                let remainOpenNotional = if ((oldPositionSize > 0))
437+                                    then ((oldPositionNotional - exchangedQuoteAssetAmount) - unrealizedPnlAfter)
438+                                    else ((unrealizedPnlAfter + oldPositionNotional) - exchangedQuoteAssetAmount)
439+                                $Tuple10((oldPositionSize + exchangedPositionSize), remainMargin, abs(remainOpenNotional), oldLatestCPF, bsAstRAfter, qtAstRAfter, baseAssetDeltaThisFundingPeriodAfter, totalPositionSizeAfter, cumulativeNotionalAfter, (openInteresetNotional() - openNotional))
440+                                }
441+                        }
442+                    else throw("Close position first")
443+                }
444+        let newPositionSize = $t01449117288._1
445+        let newPositionRemainMargin = $t01449117288._2
446+        let newPosiionOpenNotional = $t01449117288._3
447+        let newPositionLatestCPF = $t01449117288._4
448+        let bsAstRAfter = $t01449117288._5
449+        let qtAstRAfter = $t01449117288._6
450+        let baseAssetDeltaThisFundingPeriodAfter = $t01449117288._7
451+        let totalPositionSizeAfter = $t01449117288._8
452+        let cumulativeNotionalAfter = $t01449117288._9
453+        let openInteresetNotionalAfter = $t01449117288._10
454+        (updatePosition(toString(i.caller), newPositionSize, newPositionRemainMargin, newPosiionOpenNotional, newPositionLatestCPF) ++ updateAmm(qtAstRAfter, bsAstRAfter, baseAssetDeltaThisFundingPeriodAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter))
455+        }
456+
457+
458+
459+@Callable(i)
460+func increasePosition (_direction,_leverage,_minBaseAssetAmount) = {
461+    let _rawAmount = i.payments[0].amount
462+    if (if (if (if (if (if (if ((_direction != DIR_LONG))
463+        then (_direction != DIR_SHORT)
464+        else false)
465+        then true
466+        else (0 >= _rawAmount))
467+        then true
468+        else if (((1 * DECIMAL_UNIT) > _leverage))
469+            then true
470+            else (_leverage > (3 * DECIMAL_UNIT)))
471+        then true
472+        else !(initialized()))
473+        then true
474+        else (i.payments[0].assetId != USDN))
475+        then true
476+        else !(requireMoreMarginRatio(divd(DECIMAL_UNIT, _leverage), initMarginRatio(), true)))
477+        then throw("Invalid increasePosition parameters")
478+        else {
479+            let feeAmount = muld(_rawAmount, fee())
480+            let _amount = (_rawAmount - feeAmount)
481+            let $t01827818430 = getPosition(toString(i.caller))
482+            let oldPositionSize = $t01827818430._1
483+            let oldPositionMargin = $t01827818430._2
484+            let oldPositionOpenNotional = $t01827818430._3
485+            let oldPositionLstUpdCPF = $t01827818430._4
486+            let isNewPosition = (oldPositionSize == 0)
487+            let isSameDirection = if ((oldPositionSize > 0))
488+                then (_direction == DIR_LONG)
489+                else (_direction == DIR_SHORT)
490+            let expandExisting = if (!(isNewPosition))
491+                then isSameDirection
492+                else false
493+            let isAdd = (_direction == DIR_LONG)
494+            let $t01871920907 = if (if (isNewPosition)
495+                then true
496+                else expandExisting)
497+                then {
498+                    let openNotional = muld(_amount, _leverage)
499+                    let $t01912119352 = swapInput(isAdd, openNotional)
500+                    let amountBaseAssetBought = $t01912119352._1
501+                    let qtAstRAfter = $t01912119352._2
502+                    let bsAstRAfter = $t01912119352._3
503+                    let baseAssetDeltaThisFundingPeriodAfter = $t01912119352._4
504+                    let totalPositionSizeAfter = $t01912119352._5
505+                    let cumulativeNotionalAfter = $t01912119352._6
506+                    if (if ((_minBaseAssetAmount != 0))
507+                        then (_minBaseAssetAmount > abs(amountBaseAssetBought))
508+                        else false)
509+                        then throw(((("Limit error: " + toString(abs(amountBaseAssetBought))) + " < ") + toString(_minBaseAssetAmount)))
510+                        else {
511+                            let newPositionSize = (oldPositionSize + amountBaseAssetBought)
512+                            let increaseMarginRequirement = divd(openNotional, _leverage)
513+                            let $t01973319986 = calcRemainMarginWithFundingPayment(oldPositionSize, oldPositionMargin, oldPositionLstUpdCPF, increaseMarginRequirement)
514+                            let remainMargin = $t01973319986._1
515+                            let x1 = $t01973319986._2
516+                            let x2 = $t01973319986._3
517+                            let oldLatestCPF = $t01973319986._4
518+                            $Tuple10(newPositionSize, remainMargin, (oldPositionOpenNotional + openNotional), oldLatestCPF, bsAstRAfter, qtAstRAfter, baseAssetDeltaThisFundingPeriodAfter, totalPositionSizeAfter, cumulativeNotionalAfter, (openInteresetNotional() + openNotional))
519+                            }
520+                    }
521+                else {
522+                    let openNotional = muld(_amount, _leverage)
523+                    let $t02061720716 = getPositionNotionalAndUnrealizedPnl(toString(i.caller))
524+                    let oldPositionNotional = $t02061720716._1
525+                    let unrealizedPnl = $t02061720716._2
526+                    if ((oldPositionNotional > openNotional))
527+                        then throw("Use decreasePosition to decrease position size")
528+                        else throw("Close position first")
529+                    }
530+            let newPositionSize = $t01871920907._1
531+            let newPositionRemainMargin = $t01871920907._2
532+            let newPosiionOpenNotional = $t01871920907._3
533+            let newPositionLatestCPF = $t01871920907._4
534+            let bsAstRAfter = $t01871920907._5
535+            let qtAstRAfter = $t01871920907._6
536+            let baseAssetDeltaThisFundingPeriodAfter = $t01871920907._7
537+            let totalPositionSizeAfter = $t01871920907._8
538+            let cumulativeNotionalAfter = $t01871920907._9
539+            let openInteresetNotionalAfter = $t01871920907._10
540+            let stake = invoke(USDN_STAKING, "lockNeutrino", nil, [AttachedPayment(USDN, _amount)])
541+            if ((stake == stake))
542+                then (((updatePosition(toString(i.caller), newPositionSize, newPositionRemainMargin, newPosiionOpenNotional, newPositionLatestCPF) ++ updateAmm(qtAstRAfter, bsAstRAfter, baseAssetDeltaThisFundingPeriodAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter)) ++ transferFee(feeAmount)) ++ upblc((cbalance() + _amount)))
543+                else throw("Strict value is not equal to itself.")
544+            }
545+    }
546+
547+
548+
549+@Callable(i)
550+func addMargin () = {
551+    let _rawAmount = i.payments[0].amount
552+    if (if ((i.payments[0].assetId != USDN))
553+        then true
554+        else !(requireOpenPosition(toString(i.caller))))
555+        then throw("Invalid addMargin parameters")
556+        else {
557+            let feeAmount = muld(_rawAmount, fee())
558+            let _amount = (_rawAmount - feeAmount)
559+            let $t02180921961 = getPosition(toString(i.caller))
560+            let oldPositionSize = $t02180921961._1
561+            let oldPositionMargin = $t02180921961._2
562+            let oldPositionOpenNotional = $t02180921961._3
563+            let oldPositionLstUpdCPF = $t02180921961._4
564+            let stake = invoke(USDN_STAKING, "lockNeutrino", nil, [AttachedPayment(USDN, _amount)])
565+            if ((stake == stake))
566+                then ((updatePosition(toString(i.caller), oldPositionSize, (oldPositionMargin + i.payments[0].amount), oldPositionOpenNotional, oldPositionLstUpdCPF) ++ transferFee(feeAmount)) ++ upblc((cbalance() + _amount)))
567+                else throw("Strict value is not equal to itself.")
568+            }
569+    }
570+
571+
572+
573+@Callable(i)
574+func removeMargin (_amount) = if (if ((0 >= _amount))
575+    then true
576+    else !(requireOpenPosition(toString(i.caller))))
577+    then throw("Invalid removeMargin parameters")
578+    else {
579+        let $t02254722699 = getPosition(toString(i.caller))
580+        let oldPositionSize = $t02254722699._1
581+        let oldPositionMargin = $t02254722699._2
582+        let oldPositionOpenNotional = $t02254722699._3
583+        let oldPositionLstUpdCPF = $t02254722699._4
584+        let marginDelta = -(_amount)
585+        let $t02273622931 = calcRemainMarginWithFundingPayment(oldPositionSize, oldPositionMargin, oldPositionLstUpdCPF, marginDelta)
586+        let remainMargin = $t02273622931._1
587+        let badDebt = $t02273622931._2
588+        let x1 = $t02273622931._3
589+        let latestCPF1 = $t02273622931._4
590+        if ((badDebt != 0))
591+            then throw("Invalid added margin amount")
592+            else {
593+                let unstake = invoke(USDN_STAKING, "unlockNeutrino", [_amount, toBase58String(USDN)], nil)
594+                if ((unstake == unstake))
595+                    then ((updatePosition(toString(i.caller), oldPositionSize, remainMargin, oldPositionOpenNotional, latestCPF1) ++ withdraw(i.caller, _amount)) ++ upblc((cbalance() - _amount)))
596+                    else throw("Strict value is not equal to itself.")
597+                }
598+        }
599+
600+
601+
602+@Callable(i)
603+func closePosition () = if (!(requireOpenPosition(toString(i.caller))))
604+    then throw("Invalid closePosition parameters")
605+    else {
606+        let $t02358123929 = internalClosePosition(toString(i.caller))
607+        let x1 = $t02358123929._1
608+        let badDebt = $t02358123929._2
609+        let realizedPnl = $t02358123929._3
610+        let marginToVault = $t02358123929._4
611+        let quoteAssetReserveAfter = $t02358123929._5
612+        let bsAstRAfter = $t02358123929._6
613+        let baseAssetDeltaThisFundingPeriodAfter = $t02358123929._7
614+        let totalPositionSizeAfter = $t02358123929._8
615+        let cumulativeNotionalAfter = $t02358123929._9
616+        let openInteresetNotionalAfter = $t02358123929._10
617+        if ((badDebt > 0))
618+            then throw("Unable to close position with bad debt")
619+            else {
620+                let withdrawAmount = abs(marginToVault)
621+                let unstake = invoke(USDN_STAKING, "unlockNeutrino", [withdrawAmount, toBase58String(USDN)], nil)
622+                if ((unstake == unstake))
623+                    then {
624+                        let bd = (cbalance() - withdrawAmount)
625+                        let $t02426824385 = if ((0 > bd))
626+                            then $Tuple2(0, (insurance() - abs(bd)))
627+                            else $Tuple2(bd, insurance())
628+                        let nb = $t02426824385._1
629+                        let ni = $t02426824385._2
630+                        ((((deletePosition(toString(i.caller)) ++ updateAmm(quoteAssetReserveAfter, bsAstRAfter, baseAssetDeltaThisFundingPeriodAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter)) ++ withdraw(i.caller, withdrawAmount)) ++ upblc(nb)) ++ updateInsr(ni))
631+                        }
632+                    else throw("Strict value is not equal to itself.")
633+                }
634+        }
635+
636+
637+
638+@Callable(i)
639+func liquidate (_trader) = if (if (!(requireMoreMarginRatio(getMarginRatio(_trader), mmr(), false)))
640+    then true
641+    else !(initialized()))
642+    then throw("Unable to liquidate")
643+    else {
644+        let $t02498525305 = internalClosePosition(_trader)
645+        let x1 = $t02498525305._1
646+        let badDebt = $t02498525305._2
647+        let x2 = $t02498525305._3
648+        let marginToVault = $t02498525305._4
649+        let quoteAssetReserveAfter = $t02498525305._5
650+        let bsAstRAfter = $t02498525305._6
651+        let baseAssetDeltaThisFundingPeriodAfter = $t02498525305._7
652+        let totalPositionSizeAfter = $t02498525305._8
653+        let cumulativeNotionalAfter = $t02498525305._9
654+        let openInteresetNotionalAfter = $t02498525305._10
655+        let exchangedQuoteAssetAmount = $t02498525305._11
656+        let feeToLiquidator = (muld(exchangedQuoteAssetAmount, liquidationFeeRatio()) / 2)
657+        let $t02539525799 = if ((feeToLiquidator > marginToVault))
658+            then $Tuple3((feeToLiquidator - marginToVault), marginToVault, ((badDebt + feeToLiquidator) - marginToVault))
659+            else $Tuple3(0, (marginToVault - feeToLiquidator), badDebt)
660+        let liquidationBadDebt = $t02539525799._1
661+        let remainMargin = $t02539525799._2
662+        let totalBadDebt = $t02539525799._3
663+        ((deletePosition(_trader) ++ updateAmm(quoteAssetReserveAfter, bsAstRAfter, baseAssetDeltaThisFundingPeriodAfter, totalPositionSizeAfter, cumulativeNotionalAfter, openInteresetNotionalAfter)) ++ withdraw(i.caller, feeToLiquidator))
664+        }
665+
666+
667+
668+@Callable(i)
669+func payFunding () = {
670+    let fundingBlockTimestamp = nextFundingBlockTimestamp()
671+    if (if ((fundingBlockTimestamp > lastBlock.timestamp))
672+        then true
673+        else !(initialized()))
674+        then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(fundingBlockTimestamp)))
675+        else {
676+            let underlyingPrice = getOracleTwapPrice()
677+            let spotTwapPrice = getTwapSpotPrice()
678+            let premium = (spotTwapPrice - underlyingPrice)
679+            let premiumFraction = divd(muld(premium, fundingPeriodDecimal()), ONE_DAY)
680+            let totalTraderPositionSize = totalPositionSize()
681+            let ammFundingPaymentProfit = muld(premiumFraction, totalTraderPositionSize)
682+            let fundDelta = abs(ammFundingPaymentProfit)
683+            if ((0 > ammFundingPaymentProfit))
684+                then (updateInsr((insurance() - fundDelta)) ++ upblc((cbalance() + fundDelta)))
685+                else ((updateInsr((insurance() + fundDelta)) ++ upblc((cbalance() - fundDelta))) ++ updateFunding(0, (fundingBlockTimestamp + fundingPeriodSeconds()), (latestCPF() + premiumFraction), divd(premiumFraction, underlyingPrice)))
686+            }
687+    }
688+
689+
690+
691+@Callable(i)
692+func addInsrFunds () = {
693+    let _amount = i.payments[0].amount
694+    if (if (if (!(initialized()))
695+        then true
696+        else (i.payments[0].assetId != USDN))
697+        then true
698+        else (i.caller != ADMIN_ADDRESS))
699+        then throw("")
700+        else {
701+            let stake = invoke(USDN_STAKING, "lockNeutrino", nil, [AttachedPayment(USDN, _amount)])
702+            if ((stake == stake))
703+                then updateInsr((insurance() + _amount))
704+                else throw("Strict value is not equal to itself.")
705+            }
706+    }
707+
708+
709+
710+@Callable(i)
711+func withdrawInsrFunds (_amount) = if (if (if (!(initialized()))
712+    then true
713+    else (_amount > insurance()))
714+    then true
715+    else (i.caller != ADMIN_ADDRESS))
716+    then throw("")
717+    else {
718+        let unstake = invoke(USDN_STAKING, "unlockNeutrino", [_amount, toBase58String(USDN)], nil)
719+        if ((unstake == unstake))
720+            then (updateInsr((insurance() - _amount)) ++ withdraw(i.caller, _amount))
721+            else throw("Strict value is not equal to itself.")
722+        }
723+
724+
725+@Verifier(tx)
726+func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], ADMIN_PUBLIC_KEY)
727+
github/deemru/w8io/169f3d6 
33.82 ms ◑