tx · BnEHqRpyvpHv4H1kSNY7SmL3rsh2ZjTzQbjSEDsDJKtc

3MrjWA3xSUvnRen63fkm67BEmGpgiZzqiLB:  -0.03200000 Waves

2022.05.23 19:30 [2064574] smart account 3MrjWA3xSUvnRen63fkm67BEmGpgiZzqiLB > SELF 0.00000000 Waves

{ "type": 13, "id": "BnEHqRpyvpHv4H1kSNY7SmL3rsh2ZjTzQbjSEDsDJKtc", "fee": 3200000, "feeAssetId": null, "timestamp": 1653323437359, "version": 2, "chainId": 84, "sender": "3MrjWA3xSUvnRen63fkm67BEmGpgiZzqiLB", "senderPublicKey": "4omkCqBwPGSrV7j13D7iYXe1X7XymSuebyBnwaSPUWyz", "proofs": [ "5w8H4m9NuBgycdQTpYbc1qrJZboRabBZhMo4oFMZsrcqh4uE4sLrwM93Lhe4PVUxbF2xF2fNT1nYvr1iWz5EXCg" ], "script": "base64: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", "height": 2064574, "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'3N2k5AsoftpuadZquyYj5KUmrrMLy1pfEbs')
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'3N4Y3Haaj4crmm3VAmcZrcFYyDR4MaMEUww')
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 _marginRatio=" + toString(_marginRatio)) + " _baseMarginRatio=") + toString(_baseMarginRatio)) + " remainingMarginRatio=") + toString(remainingMarginRatio)))
92+ else if (if (!(_largerThanOrEqualTo))
93+ then (remainingMarginRatio >= 0)
94+ else false)
95+ then throw(((((("Invalid margin marginRatio=" + toString(_marginRatio)) + " baseMarginRatio=") + toString(_baseMarginRatio)) + " remainingMarginRatio=") + toString(remainingMarginRatio)))
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 $t042954406 = getPosition(_trader)
164+ let positionSize = $t042954406._1
165+ let positionMargin = $t042954406._2
166+ let pon = $t042954406._3
167+ let positionLstUpdCPF = $t042954406._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 $t056945908 = updateReserve(_isAdd, _quoteAssetAmoun, amountBaseAssetBoughtAbs)
195+ let qtAstRAfter1 = $t056945908._1
196+ let bsAstRAfter1 = $t056945908._2
197+ let baseAssetDeltaThisFundingPeriodAfter1 = $t056945908._3
198+ let totalPositionSizeAfter1 = $t056945908._4
199+ let cumulativeNotionalAfter1 = $t056945908._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 $t064986625 = if ((0 > signedMargin))
211+ then $Tuple2(0, abs(signedMargin))
212+ else $Tuple2(abs(signedMargin), 0)
213+ let remainMargin = $t064986625._1
214+ let badDebt = $t064986625._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 $t072747489 = updateReserve(!(_add), quoteAssetSold, _baseAssetAmount)
229+ let qtAstRAfter1 = $t072747489._1
230+ let bsAstRAfter1 = $t072747489._2
231+ let baseAssetDeltaThisFundingPeriodAfter1 = $t072747489._3
232+ let totalPositionSizeAfter1 = $t072747489._4
233+ let cumulativeNotionalAfter1 = $t072747489._5
234+ $Tuple6(quoteAssetSold, qtAstRAfter1, bsAstRAfter1, baseAssetDeltaThisFundingPeriodAfter1, totalPositionSizeAfter1, cumulativeNotionalAfter1)
235+ }
236+
237+
238+func getPositionNotionalAndUnrealizedPnl (_trader) = {
239+ let $t077437854 = getPosition(_trader)
240+ let positionSize = $t077437854._1
241+ let positionMargin = $t077437854._2
242+ let pon = $t077437854._3
243+ let positionLstUpdCPF = $t077437854._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 $t080318181 = getOutputPriceWithReserves(!(isShort), positionSizeAbs, qtAstR(), bsAstR())
250+ let positionNotional = $t080318181._1
251+ let x1 = $t080318181._2
252+ let x2 = $t080318181._3
253+ let x3 = $t080318181._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 $t085618672 = getPosition(_trader)
270+ let positionSize = $t085618672._1
271+ let positionMargin = $t085618672._2
272+ let pon = $t085618672._3
273+ let positionLstUpdCPF = $t085618672._4
274+ let $t086788762 = getPositionNotionalAndUnrealizedPnl(_trader)
275+ let positionNotional = $t086788762._1
276+ let unrealizedPnl = $t086788762._2
277+ let $t087678933 = calcRemainMarginWithFundingPayment(positionSize, positionMargin, positionLstUpdCPF, unrealizedPnl)
278+ let remainMargin = $t087678933._1
279+ let badDebt = $t087678933._2
280+ divd((remainMargin - badDebt), positionNotional)
281+ }
282+
283+
284+func internalClosePosition (_trader) = {
285+ let $t090409151 = getPosition(_trader)
286+ let positionSize = $t090409151._1
287+ let positionMargin = $t090409151._2
288+ let pon = $t090409151._3
289+ let positionLstUpdCPF = $t090409151._4
290+ let $t091579227 = getPositionNotionalAndUnrealizedPnl(_trader)
291+ let x1 = $t091579227._1
292+ let unrealizedPnl = $t091579227._2
293+ let $t092329404 = calcRemainMarginWithFundingPayment(positionSize, positionMargin, positionLstUpdCPF, unrealizedPnl)
294+ let remainMargin = $t092329404._1
295+ let badDebt = $t092329404._2
296+ let x2 = $t092329404._3
297+ let exchangedPositionSize = -(positionSize)
298+ let realizedPnl = unrealizedPnl
299+ let marginToVault = -(remainMargin)
300+ let $t095319854 = getOutputPriceWithReserves((positionSize > 0), abs(positionSize), qtAstR(), bsAstR())
301+ let exchangedQuoteAssetAmount = $t095319854._1
302+ let quoteAssetReserveAfter = $t095319854._2
303+ let bsAstRAfter = $t095319854._3
304+ let baseAssetDeltaThisFundingPeriodAfter = $t095319854._4
305+ let totalPositionSizeAfter = $t095319854._5
306+ let cumulativeNotionalAfter = $t095319854._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 $t01425514407 = getPosition(toString(i.caller))
384+ let oldPositionSize = $t01425514407._1
385+ let oldPositionMargin = $t01425514407._2
386+ let oldPositionOpenNotional = $t01425514407._3
387+ let oldPositionLstUpdCPF = $t01425514407._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 $t01469617493 = 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 $t01518015279 = getPositionNotionalAndUnrealizedPnl(toString(i.caller))
403+ let oldPositionNotional = $t01518015279._1
404+ let unrealizedPnl = $t01518015279._2
405+ if ((oldPositionNotional > openNotional))
406+ then {
407+ let $t01534115600 = swapInput(isAdd, openNotional)
408+ let exchangedPositionSize = $t01534115600._1
409+ let qtAstRAfter = $t01534115600._2
410+ let bsAstRAfter = $t01534115600._3
411+ let baseAssetDeltaThisFundingPeriodAfter = $t01534115600._4
412+ let totalPositionSizeAfter = $t01534115600._5
413+ let cumulativeNotionalAfter = $t01534115600._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 $t01614116412 = calcRemainMarginWithFundingPayment(oldPositionSize, oldPositionMargin, oldPositionLstUpdCPF, realizedPnl)
424+ let remainMargin = $t01614116412._1
425+ let badDebt = $t01614116412._2
426+ let fundingPayment = $t01614116412._3
427+ let oldLatestCPF = $t01614116412._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 = $t01469617493._1
439+ let newPositionRemainMargin = $t01469617493._2
440+ let newPosiionOpenNotional = $t01469617493._3
441+ let newPositionLatestCPF = $t01469617493._4
442+ let bsAstRAfter = $t01469617493._5
443+ let qtAstRAfter = $t01469617493._6
444+ let baseAssetDeltaThisFundingPeriodAfter = $t01469617493._7
445+ let totalPositionSizeAfter = $t01469617493._8
446+ let cumulativeNotionalAfter = $t01469617493._9
447+ let openInteresetNotionalAfter = $t01469617493._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 $t01848318635 = getPosition(toString(i.caller))
476+ let oldPositionSize = $t01848318635._1
477+ let oldPositionMargin = $t01848318635._2
478+ let oldPositionOpenNotional = $t01848318635._3
479+ let oldPositionLstUpdCPF = $t01848318635._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 $t01892421112 = if (if (isNewPosition)
489+ then true
490+ else expandExisting)
491+ then {
492+ let openNotional = muld(_amount, _leverage)
493+ let $t01932619557 = swapInput(isAdd, openNotional)
494+ let amountBaseAssetBought = $t01932619557._1
495+ let qtAstRAfter = $t01932619557._2
496+ let bsAstRAfter = $t01932619557._3
497+ let baseAssetDeltaThisFundingPeriodAfter = $t01932619557._4
498+ let totalPositionSizeAfter = $t01932619557._5
499+ let cumulativeNotionalAfter = $t01932619557._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 $t01993820191 = calcRemainMarginWithFundingPayment(oldPositionSize, oldPositionMargin, oldPositionLstUpdCPF, increaseMarginRequirement)
508+ let remainMargin = $t01993820191._1
509+ let x1 = $t01993820191._2
510+ let x2 = $t01993820191._3
511+ let oldLatestCPF = $t01993820191._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 $t02082220921 = getPositionNotionalAndUnrealizedPnl(toString(i.caller))
518+ let oldPositionNotional = $t02082220921._1
519+ let unrealizedPnl = $t02082220921._2
520+ if ((oldPositionNotional > openNotional))
521+ then throw("Use decreasePosition to decrease position size")
522+ else throw("Close position first")
523+ }
524+ let newPositionSize = $t01892421112._1
525+ let newPositionRemainMargin = $t01892421112._2
526+ let newPosiionOpenNotional = $t01892421112._3
527+ let newPositionLatestCPF = $t01892421112._4
528+ let bsAstRAfter = $t01892421112._5
529+ let qtAstRAfter = $t01892421112._6
530+ let baseAssetDeltaThisFundingPeriodAfter = $t01892421112._7
531+ let totalPositionSizeAfter = $t01892421112._8
532+ let cumulativeNotionalAfter = $t01892421112._9
533+ let openInteresetNotionalAfter = $t01892421112._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 $t02201422166 = getPosition(toString(i.caller))
554+ let oldPositionSize = $t02201422166._1
555+ let oldPositionMargin = $t02201422166._2
556+ let oldPositionOpenNotional = $t02201422166._3
557+ let oldPositionLstUpdCPF = $t02201422166._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 $t02275222904 = getPosition(toString(i.caller))
574+ let oldPositionSize = $t02275222904._1
575+ let oldPositionMargin = $t02275222904._2
576+ let oldPositionOpenNotional = $t02275222904._3
577+ let oldPositionLstUpdCPF = $t02275222904._4
578+ let marginDelta = -(_amount)
579+ let $t02294123136 = calcRemainMarginWithFundingPayment(oldPositionSize, oldPositionMargin, oldPositionLstUpdCPF, marginDelta)
580+ let remainMargin = $t02294123136._1
581+ let badDebt = $t02294123136._2
582+ let x1 = $t02294123136._3
583+ let latestCPF1 = $t02294123136._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 $t02378624134 = internalClosePosition(toString(i.caller))
601+ let x1 = $t02378624134._1
602+ let badDebt = $t02378624134._2
603+ let realizedPnl = $t02378624134._3
604+ let marginToVault = $t02378624134._4
605+ let quoteAssetReserveAfter = $t02378624134._5
606+ let bsAstRAfter = $t02378624134._6
607+ let baseAssetDeltaThisFundingPeriodAfter = $t02378624134._7
608+ let totalPositionSizeAfter = $t02378624134._8
609+ let cumulativeNotionalAfter = $t02378624134._9
610+ let openInteresetNotionalAfter = $t02378624134._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 $t02432724423 = if ((0 > bd))
617+ then $Tuple2(0, abs(bd))
618+ else $Tuple2(bd, 0)
619+ let nb = $t02432724423._1
620+ let fromi = $t02432724423._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 $t02537725697 = internalClosePosition(_trader)
649+ let x1 = $t02537725697._1
650+ let badDebt = $t02537725697._2
651+ let x2 = $t02537725697._3
652+ let marginToVault = $t02537725697._4
653+ let quoteAssetReserveAfter = $t02537725697._5
654+ let bsAstRAfter = $t02537725697._6
655+ let baseAssetDeltaThisFundingPeriodAfter = $t02537725697._7
656+ let totalPositionSizeAfter = $t02537725697._8
657+ let cumulativeNotionalAfter = $t02537725697._9
658+ let openInteresetNotionalAfter = $t02537725697._10
659+ let exchangedQuoteAssetAmount = $t02537725697._11
660+ let feeToLiquidator = (muld(exchangedQuoteAssetAmount, liquidationFeeRatio()) / 2)
661+ let $t02578726191 = if ((feeToLiquidator > marginToVault))
662+ then $Tuple3((feeToLiquidator - marginToVault), marginToVault, ((badDebt + feeToLiquidator) - marginToVault))
663+ else $Tuple3(0, (marginToVault - feeToLiquidator), badDebt)
664+ let liquidationBadDebt = $t02578726191._1
665+ let remainMargin = $t02578726191._2
666+ let totalBadDebt = $t02578726191._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 
41.37 ms