w8 · tx · 7Dr···SGa

tx · 7DrEHk1pjBMombpzDZAotZFc6SXijc4tWKXUckzTqSGa

3MuAyo3UDyRW1uGJYpgNwKJx4rGPEQdHetK:  -0.02000000 Waves

2022.02.24 20:41 [1938046] smart account 3MuAyo3UDyRW1uGJYpgNwKJx4rGPEQdHetK > SELF 0.00000000 Waves

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

View: original | compacted
Prev: Fed8HpsMqR681T6aWP4qFvtMbb5SRAF96rLDQoYn9gtU
Next: 4LUCuohoifNSU1RLwqx7S4Lam5UPrmKZNzRPgWb9n159

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

Old	New		Differences
203	203		let kCalcArray = asAnyList(invoke(this, "calculateKMATH", [wRaw, uRaw, price, mRaw, sRaw], nil))
204	204		if ((kCalcArray == kCalcArray))
205	205		then {
206		-	let multK = parseBigIntValue(asString(kCalcArray[7]))
	206	+	let multK = parseBigIntValue(asString(kCalcArray[6]))
207	207		let usdnPay = convertWavesToNeutrino(wavesPayRaw, price)
208	208		let bigMaxNsbtSupply = toBigInt(mRaw)
209	209		let bigNsbtSupply = toBigInt((mRaw - sRaw))

211	211		let step2 = fraction(step1, bigNsbtSupply, bigMaxNsbtSupply)
212	212		let step3 = toInt(fraction(bigNsbtSupply, bigMaxNsbtSupply, (step2 + bigMaxNsbtSupply)))
213	213		let nsbtAmountRaw = ((mRaw - sRaw) - step3)
214		-	$Tuple2(nil, [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)])
	214	+	$Tuple2(nil, [nsbtAmountRaw, usdnPay, wRaw, uRaw, mRaw, sRaw, asInt(kCalcArray[0]), asInt(kCalcArray[1]), asInt(kCalcArray[2]), asInt(price), asInt(kCalcArray[3]), asInt(kCalcArray[4]), kCalcArray[5], kCalcArray[6], toString(step1), toString(step2), toString(step3)])
215	215		}
216	216		else throw("Strict value is not equal to itself.")
217	217		}

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

github/deemru/w8io/873ac7e 
67.10 ms ◑