tx · DxAk21AZnnGhc1mWKDJCv9AGaeXpRhwLb5THFvwZ9s9m

3N2rQ1rjNyiH3kwQbDg2Ycc79fA6Nh3sU9q:  -0.01000000 Waves

2022.05.23 09:32 [2063977] smart account 3N2rQ1rjNyiH3kwQbDg2Ycc79fA6Nh3sU9q > SELF 0.00000000 Waves

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