w8 · tx · HqA···WLf

tx · HqADTGxJGACF4dqaSCq12uVTgKQ3Y2xdfeaFQ2H4wWLf

3MuAyo3UDyRW1uGJYpgNwKJx4rGPEQdHetK:  -0.02000000 Waves

2022.02.24 18:53 [1937940] smart account 3MuAyo3UDyRW1uGJYpgNwKJx4rGPEQdHetK > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HqADTGxJGACF4dqaSCq12uVTgKQ3Y2xdfeaFQ2H4wWLf",
    "fee": 2000000,
    "feeAssetId": null,
    "timestamp": 1645718074351,
    "version": 1,
    "sender": "3MuAyo3UDyRW1uGJYpgNwKJx4rGPEQdHetK",
    "senderPublicKey": "8JFUsgTkU5xXsm3gJYTdzsJwYfzBYbZsW7bgR1SYLmas",
    "proofs": [
        "3Ypfnagh3NtXkJcsxyGRD3rdQtAnRaQmX24tTfE5vTzmoKDdeNuuk4tSbHnysbJUnNEutwVtdoha7cCr8nEoYzJR"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1937940,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: FyumErw8Wsrd67D2tSNCPZfTZeLanj1o2TYu6DT4v4gB
Next: ACrKzQCW7PBnqiFodpeh1qCEn4x7mGxBPSwLqk4DWVD1

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

Old	New		Differences
26	26		let scale6 = 1000000
27	27
28	28		let scale6BigInt = toBigInt(1000000)
	29	+
	30	+	let scale8BigInt = toBigInt(100000000)
29	31
30	32		func keyNeutrinoAddress () = "%s%s__config__neutrinoAddress"
31	33

170	172		let usdnSwapDelayDuration = valueOrErrorMessage(getIntegerValue(this, keySwapAmountAParam()), "Swap parameter A missed.")
171	173		let gNsbtAmountBigInt = toBigInt(gNsbtAmount)
172	174		let limitPowPart = pow(gNsbtAmountBigInt, 0, toBigInt(EULERNUMBER), 8, 0, DOWN)
173		-	let limit = fraction(toBigInt(usdnSwapDelayDuration), limitPowPart, ~~scale6BigInt~~)
	175	+	let limit = fraction(toBigInt(usdnSwapDelayDuration), limitPowPart, scale8BigInt)
174	176		$Tuple2(nil, limit)
175	177		}
176	178

276	278		let BR = fraction(reservesInUsdn, PAULI, neutrinoSupply)
277	279		let nsbtSupplyMAX = value(assetInfo(nsbtAssetId)).quantity
278	280		let nsbtSupply = (nsbtSupplyMAX - assetBalance(auctionContract, nsbtAssetId))
279		-	$Tuple2(nil, ~~$Tuple11(~~currentPrice, neutrinoLockedBalance, wavesLockedBalance, reserve, reservesInUsdn, neutrinoSupply, surplus, surplusPercent, BR, nsbtSupply, nsbtSupplyMAX))
	281	+	$Tuple2(nil, [currentPrice, neutrinoLockedBalance, wavesLockedBalance, reserve, reservesInUsdn, neutrinoSupply, surplus, surplusPercent, BR, nsbtSupply, nsbtSupplyMAX])
280	282		}
281	283
282	284

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

github/deemru/w8io/873ac7e 
91.01 ms ◑