tx · CHFE2WYdEr5iiKUshHTcGLXgwSPyj7fnJgnivf6td3Qy

3N3tT5Kyp9orgzLHoNh6mS2e6nQSL3jHLw5:  -0.03100000 Waves

2022.05.23 14:27 [2064275] smart account 3N3tT5Kyp9orgzLHoNh6mS2e6nQSL3jHLw5 > SELF 0.00000000 Waves

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