tx · 8y9dvrUwb2PxxgcaYtahG5yettvGFcUr6RKHFPqkcVB3

3N3c1H3fvDSSGzMNej8nn3WD6cPaG1h6FS5:  -0.01000000 Waves

2022.03.09 23:23 [1956892] smart account 3N3c1H3fvDSSGzMNej8nn3WD6cPaG1h6FS5 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8y9dvrUwb2PxxgcaYtahG5yettvGFcUr6RKHFPqkcVB3",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1646857422615,
    "version": 1,
    "sender": "3N3c1H3fvDSSGzMNej8nn3WD6cPaG1h6FS5",
    "senderPublicKey": "38u2gx8Y1hoynoZDw5oXcparzpr21qh2SuZU9xFReSEi",
    "proofs": [
        "62yigqQ8DzDp3Ct9Mu37ozKswuYMYE6LXHRhs96YNiRgpRbvwm1LfXNbx5mH8e5phs8rEnKM1ehRkm7SxdhQLkK7"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1956892,
    "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 WAVELET = 100000000
5+
6+let PAULI = 1000000
7+
8+let BIGPAULI = toBigInt(1000000)
9+
10+let PRICELET = 1000000
11+
12+let MULT = 100000000
13+
14+let BIGMULT16 = toBigInt(10000000000000000)
15+
16+let MULTSCALE = 8
17+
18+let SCALE16 = 16
19+
20+let SEP = "__"
21+
22+let HALF8 = 50000000
23+
24+let EULERNUMBER = toBigInt(27182818284590452)
25+
26+let scale6 = 1000000
27+
28+let scale6BigInt = toBigInt(1000000)
29+
30+let scale8BigInt = toBigInt(100000000)
31+
32+func keyNeutrinoAddress () = "%s%s__config__neutrinoAddress"
33+
34+
35+func keySwapAmountAParam () = "%s%s__config__swapAParam"
36+
37+
38+func keyNeutrinoAssetId () = "neutrino_asset_id"
39+
40+
41+func keyLiquidationContractAddress () = "liquidation_contract"
42+
43+
44+func keyRPDContract () = "rpd_contract"
45+
46+
47+func keyAuctionContract () = "auction_contract"
48+
49+
50+func keyContolContract () = "control_contract"
51+
52+
53+func keyBondAssetId () = "bond_asset_id"
54+
55+
56+func keyBalanceLocked () = "balance_lock_"
57+
58+
59+func keyWavesLockedBalance () = (keyBalanceLocked() + "waves")
60+
61+
62+func keyNeutrinoLockedBalance () = (keyBalanceLocked() + "neutrino")
63+
64+
65+func keyMinWavesSwapAmount () = "min_waves_swap_amount"
66+
67+
68+func keyMinNeutrinoSwapAmount () = "min_neutrino_swap_amount"
69+
70+
71+func keyWavesOutFeePart () = "wavesOut_swap_feePart"
72+
73+
74+func keyNeutrinoOutFeePart () = "neutrinoOut_swap_feePart"
75+
76+
77+func keyNsbtLockContract () = "%s__nsbtLockContract"
78+
79+
80+func keyQuickSwapLimitDuration () = "%s__quickSwapLimitDuration"
81+
82+
83+func keyUserLastQuickSwapHeight (userAddress) = makeString(["%s%s", "userLastQuickSwapHeight", userAddress], SEP)
84+
85+
86+func keyQuickSwapUserSpentInPeriod (userAddress) = makeString(["%s%s", "quickSwapUserSpentInPeriod", userAddress], SEP)
87+
88+
89+func keyPrice () = "price"
90+
91+
92+func keyHalfLife () = "%s__halfLife"
93+
94+
95+func keyLockParamUserAmount (userAddress) = makeString(["%s%s%s", "paramByUser", userAddress, "amount"], SEP)
96+
97+
98+func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
99+
100+
101+func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
102+
103+
104+func getNumberByKey (address,key) = valueOrElse(getInteger(address, key), 0)
105+
106+
107+func getBoolOrFail (address,key) = valueOrErrorMessage(getBoolean(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
108+
109+
110+func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, PRICELET, price), WAVELET, PAULI)
111+
112+
113+func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, PRICELET), PAULI, WAVELET)
114+
115+
116+func toX16 (origVal,origScaleMult) = fraction(toBigInt(origVal), BIGMULT16, toBigInt(origScaleMult))
117+
118+
119+func fromX16 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), BIGMULT16))
120+
121+
122+func asAnyList (val) = match val {
123+    case valAnyLyst: List[Any] => 
124+        valAnyLyst
125+    case _ => 
126+        throw("fail to cast into List[Any]")
127+}
128+
129+
130+func asInt (val) = match val {
131+    case valInt: Int => 
132+        valInt
133+    case _ => 
134+        throw("fail to cast into Int")
135+}
136+
137+
138+func asString (val) = match val {
139+    case valStr: String => 
140+        valStr
141+    case _ => 
142+        throw("fail to cast into String")
143+}
144+
145+
146+let neutrinoContract = addressFromStringValue(getStringOrFail(this, keyNeutrinoAddress()))
147+
148+let controlContract = addressFromStringValue(getStringOrFail(neutrinoContract, keyContolContract()))
149+
150+let auctionContract = addressFromStringValue(getStringOrFail(neutrinoContract, keyAuctionContract()))
151+
152+let liquidationContract = getStringOrFail(neutrinoContract, keyLiquidationContractAddress())
153+
154+let rpdContract = getStringOrFail(neutrinoContract, keyRPDContract())
155+
156+let nsbtStakingContract = addressFromStringValue(getStringOrFail(this, keyNsbtLockContract()))
157+
158+let neutrinoAssetIdString = getStringOrFail(neutrinoContract, keyNeutrinoAssetId())
159+
160+let neutrinoAssetId = fromBase58String(neutrinoAssetIdString)
161+
162+let nsbtAssetIdStr = getStringValue(neutrinoContract, keyBondAssetId())
163+
164+let nsbtAssetId = fromBase58String(nsbtAssetIdStr)
165+
166+func calcContractNsbtPriceInternal (nsbtSupplyOverride) = {
167+    let nsbtSupplyMAX = value(assetInfo(nsbtAssetId)).quantity
168+    let neutrinoMetrics = asAnyList(invoke(this, "calcNeutinoMetricsMATH", nil, nil))
169+    if ((neutrinoMetrics == neutrinoMetrics))
170+        then {
171+            let nsbtSupply = if ((nsbtSupplyOverride == unit))
172+                then asInt(neutrinoMetrics[9])
173+                else value(nsbtSupplyOverride)
174+            let currentPrice = asInt(neutrinoMetrics[0])
175+            let kCalcArray = asAnyList(invoke(this, "calculateKMATH", [asInt(neutrinoMetrics[4]), asInt(neutrinoMetrics[6]), currentPrice, nsbtSupplyMAX, nsbtSupply], nil))
176+            if ((kCalcArray == kCalcArray))
177+                then {
178+                    let multK = parseBigIntValue(asString(kCalcArray[6]))
179+                    let mK = fromX16(multK, MULT)
180+                    let multStep1 = fraction(nsbtSupplyMAX, MULT, (nsbtSupplyMAX - nsbtSupply))
181+                    let multStep2 = fraction(multStep1, multStep1, MULT)
182+                    let multNsbt2usdnPrice = fraction(mK, multStep2, MULT)
183+                    let nsbt2usdnPrice = fraction(multNsbt2usdnPrice, PAULI, MULT)
184+                    let nsbt2wavesPrice = fraction(nsbt2usdnPrice, PAULI, currentPrice)
185+                    $Tuple2(nil, [nsbt2usdnPrice, nsbt2wavesPrice])
186+                    }
187+                else throw("Strict value is not equal to itself.")
188+            }
189+        else throw("Strict value is not equal to itself.")
190+    }
191+
192+
193+@Callable(i)
194+func constructor (neutrinoAddress,nsbtLockAddress,swapAmountAParam) = if ((i.caller != this))
195+    then throw("not authorized")
196+    else [StringEntry(keyNeutrinoAddress(), neutrinoAddress), StringEntry(keyNsbtLockContract(), nsbtLockAddress), IntegerEntry(keySwapAmountAParam(), swapAmountAParam)]
197+
198+
199+
200+@Callable(i)
201+func calcSwapLimitMATH (gNsbtAmount) = {
202+    let limitParamA = toBigInt(3)
203+    let gNsbtAmountScale16 = toX16(gNsbtAmount, scale6)
204+    let limitPowPart = pow(gNsbtAmountScale16, 16, EULERNUMBER, 16, 8, CEILING)
205+    let limit = fraction(limitParamA, limitPowPart, scale8BigInt)
206+    $Tuple2(nil, toInt(limit))
207+    }
208+
209+
210+
211+@Callable(i)
212+func calculateKMATH (wRaw,uRaw,price,mRaw,sRaw) = {
213+    let EXP = toBigInt(2718281)
214+    let EXPSCALE = 6
215+    let a = valueOrElse(getInteger(auctionContract, "nsbtCurveParam_a"), 3)
216+    let paulB = valueOrElse(getInteger(auctionContract, "nsbtCurveParam_b"), ((3 * PAULI) / 10))
217+    let wReservesInUsdn = convertWavesToNeutrino(wRaw, price)
218+    let multBR = fraction(wReservesInUsdn, MULT, uRaw)
219+    if ((multBR > 10678564816))
220+        then throw("BR > 10678.564816% will overflow exponent")
221+        else {
222+            let multPower = (a * (multBR - MULT))
223+            let multExpInPower = pow(EXP, EXPSCALE, toBigInt(multPower), MULTSCALE, SCALE16, DOWN)
224+            let multK = fraction(toBigInt(paulB), multExpInPower, BIGPAULI)
225+            $Tuple2(nil, [a, paulB, wReservesInUsdn, multBR, multPower, toString(multExpInPower), toString(multK)])
226+            }
227+    }
228+
229+
230+
231+@Callable(i)
232+func curveFunctionMATH (wRaw,uRaw,price,mRaw,sRaw,wavesPayRaw) = {
233+    let kCalcArray = asAnyList(invoke(this, "calculateKMATH", [wRaw, uRaw, price, mRaw, sRaw], nil))
234+    if ((kCalcArray == kCalcArray))
235+        then {
236+            let multK = parseBigIntValue(asString(kCalcArray[6]))
237+            let usdnPay = convertWavesToNeutrino(wavesPayRaw, price)
238+            let bigMaxNsbtSupply = toBigInt(mRaw)
239+            let bigNsbtSupply = toBigInt((mRaw - sRaw))
240+            let step1 = fraction(toBigInt(usdnPay), BIGMULT16, multK)
241+            let step2 = fraction(step1, bigNsbtSupply, bigMaxNsbtSupply)
242+            let step3 = toInt(fraction(bigNsbtSupply, bigMaxNsbtSupply, (step2 + bigMaxNsbtSupply)))
243+            let nsbtAmountRaw = ((mRaw - sRaw) - step3)
244+            $Tuple2(nil, [nsbtAmountRaw, usdnPay, wRaw, uRaw, mRaw, sRaw, asInt(kCalcArray[0]), asInt(kCalcArray[1]), asInt(kCalcArray[2]), price, asInt(kCalcArray[3]), asInt(kCalcArray[4]), kCalcArray[5], kCalcArray[6], toString(step1), toString(step2), step3])
245+            }
246+        else throw("Strict value is not equal to itself.")
247+    }
248+
249+
250+
251+@Callable(i)
252+func calcContractNsbtPriceMATH () = calcContractNsbtPriceInternal(unit)
253+
254+
255+
256+@Callable(i)
257+func calcContractNsbtPriceBySupplyMATH (nsbtSupply) = calcContractNsbtPriceInternal(nsbtSupply)
258+
259+
260+
261+@Callable(i)
262+func calcUserSwapLimitsMATH (userAddressStr) = {
263+    let currentPrice = getIntegerValue(controlContract, keyPrice())
264+    let userGNsbtAmount = valueOrElse(getInteger(nsbtStakingContract, keyLockParamUserAmount(userAddressStr)), 0)
265+    let usdnLmtMax = asInt(invoke(this, "calcSwapLimitMATH", [userGNsbtAmount], nil))
266+    if ((usdnLmtMax == usdnLmtMax))
267+        then {
268+            let quickSwapResetBlocks = getNumberByKey(neutrinoContract, keyQuickSwapLimitDuration())
269+            let lastQuickSwapBlock = valueOrElse(getInteger(neutrinoContract, keyUserLastQuickSwapHeight(userAddressStr)), 0)
270+            let isNewQuickSwapPeriod = ((height - lastQuickSwapBlock) > quickSwapResetBlocks)
271+            let quickSwapUserSpent = if (isNewQuickSwapPeriod)
272+                then 0
273+                else valueOrElse(getInteger(neutrinoContract, keyQuickSwapUserSpentInPeriod(userAddressStr)), 0)
274+            let blcks2LmtReset = if (isNewQuickSwapPeriod)
275+                then 0
276+                else (quickSwapResetBlocks - (height - lastQuickSwapBlock))
277+            let wavesLmtMax = convertNeutrinoToWaves(usdnLmtMax, currentPrice)
278+            $Tuple2(nil, [usdnLmtMax, quickSwapUserSpent, blcks2LmtReset, wavesLmtMax])
279+            }
280+        else throw("Strict value is not equal to itself.")
281+    }
282+
283+
284+
285+@Callable(i)
286+func calcNeutinoMetricsMATH () = {
287+    let currentPrice = getIntegerValue(controlContract, keyPrice())
288+    let neutrinoLockedBalance = valueOrElse(getInteger(neutrinoContract, keyNeutrinoLockedBalance()), 0)
289+    let wavesLockedBalance = valueOrElse(getInteger(neutrinoContract, keyWavesLockedBalance()), 0)
290+    let reserve = (wavesBalance(neutrinoContract).regular - wavesLockedBalance)
291+    let reservesInUsdn = convertWavesToNeutrino(reserve, currentPrice)
292+    let neutrinoSupply = (((neutrinoLockedBalance + value(assetInfo(neutrinoAssetId)).quantity) - assetBalance(neutrinoContract, neutrinoAssetId)) - assetBalance(addressFromStringValue(liquidationContract), neutrinoAssetId))
293+    let surplus = (reservesInUsdn - neutrinoSupply)
294+    let deficit = (neutrinoSupply - reservesInUsdn)
295+    let surplusPercent = if ((neutrinoSupply == 0))
296+        then 0
297+        else (fraction(surplus, PAULI, neutrinoSupply) * 100)
298+    let BR = if ((neutrinoSupply == 0))
299+        then 0
300+        else fraction(reservesInUsdn, PAULI, neutrinoSupply)
301+    let nsbtSupplyMAX = value(assetInfo(nsbtAssetId)).quantity
302+    let nsbtSupply = (nsbtSupplyMAX - assetBalance(auctionContract, nsbtAssetId))
303+    $Tuple2(nil, [currentPrice, neutrinoLockedBalance, wavesLockedBalance, reserve, reservesInUsdn, neutrinoSupply, surplus, surplusPercent, BR, nsbtSupply, nsbtSupplyMAX])
304+    }
305+
306+
307+
308+@Callable(i)
309+func getUnstakeComissionAmountMATH (amount,startHeight) = {
310+    let halfLife = getIntOrFail(nsbtStakingContract, keyHalfLife())
311+    $Tuple2(nil, fraction(amount, pow(2, 0, fraction(-((height - startHeight)), MULT, halfLife), 8, 8, HALFUP), MULT))
312+    }
313+
314+
315+
316+@Callable(i)
317+func mergeStakesMATH (amount1,height1,amount2,height2) = {
318+    let halfLife = getIntOrFail(nsbtStakingContract, keyHalfLife())
319+    let w = fraction(amount2, pow(2, 0, fraction((height2 - height1), MULT, halfLife), 8, 8, HALFUP), MULT)
320+    let v = fraction((amount1 + amount2), MULT, (amount1 + w))
321+    $Tuple2(nil, (height1 + ((HALF8 - (halfLife * log(v, 8, 2, 0, 8, HALFUP))) / MULT)))
322+    }
323+
324+
github/deemru/w8io/873ac7e 
22.05 ms ◑