w8 · tx · Dxi···nH6

tx · DxiDNY1rfY5kn5G6HYToZZmKdEjaS2UDcFJBLY72JnH6

3MqQg3GcBjjk5727HxPKgQfqGQwWm6QA2yL:  -0.03300000 Waves

2022.09.06 19:38 [2217515] smart account 3MqQg3GcBjjk5727HxPKgQfqGQwWm6QA2yL > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DxiDNY1rfY5kn5G6HYToZZmKdEjaS2UDcFJBLY72JnH6",
    "fee": 3300000,
    "feeAssetId": null,
    "timestamp": 1662482284400,
    "version": 2,
    "chainId": 84,
    "sender": "3MqQg3GcBjjk5727HxPKgQfqGQwWm6QA2yL",
    "senderPublicKey": "4AhS4PdxdW6j71mgHB4Xq7Eewk1rPdm57kDHAwQTTweK",
    "proofs": [
        "41dzTL5ajqfEm6ozGpoLj7o7XrstSHpmSDdGScnarUw6cUwFgCLDvvzZfTTn5XH5qgdzi5Hb2KZgv6ye7a5jef5Z"
    ],
    "script": "base64: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",
    "height": 2217515,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: EJ3eZimZTcoh46BuCER4W8oFq92pkCzDVXAi8U8uF7Pi

Full: 
Old New Differences
1 - # no script
1 + {-# STDLIB_VERSION 6 #-}
2 + {-# SCRIPT_TYPE ACCOUNT #-}
3 + {-# CONTENT_TYPE DAPP #-}
4 + let PRECISION = 1000000
5 + 
6 + let MAX_A = 1000000
7 + 
8 + let MAX_A_CHANGE = 10
9 + 
10 + let DECIMALS = 6
11 + 
12 + let MIN_RAMP_TIME = (86400 / 60)
13 + 
14 + let version = "3.0.0"
15 + 
16 + let kVersion = "version"
17 + 
18 + let kAssets = "asset_ids"
19 + 
20 + let kAssetBalance = "_balance"
21 + 
22 + let kActive = "active"
23 + 
24 + let kCause = "shutdown_cause"
25 + 
26 + let kShareAssetId = "share_asset_id"
27 + 
28 + let kShareAssetSupply = "share_asset_supply"
29 + 
30 + let kFee = "commission"
31 + 
32 + let kDAppThresholdCoef = "dAppThresholdCoef"
33 + 
34 + let kUSDNAddress = "staking_usdnnsbt_address"
35 + 
36 + let kDiscounts = "discounts"
37 + 
38 + let kDiscountValues = "discount_values"
39 + 
40 + let kUserSwopInGov = "_SWOP_amount"
41 + 
42 + let kFirstHarvest = "first_harvest"
43 + 
44 + let kFirstHarvestHeight = "first_harvest_height"
45 + 
46 + let kShareLimit = "share_limit_on_first_harvest"
47 + 
48 + let kBasePeriod = "base_period"
49 + 
50 + let kPeriodLength = "period_length"
51 + 
52 + let kStartHeight = "start_height"
53 + 
54 + let kAdminPubKey1 = "admin_pub_1"
55 + 
56 + let kAdminPubKey2 = "admin_pub_2"
57 + 
58 + let kAdminPubKey3 = "admin_pub_3"
59 + 
60 + let kAdminInvokePubKey = "admin_invoke_pub"
61 + 
62 + let kMoneyBoxAddress = "money_box_address"
63 + 
64 + let kGovAddress = "governance_address"
65 + 
66 + let kVotingAddress = "voting_address"
67 + 
68 + let kFarmingAddress = "farming_address"
69 + 
70 + let oracle = Address(base58'3NBBWfzZtZtszaXbitTKnrB2xXwv26Bn7H9')
71 + 
72 + func getBase58FromOracle (key) = match getString(oracle, key) {
73 +     case string: String => 
74 +         fromBase58String(string)
75 +     case nothing => 
76 +         throw((key + "is empty"))
77 + }
78 + 
79 + 
80 + let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
81 + 
82 + let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
83 + 
84 + let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
85 + 
86 + let adminPubKeyInvoke = getBase58FromOracle(kAdminInvokePubKey)
87 + 
88 + let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
89 + 
90 + let govAddress = Address(getBase58FromOracle(kGovAddress))
91 + 
92 + let stakingUSDNAddress = Address(getBase58FromOracle(kUSDNAddress))
93 + 
94 + let votingAddress = Address(getBase58FromOracle(kVotingAddress))
95 + 
96 + let farmingAddress = Address(getBase58FromOracle(kFarmingAddress))
97 + 
98 + let capMoneyBoxAddress = Address(base58'3MxXHaGvmKQHH3kNrPBunhve1sDXf7M5RZt')
99 + 
100 + let USDN = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
101 + 
102 + let stakingAssets = [toBase58String(USDN)]
103 + 
104 + let basePeriod = valueOrErrorMessage(getInteger(votingAddress, kBasePeriod), "Empty kBasePeriod")
105 + 
106 + let startHeight = valueOrErrorMessage(getInteger(votingAddress, kStartHeight), "Empty kStartHeight")
107 + 
108 + let periodLength = valueOrErrorMessage(getInteger(votingAddress, kPeriodLength), "Empty kPeriodLength")
109 + 
110 + let firstHarvestEndPeriod = ((basePeriod + ((height - startHeight) / periodLength)) + 3)
111 + 
112 + let active = getBooleanValue(this, kActive)
113 + 
114 + let shareAssetId = fromBase58String(getStringValue(this, kShareAssetId))
115 + 
116 + let shareSupply = getIntegerValue(this, kShareAssetSupply)
117 + 
118 + let feeScale6 = 1000000
119 + 
120 + let fee = getIntegerValue(this, kFee)
121 + 
122 + let feeGovernance = fraction(40, feeScale6, 100)
123 + 
124 + let initial_A = getIntegerValue(this, "initial_A")
125 + 
126 + let future_A = getIntegerValue(this, "future_A")
127 + 
128 + let initial_A_time = valueOrElse(getInteger(this, "initial_A_time"), 0)
129 + 
130 + let future_A_time = valueOrElse(getInteger(this, "future_A_time"), 0)
131 + 
132 + let assetIds = split(getStringValue(this, kAssets), ",")
133 + 
134 + let nCoins = size(assetIds)
135 + 
136 + func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
137 + 
138 + 
139 + func throwIsActive () = throw("DApp is already active")
140 + 
141 + 
142 + func isActive () = if (active)
143 +     then unit
144 +     else throw("DApp is inactive at this moment")
145 + 
146 + 
147 + func isAdminCall (i) = if (containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey))
148 +     then unit
149 +     else throw("Only admin can call this function")
150 + 
151 + 
152 + func isSelfCall (i) = if ((this == i.caller))
153 +     then unit
154 +     else throw("Only contract itself can call this function")
155 + 
156 + 
157 + let big2 = toBigInt(2)
158 + 
159 + let blockTimestamp = height
160 + 
161 + func assert (a) = if (a)
162 +     then false
163 +     else true
164 + 
165 + 
166 + func calculateFeeDiscount (userAddr) = {
167 +     let swopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserSwopInGov)), 0)
168 +     let discountValues = split(getStringValue(oracle, kDiscountValues), ",")
169 +     let discounts = split(getStringValue(oracle, kDiscounts), ",")
170 +     if (if ((swopAmount >= parseIntValue(discountValues[0])))
171 +         then (parseIntValue(discountValues[1]) > swopAmount)
172 +         else false)
173 +         then (feeScale6 - parseIntValue(discounts[0]))
174 +         else if (if ((swopAmount >= parseIntValue(discountValues[1])))
175 +             then (parseIntValue(discountValues[2]) > swopAmount)
176 +             else false)
177 +             then (feeScale6 - parseIntValue(discounts[1]))
178 +             else if (if ((swopAmount >= parseIntValue(discountValues[2])))
179 +                 then (parseIntValue(discountValues[3]) > swopAmount)
180 +                 else false)
181 +                 then (feeScale6 - parseIntValue(discounts[2]))
182 +                 else if (if ((swopAmount >= parseIntValue(discountValues[3])))
183 +                     then (parseIntValue(discountValues[4]) > swopAmount)
184 +                     else false)
185 +                     then (feeScale6 - parseIntValue(discounts[3]))
186 +                     else if ((swopAmount >= parseIntValue(discountValues[4])))
187 +                         then (feeScale6 - parseIntValue(discounts[4]))
188 +                         else feeScale6
189 +     }
190 + 
191 + 
192 + func _A () = {
193 +     let t1 = future_A_time
194 +     let A1 = future_A
195 +     if ((t1 > blockTimestamp))
196 +         then {
197 +             let A0 = initial_A
198 +             let t0 = initial_A_time
199 +             if ((A1 > A0))
200 +                 then (A0 + (((A1 - A0) * (blockTimestamp - t0)) / (t1 - t0)))
201 +                 else (A0 - (((A0 - A1) * (blockTimestamp - t0)) / (t1 - t0)))
202 +             }
203 +         else A1
204 +     }
205 + 
206 + 
207 + func _xp () = {
208 +     func assetBalances (acc,assetId) =     (acc :+ valueOrElse(getInteger(this, (assetId + kAssetBalance)), 0))
209 + 
210 +     let $l = assetIds
211 +     let $s = size($l)
212 +     let $acc0 = nil
213 +     func $f0_1 ($a,$i) =     if (($i >= $s))
214 +         then $a
215 +         else assetBalances($a, $l[$i])
216 + 
217 +     func $f0_2 ($a,$i) =     if (($i >= $s))
218 +         then $a
219 +         else throw("List size exceeds 15")
220 + 
221 +     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
222 +     }
223 + 
224 + 
225 + func _xp_mem (xp) = xp
226 + 
227 + 
228 + func sumList (acc,element) = (acc + element)
229 + 
230 + 
231 + func get_D (xp,amp) = {
232 +     let @ = invoke(this, "D", [xp, amp], nil)
233 +     if ($isInstanceOf(@, "Int"))
234 +         then @
235 +         else throw(($getType(invoke(this, "D", [xp, amp], nil)) + " couldn't be cast to Int"))
236 +     }
237 + 
238 + 
239 + func get_D_internal (xp,amp) = {
240 +     let S = {
241 +         let $l = xp
242 +         let $s = size($l)
243 +         let $acc0 = 0
244 +         func $f0_1 ($a,$i) =         if (($i >= $s))
245 +             then $a
246 +             else sumList($a, $l[$i])
247 + 
248 +         func $f0_2 ($a,$i) =         if (($i >= $s))
249 +             then $a
250 +             else throw("List size exceeds 15")
251 + 
252 +         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
253 +         }
254 +     if ((S == 0))
255 +         then 0
256 +         else {
257 +             let Ann = (amp * nCoins)
258 +             let AnnS = (toBigInt(Ann) * toBigInt(S))
259 +             let Ann1 = toBigInt((Ann - 1))
260 +             func Dproc (acc,i) =             if ((acc._2 == true))
261 +                 then acc
262 +                 else {
263 +                     let Dprev = acc._1
264 +                     func D_PProc (D_P,i) =                     if ((nCoins > i))
265 +                         then ((D_P * Dprev) / (toBigInt(xp[i]) * toBigInt(nCoins)))
266 +                         else D_P
267 + 
268 +                     let D_P = {
269 +                         let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
270 +                         let $s = size($l)
271 +                         let $acc0 = Dprev
272 +                         func $f1_1 ($a,$i) =                         if (($i >= $s))
273 +                             then $a
274 +                             else D_PProc($a, $l[$i])
275 + 
276 +                         func $f1_2 ($a,$i) =                         if (($i >= $s))
277 +                             then $a
278 +                             else throw("List size exceeds 15")
279 + 
280 +                         $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
281 +                         }
282 +                     let D = fraction((AnnS + (toBigInt(nCoins) * D_P)), Dprev, ((Ann1 * Dprev) + (toBigInt((nCoins + 1)) * D_P)))
283 +                     if ((D > Dprev))
284 +                         then if ((1 >= toInt((D - Dprev))))
285 +                             then $Tuple2(D, true)
286 +                             else $Tuple2(D, false)
287 +                         else if ((1 >= toInt((Dprev - D))))
288 +                             then $Tuple2(D, true)
289 +                             else $Tuple2(D, false)
290 +                     }
291 + 
292 +             let $t066756787 = {
293 +                 let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
294 +                 let $s = size($l)
295 +                 let $acc0 = $Tuple2(toBigInt(S), false)
296 +                 func $f1_1 ($a,$i) =                 if (($i >= $s))
297 +                     then $a
298 +                     else Dproc($a, $l[$i])
299 + 
300 +                 func $f1_2 ($a,$i) =                 if (($i >= $s))
301 +                     then $a
302 +                     else throw("List size exceeds 15")
303 + 
304 +                 $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
305 +                 }
306 +             let D = $t066756787._1
307 +             let finished = $t066756787._2
308 +             if ((finished == false))
309 +                 then throw(("get_D() not finished with " + toString(D)))
310 +                 else toInt(D)
311 +             }
312 +     }
313 + 
314 + 
315 + func getDMem (xp,amp) = get_D(_xp_mem(xp), amp)
316 + 
317 + 
318 + func getY (in,out,x,xp_) = if (assert((in != out)))
319 +     then throw("same coin")
320 +     else if (assert(if ((out >= 0))
321 +         then (in >= 0)
322 +         else false))
323 +         then throw("below zero")
324 +         else if (assert(if ((nCoins > out))
325 +             then (nCoins > in)
326 +             else false))
327 +             then throw("above N_COINS")
328 +             else {
329 +                 let amp = _A()
330 +                 let D = get_D(xp_, amp)
331 +                 let Ann = (amp * nCoins)
332 +                 func S_c (acc,i) =                 {
333 +                     let $t073587375 = acc
334 +                     let S_ = $t073587375._1
335 +                     let c = $t073587375._2
336 +                     let x_ = if ((in == i))
337 +                         then x
338 +                         else xp_[i]
339 +                     if (if ((i != out))
340 +                         then (nCoins > i)
341 +                         else false)
342 +                         then $Tuple2((S_ + x_), fraction(c, toBigInt(D), toBigInt((x_ * nCoins))))
343 +                         else $Tuple2(S_, c)
344 +                     }
345 + 
346 +                 let $t075837684 = {
347 +                     let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
348 +                     let $s = size($l)
349 +                     let $acc0 = $Tuple2(0, toBigInt(D))
350 +                     func $f0_1 ($a,$i) =                     if (($i >= $s))
351 +                         then $a
352 +                         else S_c($a, $l[$i])
353 + 
354 +                     func $f0_2 ($a,$i) =                     if (($i >= $s))
355 +                         then $a
356 +                         else throw("List size exceeds 15")
357 + 
358 +                     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
359 +                     }
360 +                 let S_ = $t075837684._1
361 +                 let c_ = $t075837684._2
362 +                 let c = fraction(c_, toBigInt(D), toBigInt((Ann * nCoins)))
363 +                 let bD = toBigInt(((S_ + (D / Ann)) - D))
364 +                 func y_proc (acc,_i) =                 if ((acc._2 == true))
365 +                     then acc
366 +                     else {
367 +                         let y_prev = acc._1
368 +                         let y = (((y_prev * y_prev) + c) / ((big2 * y_prev) + bD))
369 +                         if ((y > y_prev))
370 +                             then if ((1 >= toInt((y - y_prev))))
371 +                                 then $Tuple2(y, true)
372 +                                 else $Tuple2(y, false)
373 +                             else if ((1 >= toInt((y_prev - y))))
374 +                                 then $Tuple2(y, true)
375 +                                 else $Tuple2(y, false)
376 +                         }
377 + 
378 +                 let $t081668283 = {
379 +                     let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
380 +                     let $s = size($l)
381 +                     let $acc0 = $Tuple2(toBigInt(D), false)
382 +                     func $f1_1 ($a,$i) =                     if (($i >= $s))
383 +                         then $a
384 +                         else y_proc($a, $l[$i])
385 + 
386 +                     func $f1_2 ($a,$i) =                     if (($i >= $s))
387 +                         then $a
388 +                         else throw("List size exceeds 16")
389 + 
390 +                     $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
391 +                     }
392 +                 let y = $t081668283._1
393 +                 let finished = $t081668283._2
394 +                 if ((finished == false))
395 +                     then throw(("getY() not finished with " + toString(y)))
396 +                     else toInt(y)
397 +                 }
398 + 
399 + 
400 + func get_y_D (A_,in,xp,D) = if (assert((in >= 0)))
401 +     then throw("i below zero")
402 +     else if (assert((nCoins > in)))
403 +         then throw("i above N_COINS")
404 +         else {
405 +             let Ann = (A_ * nCoins)
406 +             func S_c (acc,i) =             {
407 +                 let $t086628679 = acc
408 +                 let S_ = $t086628679._1
409 +                 let c = $t086628679._2
410 +                 let x_ = if (if ((in != i))
411 +                     then (nCoins > i)
412 +                     else false)
413 +                     then xp[i]
414 +                     else 0
415 +                 if (if ((nCoins > i))
416 +                     then (in != i)
417 +                     else false)
418 +                     then $Tuple2((S_ + x_), fraction(c, toBigInt(D), toBigInt((x_ * nCoins))))
419 +                     else $Tuple2(S_, c)
420 +                 }
421 + 
422 +             let $t088999000 = {
423 +                 let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
424 +                 let $s = size($l)
425 +                 let $acc0 = $Tuple2(0, toBigInt(D))
426 +                 func $f0_1 ($a,$i) =                 if (($i >= $s))
427 +                     then $a
428 +                     else S_c($a, $l[$i])
429 + 
430 +                 func $f0_2 ($a,$i) =                 if (($i >= $s))
431 +                     then $a
432 +                     else throw("List size exceeds 15")
433 + 
434 +                 $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
435 +                 }
436 +             let S_ = $t088999000._1
437 +             let c_ = $t088999000._2
438 +             let c = fraction(c_, toBigInt(D), toBigInt((Ann * nCoins)))
439 +             let bD = toBigInt(((S_ + (D / Ann)) - D))
440 +             func y_D_proc (acc,i) =             if ((acc._2 == true))
441 +                 then acc
442 +                 else {
443 +                     let y_prev = acc._1
444 +                     let y = (((y_prev * y_prev) + c) / ((big2 * y_prev) + bD))
445 +                     if ((y > y_prev))
446 +                         then if ((1 >= toInt((y - y_prev))))
447 +                             then $Tuple2(y, true)
448 +                             else $Tuple2(y, false)
449 +                         else if ((1 >= toInt((y_prev - y))))
450 +                             then $Tuple2(y, true)
451 +                             else $Tuple2(y, false)
452 +                     }
453 + 
454 +             let $t094839602 = {
455 +                 let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
456 +                 let $s = size($l)
457 +                 let $acc0 = $Tuple2(toBigInt(D), false)
458 +                 func $f1_1 ($a,$i) =                 if (($i >= $s))
459 +                     then $a
460 +                     else y_D_proc($a, $l[$i])
461 + 
462 +                 func $f1_2 ($a,$i) =                 if (($i >= $s))
463 +                     then $a
464 +                     else throw("List size exceeds 16")
465 + 
466 +                 $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
467 +                 }
468 +             let y = $t094839602._1
469 +             let finished = $t094839602._2
470 +             if ((finished == false))
471 +                 then throw(("get_y_D() not finished with " + toString(y)))
472 +                 else toInt(y)
473 +             }
474 + 
475 + 
476 + func _calcWithdrawOneCoin (xp,_token_amount,i,caller) = {
477 +     let feeDiscount = calculateFeeDiscount(caller)
478 +     let amp = _A()
479 +     let _fee = ((fraction(fee, feeDiscount, feeScale6, CEILING) * nCoins) / (4 * (nCoins - 1)))
480 +     let total_supply = shareSupply
481 +     let D0 = get_D(xp, amp)
482 +     let D1 = (D0 - fraction(_token_amount, D0, total_supply))
483 +     let new_y = get_y_D(amp, i, xp, D1)
484 +     let dy_0 = (xp[i] - new_y)
485 +     func xp_reduced_proc (acc,xp_j) =     {
486 +         let $t01024310272 = acc
487 +         let xp_reduced = $t01024310272._1
488 +         let index = $t01024310272._2
489 +         let dx_expected = if ((index == i))
490 +             then (fraction(xp_j, D1, D0) - new_y)
491 +             else (xp_j - fraction(xp_j, D1, D0))
492 +         $Tuple2((xp_reduced :+ (xp_j - fraction(_fee, dx_expected, feeScale6))), (index + 1))
493 +         }
494 + 
495 +     let $t01053410598 = {
496 +         let $l = xp
497 +         let $s = size($l)
498 +         let $acc0 = $Tuple2(nil, 0)
499 +         func $f0_1 ($a,$i) =         if (($i >= $s))
500 +             then $a
501 +             else xp_reduced_proc($a, $l[$i])
502 + 
503 +         func $f0_2 ($a,$i) =         if (($i >= $s))
504 +             then $a
505 +             else throw("List size exceeds 15")
506 + 
507 +         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
508 +         }
509 +     let xp_reduced = $t01053410598._1
510 +     let index = $t01053410598._2
511 +     let xp_reduced_i = xp_reduced[i]
512 +     let dy = ((xp_reduced_i - get_y_D(amp, i, xp_reduced, D1)) - 1)
513 +     $Tuple2(dy, (dy_0 - dy))
514 +     }
515 + 
516 + 
517 + func getStrAssetId (assetId) = match assetId {
518 +     case id: ByteVector => 
519 +         toBase58String(id)
520 +     case waves: Unit => 
521 +         "WAVES"
522 +     case _ => 
523 +         throw("Match error")
524 + }
525 + 
526 + 
527 + func calcStakingFuncAndAddres (stake,assetId) = if (stake)
528 +     then $Tuple2("lockNeutrino", stakingUSDNAddress)
529 +     else $Tuple2("unlockNeutrino", stakingUSDNAddress)
530 + 
531 + 
532 + func calcStakingParams (stake,amount,assetId) = if (stake)
533 +     then {
534 +         let $t01116211228 = calcStakingFuncAndAddres(stake, assetId)
535 +         let call = $t01116211228._1
536 +         let stakingAddr = $t01116211228._2
537 +         $Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
538 +         }
539 +     else {
540 +         let $t01131411380 = calcStakingFuncAndAddres(stake, assetId)
541 +         let call = $t01131411380._1
542 +         let stakingAddr = $t01131411380._2
543 +         $Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
544 +         }
545 + 
546 + 
547 + func stake (amount,assetIdString) = if (containsElement(stakingAssets, assetIdString))
548 +     then {
549 +         let $t01156711669 = calcStakingParams(true, amount, fromBase58String(assetIdString))
550 +         let call = $t01156711669._1
551 +         let addr = $t01156711669._2
552 +         let params = $t01156711669._3
553 +         let payments = $t01156711669._4
554 +         invoke(addr, call, params, payments)
555 +         }
556 +     else 0
557 + 
558 + 
559 + func unstake (amount,assetIdString) = if (containsElement(stakingAssets, assetIdString))
560 +     then {
561 +         let $t01185411957 = calcStakingParams(false, amount, fromBase58String(assetIdString))
562 +         let call = $t01185411957._1
563 +         let addr = $t01185411957._2
564 +         let params = $t01185411957._3
565 +         let payments = $t01185411957._4
566 +         invoke(addr, call, params, payments)
567 +         }
568 +     else 0
569 + 
570 + 
571 + func stakedAmount (assetId) = {
572 +     let stakedAmountCalculated =     match assetId {
573 +         case aId: ByteVector => 
574 +             if ((aId == USDN))
575 +                 then getInteger(stakingUSDNAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(this)))
576 +                 else 0
577 +         case _: Unit => 
578 +             0
579 +         case _ => 
580 +             throw("Match error")
581 +     }
582 +     match stakedAmountCalculated {
583 +         case i: Int => 
584 +             i
585 +         case _ => 
586 +             0
587 +     }
588 +     }
589 + 
590 + 
591 + func checkSuspicious () = {
592 +     let contractBalances = _xp()
593 +     func checkBalance (acc,assetId) =     {
594 +         let $t01256812593 = acc
595 +         let suspicious = $t01256812593._1
596 +         let i = $t01256812593._2
597 +         if (suspicious)
598 +             then $Tuple2(suspicious, i)
599 +             else {
600 +                 let aBalance = (assetBalance(this, fromBase58String(assetId)) + stakedAmount(fromBase58String(assetId)))
601 +                 if ((contractBalances[i] > aBalance))
602 +                     then $Tuple2(true, i)
603 +                     else $Tuple2(false, (i + 1))
604 +                 }
605 +         }
606 + 
607 +     let $l = assetIds
608 +     let $s = size($l)
609 +     let $acc0 = $Tuple2(false, 0)
610 +     func $f0_1 ($a,$i) =     if (($i >= $s))
611 +         then $a
612 +         else checkBalance($a, $l[$i])
613 + 
614 +     func $f0_2 ($a,$i) =     if (($i >= $s))
615 +         then $a
616 +         else throw("List size exceeds 15")
617 + 
618 +     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
619 +     }
620 + 
621 + 
622 + func suspendSuspicious (i) = suspend(("Suspicious state with asset: " + assetIds[i]))
623 + 
624 + 
625 + func returnPayments (caller,payments) = {
626 +     func parsePayments (acc,payment) =     (acc :+ ScriptTransfer(caller, payment.amount, payment.assetId))
627 + 
628 +     let $l = payments
629 +     let $s = size($l)
630 +     let $acc0 = nil
631 +     func $f0_1 ($a,$i) =     if (($i >= $s))
632 +         then $a
633 +         else parsePayments($a, $l[$i])
634 + 
635 +     func $f0_2 ($a,$i) =     if (($i >= $s))
636 +         then $a
637 +         else throw("List size exceeds 15")
638 + 
639 +     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
640 +     }
641 + 
642 + 
643 + func checkDAppThreshold (newBalances) = {
644 +     let dAppThresholdCoef = valueOrErrorMessage(getInteger(this, kDAppThresholdCoef), "No dAppThresholdCoef key")
645 +     let thresholdScale = 10000
646 +     let maxBalance = max(newBalances)
647 +     let minBalance = min(newBalances)
648 +     let ratio = fraction(maxBalance, thresholdScale, minBalance)
649 +     if ((ratio > (dAppThresholdCoef * thresholdScale)))
650 +         then throw("New balance in assets of the DApp is less than threshold")
651 +         else false
652 +     }
653 + 
654 + 
655 + func checkCoins (assetIds) = {
656 +     let coins = split(assetIds, ",")
657 +     func checkCoin (error,assetId) =     {
658 +         let asset = valueOrErrorMessage(fromBase58String(assetId), ("fromBase58String: " + assetId))
659 +         let decimals = valueOrErrorMessage(assetInfo(asset), ("assetInfo: " + assetId)).decimals
660 +         if ((decimals != DECIMALS))
661 +             then throw("wrong decimals")
662 +             else false
663 +         }
664 + 
665 +     let $l = coins
666 +     let $s = size($l)
667 +     let $acc0 = false
668 +     func $f0_1 ($a,$i) =     if (($i >= $s))
669 +         then $a
670 +         else checkCoin($a, $l[$i])
671 + 
672 +     func $f0_2 ($a,$i) =     if (($i >= $s))
673 +         then $a
674 +         else throw("List size exceeds 15")
675 + 
676 +     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
677 +     }
678 + 
679 + 
680 + @Callable(msg)
681 + func D (xp,amp) = {
682 +     let D = get_D_internal(xp, amp)
683 +     $Tuple2([IntegerEntry("D", D)], D)
684 +     }
685 + 
686 + 
687 + 
688 + @Callable(msg)
689 + func init (assetIds,_A,_dAppThresholdCoef,firstHarvest) = if (!(isDataStorageUntouched(this)))
690 +     then throw("Already initialized")
691 +     else if ((0 >= _A))
692 +         then throw("Amp must be must > 0")
693 +         else if ((0 >= _dAppThresholdCoef))
694 +             then throw("dApp Threshold Coef must be > 0")
695 +             else {
696 +                 let shareName = "s_Multi_USD"
697 +                 let shareDescription = ("ShareToken of SwopFi protocol for MultiStable USD pool at address " + toString(this))
698 +                 let issueToken = Issue(shareName, shareDescription, 0, 6, true)
699 +                 let tokenId = calculateAssetId(issueToken)
700 +                 if (checkCoins(assetIds))
701 +                     then throw()
702 +                     else {
703 +                         let baseEntry = [StringEntry(kVersion, version), StringEntry(kAssets, assetIds), IntegerEntry("initial_A", _A), IntegerEntry("future_A", _A), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_flat")), StringEntry(kShareAssetId, toBase58String(tokenId)), IntegerEntry(kShareAssetSupply, 0), IntegerEntry(kDAppThresholdCoef, _dAppThresholdCoef), BooleanEntry(kActive, true), issueToken]
704 +                         if (firstHarvest)
705 +                             then (baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))])
706 +                             else baseEntry
707 +                         }
708 +                 }
709 + 
710 + 
711 + 
712 + @Callable(msg)
713 + func addLiquidity (minMintAmount,stakeFarming) = valueOrElse(isActive(), {
714 +     let amp = _A()
715 +     let xp = _xp()
716 +     let D0 = if ((shareSupply == 0))
717 +         then 0
718 +         else getDMem(xp, amp)
719 +     let payments = msg.payments
720 +     let paymentsSize = size(payments)
721 +     func validPayments (n) =     if ((paymentsSize > nCoins))
722 +         then throw(("payments size > " + toString(nCoins)))
723 +         else if ((1 > paymentsSize))
724 +             then throw("payments size < 1")
725 +             else if (if ((shareSupply == 0))
726 +                 then (nCoins != paymentsSize)
727 +                 else false)
728 +                 then throw("initial deposit requires all coins")
729 +                 else {
730 +                     func paymantValid (acc,payment) =                     if (containsElement(assetIds, getStrAssetId(payment.assetId)))
731 +                         then true
732 +                         else throw("Invalid asset in payment")
733 + 
734 +                     let $l = payments
735 +                     let $s = size($l)
736 +                     let $acc0 = false
737 +                     func $f0_1 ($a,$i) =                     if (($i >= $s))
738 +                         then $a
739 +                         else paymantValid($a, $l[$i])
740 + 
741 +                     func $f0_2 ($a,$i) =                     if (($i >= $s))
742 +                         then $a
743 +                         else throw("List size exceeds 15")
744 + 
745 +                     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
746 +                     }
747 + 
748 +     if (!(validPayments(paymentsSize)))
749 +         then throw()
750 +         else {
751 +             let suspicious = checkSuspicious()
752 +             if (suspicious._1)
753 +                 then (suspendSuspicious(suspicious._2) ++ returnPayments(msg.caller, payments))
754 +                 else {
755 +                     func parsePayments (acc,assetId) =                     {
756 +                         let $t01690116930 = acc
757 +                         let newBalances = $t01690116930._1
758 +                         let i = $t01690116930._2
759 +                         let j = $t01690116930._3
760 +                         if (if ((paymentsSize > j))
761 +                             then (getStrAssetId(payments[j].assetId) == assetId)
762 +                             else false)
763 +                             then $Tuple3((newBalances :+ (xp[i] + payments[j].amount)), (i + 1), (j + 1))
764 +                             else $Tuple3((newBalances :+ xp[i]), (i + 1), j)
765 +                         }
766 + 
767 +                     let $t01715017236 = {
768 +                         let $l = assetIds
769 +                         let $s = size($l)
770 +                         let $acc0 = $Tuple3(nil, 0, 0)
771 +                         func $f0_1 ($a,$i) =                         if (($i >= $s))
772 +                             then $a
773 +                             else parsePayments($a, $l[$i])
774 + 
775 +                         func $f0_2 ($a,$i) =                         if (($i >= $s))
776 +                             then $a
777 +                             else throw("List size exceeds 15")
778 + 
779 +                         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
780 +                         }
781 +                     let newBalances = $t01715017236._1
782 +                     let k = $t01715017236._2
783 +                     let parsedPayments = $t01715017236._3
784 +                     if ((paymentsSize > parsedPayments))
785 +                         then throw("Incorect payments order")
786 +                         else if (checkDAppThreshold(newBalances))
787 +                             then throw()
788 +                             else {
789 +                                 let D1 = getDMem(newBalances, amp)
790 +                                 if (assert((D1 > D0)))
791 +                                     then throw("D1 > D0")
792 +                                     else {
793 +                                         let feeDiscount = calculateFeeDiscount(msg.caller)
794 +                                         func calcScriptActions (acc,newBalance) =                                         {
795 +                                             let $t01763717678 = acc
796 +                                             let invBalances = $t01763717678._1
797 +                                             let scriptActions = $t01763717678._2
798 +                                             let i = $t01763717678._3
799 +                                             if ((shareSupply > 0))
800 +                                                 then {
801 +                                                     let _fee = ((fraction(fee, feeDiscount, feeScale6, CEILING) * nCoins) / (4 * (nCoins - 1)))
802 +                                                     let fees = {
803 +                                                         let idealBalance = fraction(D1, xp[i], D0)
804 +                                                         let difference = if ((idealBalance > newBalance))
805 +                                                             then (idealBalance - newBalance)
806 +                                                             else (newBalance - idealBalance)
807 +                                                         fraction(_fee, difference, feeScale6)
808 +                                                         }
809 +                                                     let governanceFees = fraction(fees, feeGovernance, feeScale6)
810 +                                                     let finalBalance = (newBalance - fees)
811 +                                                     let invariantBalance = (newBalance - fees)
812 +                                                     let pmt = (newBalance - xp[i])
813 +                                                     let inv = if ((pmt > 0))
814 +                                                         then stake((pmt - fees), assetIds[i])
815 +                                                         else unstake(fees, assetIds[i])
816 +                                                     if ((inv == inv))
817 +                                                         then $Tuple3((invBalances :+ invariantBalance), (scriptActions ++ [ScriptTransfer(capMoneyBoxAddress, (fees - governanceFees), fromBase58String(assetIds[i])), ScriptTransfer(moneyBoxAddress, governanceFees, fromBase58String(assetIds[i])), IntegerEntry((assetIds[i] + kAssetBalance), finalBalance)]), (i + 1))
818 +                                                         else throw("Strict value is not equal to itself.")
819 +                                                     }
820 +                                                 else {
821 +                                                     let inv = stake(newBalance, assetIds[i])
822 +                                                     if ((inv == inv))
823 +                                                         then $Tuple3((invBalances :+ newBalance), (scriptActions :+ IntegerEntry((assetIds[i] + kAssetBalance), newBalance)), (i + 1))
824 +                                                         else throw("Strict value is not equal to itself.")
825 +                                                     }
826 +                                             }
827 + 
828 +                                         let $t01922619314 = {
829 +                                             let $l = newBalances
830 +                                             let $s = size($l)
831 +                                             let $acc0 = $Tuple3(nil, nil, 0)
832 +                                             func $f1_1 ($a,$i) =                                             if (($i >= $s))
833 +                                                 then $a
834 +                                                 else calcScriptActions($a, $l[$i])
835 + 
836 +                                             func $f1_2 ($a,$i) =                                             if (($i >= $s))
837 +                                                 then $a
838 +                                                 else throw("List size exceeds 15")
839 + 
840 +                                             $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
841 +                                             }
842 +                                         let invBalances = $t01922619314._1
843 +                                         let scriptActions = $t01922619314._2
844 +                                         let D2 = getDMem(invBalances, amp)
845 +                                         let mint_amount = if ((shareSupply == 0))
846 +                                             then D1
847 +                                             else fraction(shareSupply, (D2 - D0), D0)
848 +                                         if (assert((mint_amount >= minMintAmount)))
849 +                                             then throw("Slippage screwed you")
850 +                                             else if (stakeFarming)
851 +                                                 then {
852 +                                                     let re = invoke(this, "reissueShare", [mint_amount], nil)
853 +                                                     if ((re == re))
854 +                                                         then {
855 +                                                             let s = invoke(farmingAddress, "lockShareTokens", [toString(this)], [AttachedPayment(shareAssetId, mint_amount)])
856 +                                                             if ((s == s))
857 +                                                                 then (scriptActions :+ IntegerEntry(kShareAssetSupply, (shareSupply + mint_amount)))
858 +                                                                 else throw("Strict value is not equal to itself.")
859 +                                                             }
860 +                                                         else throw("Strict value is not equal to itself.")
861 +                                                     }
862 +                                                 else (scriptActions ++ [Reissue(shareAssetId, mint_amount, true), ScriptTransfer(msg.caller, mint_amount, shareAssetId), IntegerEntry(kShareAssetSupply, (shareSupply + mint_amount))])
863 +                                         }
864 +                                 }
865 +                     }
866 +             }
867 +     })
868 + 
869 + 
870 + 
871 + @Callable(msg)
872 + func reissueShare (amount) = valueOrElse(isSelfCall(msg), [Reissue(shareAssetId, amount, true)])
873 + 
874 + 
875 + 
876 + @Callable(msg)
877 + func getDy (assetFrom,assetTo,dx,userAddress) = {
878 +     let xp = _xp()
879 +     let fromIndex = valueOrErrorMessage(indexOf(assetIds, assetFrom), "unknown token in")
880 +     let toIndex = valueOrErrorMessage(indexOf(assetIds, assetTo), "unknown token out")
881 +     let x = (xp[fromIndex] + dx)
882 +     let y = getY(fromIndex, toIndex, x, xp)
883 +     let dy = ((xp[toIndex] - y) - 1)
884 +     let feeDiscount = calculateFeeDiscount(Address(fromBase58String(userAddress)))
885 +     let _fee = fraction(fraction(fee, feeDiscount, feeScale6, CEILING), dy, feeScale6)
886 +     $Tuple2(nil, $Tuple2((dy - _fee), _fee))
887 +     }
888 + 
889 + 
890 + 
891 + @Callable(msg)
892 + func exchange (tokenOut,min_dy) = valueOrElse(isActive(), if ((size(msg.payments) != 1))
893 +     then throw("size(payments) != 1")
894 +     else {
895 +         let suspicious = checkSuspicious()
896 +         if (suspicious._1)
897 +             then (suspendSuspicious(suspicious._2) ++ returnPayments(msg.caller, msg.payments))
898 +             else {
899 +                 let payment = msg.payments[0]
900 +                 let tokenIn = getStrAssetId(payment.assetId)
901 +                 let tokenOutB58 = fromBase58String(tokenOut)
902 +                 let dx = payment.amount
903 +                 let fromIndex = valueOrErrorMessage(indexOf(assetIds, tokenIn), "unknown token in")
904 +                 let toIndex = valueOrErrorMessage(indexOf(assetIds, tokenOut), "unknown token out")
905 +                 let xp = _xp()
906 +                 let x = (xp[fromIndex] + dx)
907 +                 let y = getY(fromIndex, toIndex, x, xp)
908 +                 let _dy = ((xp[toIndex] - y) - 1)
909 +                 let feeDiscount = calculateFeeDiscount(msg.caller)
910 +                 let _fee = fraction(_dy, fraction(fee, feeDiscount, feeScale6, CEILING), feeScale6)
911 +                 let dy = (_dy - _fee)
912 +                 let governanceFees = fraction(_fee, feeGovernance, feeScale6)
913 +                 if (assert((dy >= min_dy)))
914 +                     then throw("Exchange resulted in fewer coins than expected")
915 +                     else {
916 +                         func makeNewBalances (acc,tokenBalance) =                         {
917 +                             let $t02202622052 = acc
918 +                             let newBalances = $t02202622052._1
919 +                             let i = $t02202622052._2
920 +                             if ((i == fromIndex))
921 +                                 then $Tuple2((newBalances :+ (tokenBalance + dx)), (i + 1))
922 +                                 else if ((i == toIndex))
923 +                                     then $Tuple2((newBalances :+ (tokenBalance - _dy)), (i + 1))
924 +                                     else $Tuple2((newBalances :+ tokenBalance), (i + 1))
925 +                             }
926 + 
927 +                         let $t02230322364 = {
928 +                             let $l = xp
929 +                             let $s = size($l)
930 +                             let $acc0 = $Tuple2(nil, 0)
931 +                             func $f0_1 ($a,$i) =                             if (($i >= $s))
932 +                                 then $a
933 +                                 else makeNewBalances($a, $l[$i])
934 + 
935 +                             func $f0_2 ($a,$i) =                             if (($i >= $s))
936 +                                 then $a
937 +                                 else throw("List size exceeds 15")
938 + 
939 +                             $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
940 +                             }
941 +                         let newBalances = $t02230322364._1
942 +                         let i = $t02230322364._2
943 +                         if (checkDAppThreshold(newBalances))
944 +                             then throw()
945 +                             else {
946 +                                 let s = stake(payment.amount, getStrAssetId(payment.assetId))
947 +                                 if ((s == s))
948 +                                     then {
949 +                                         let us = unstake(_dy, tokenOut)
950 +                                         if ((us == us))
951 +                                             then $Tuple2([IntegerEntry((tokenIn + kAssetBalance), x), IntegerEntry((tokenOut + kAssetBalance), (xp[toIndex] - _dy)), ScriptTransfer(msg.caller, dy, tokenOutB58), ScriptTransfer(moneyBoxAddress, governanceFees, tokenOutB58), ScriptTransfer(capMoneyBoxAddress, (_fee - governanceFees), tokenOutB58)], [dy, tokenOutB58])
952 +                                             else throw("Strict value is not equal to itself.")
953 +                                         }
954 +                                     else throw("Strict value is not equal to itself.")
955 +                                 }
956 +                         }
957 +                 }
958 +         })
959 + 
960 + 
961 + 
962 + @Callable(msg)
963 + func withdraw (minAmounts) = valueOrElse(isActive(), if ((size(msg.payments) != 1))
964 +     then throw("size(payments) != 1")
965 +     else {
966 +         let pmtAmount = msg.payments[0].amount
967 +         let pmtAssetId = msg.payments[0].assetId
968 +         if ((shareAssetId != pmtAssetId))
969 +             then throw("unknown payment token")
970 +             else {
971 +                 let suspicious = checkSuspicious()
972 +                 if (suspicious._1)
973 +                     then (suspendSuspicious(suspicious._2) ++ returnPayments(msg.originCaller, msg.payments))
974 +                     else {
975 +                         func calcScriptActions (acc,balance) =                         {
976 +                             let $t02350523533 = acc
977 +                             let scriptActions = $t02350523533._1
978 +                             let i = $t02350523533._2
979 +                             let wAmount = fraction(balance, pmtAmount, shareSupply)
980 +                             if (assert((wAmount >= minAmounts[i])))
981 +                                 then throw("Withdrawal resulted in fewer coins than expected")
982 +                                 else {
983 +                                     let us = unstake(wAmount, assetIds[i])
984 +                                     if ((us == us))
985 +                                         then $Tuple2((scriptActions ++ [IntegerEntry((assetIds[i] + kAssetBalance), (balance - wAmount)), ScriptTransfer(msg.originCaller, wAmount, fromBase58String(assetIds[i]))]), (i + 1))
986 +                                         else throw("Strict value is not equal to itself.")
987 +                                     }
988 +                             }
989 + 
990 +                         let $t02402324091 = {
991 +                             let $l = _xp()
992 +                             let $s = size($l)
993 +                             let $acc0 = $Tuple2(nil, 0)
994 +                             func $f0_1 ($a,$i) =                             if (($i >= $s))
995 +                                 then $a
996 +                                 else calcScriptActions($a, $l[$i])
997 + 
998 +                             func $f0_2 ($a,$i) =                             if (($i >= $s))
999 +                                 then $a
1000 +                                 else throw("List size exceeds 15")
1001 + 
1002 +                             $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
1003 +                             }
1004 +                         let scriptActions = $t02402324091._1
1005 +                         let i = $t02402324091._2
1006 +                         (scriptActions ++ [Burn(shareAssetId, pmtAmount), IntegerEntry(kShareAssetSupply, (shareSupply - pmtAmount))])
1007 +                         }
1008 +                 }
1009 +         })
1010 + 
1011 + 
1012 + 
1013 + @Callable(msg)
1014 + func withdrawWithUnlock (minAmounts,unlockAmount) = valueOrElse(isActive(), if ((0 >= unlockAmount))
1015 +     then throw("Unlock amount must be positive")
1016 +     else {
1017 +         let suspicious = checkSuspicious()
1018 +         if (suspicious._1)
1019 +             then (suspendSuspicious(suspicious._2) ++ returnPayments(msg.caller, msg.payments))
1020 +             else {
1021 +                 let pmtAmount = if ((size(msg.payments) > 0))
1022 +                     then if ((size(msg.payments) != 1))
1023 +                         then throw("size(payments) != 1")
1024 +                         else {
1025 +                             let pmtAssetId = msg.payments[0].assetId
1026 +                             if ((shareAssetId != pmtAssetId))
1027 +                                 then throw("unknown payment token")
1028 +                                 else msg.payments[0].amount
1029 +                             }
1030 +                     else 0
1031 +                 let unlock = invoke(farmingAddress, "withdrawShareTokens", [toString(this), unlockAmount], nil)
1032 +                 if ((unlock == unlock))
1033 +                     then {
1034 +                         let withdrawAmount = (pmtAmount + unlockAmount)
1035 +                         let inv = invoke(this, "withdraw", [minAmounts], [AttachedPayment(shareAssetId, withdrawAmount)])
1036 +                         if ((inv == inv))
1037 +                             then nil
1038 +                             else throw("Strict value is not equal to itself.")
1039 +                         }
1040 +                     else throw("Strict value is not equal to itself.")
1041 +                 }
1042 +         })
1043 + 
1044 + 
1045 + 
1046 + @Callable(msg)
1047 + func calcWithdrawOneCoin (tokenAmount,tokenOut,user) = {
1048 +     let i = valueOrErrorMessage(indexOf(assetIds, tokenOut), "unknown token out")
1049 +     $Tuple2(nil, _calcWithdrawOneCoin(_xp(), tokenAmount, i, Address(fromBase58String(user)))._1)
1050 +     }
1051 + 
1052 + 
1053 + 
1054 + @Callable(msg)
1055 + func withdrawOneCoin (tokenOut,minAmount) = valueOrElse(isActive(), if ((size(msg.payments) != 1))
1056 +     then throw("size(payments) != 1")
1057 +     else {
1058 +         let suspicious = checkSuspicious()
1059 +         if (suspicious._1)
1060 +             then (suspendSuspicious(suspicious._2) ++ returnPayments(msg.originCaller, msg.payments))
1061 +             else {
1062 +                 let pmtAmount = msg.payments[0].amount
1063 +                 let pmtAssetId = msg.payments[0].assetId
1064 +                 if ((pmtAssetId != shareAssetId))
1065 +                     then throw("unknown token")
1066 +                     else {
1067 +                         let outIndex = valueOrErrorMessage(indexOf(assetIds, tokenOut), "unknown token out")
1068 +                         let xp = _xp()
1069 +                         let $t02600526087 = _calcWithdrawOneCoin(xp, pmtAmount, outIndex, msg.originCaller)
1070 +                         let dy = $t02600526087._1
1071 +                         let dy_fee = $t02600526087._2
1072 +                         if (assert((dy >= minAmount)))
1073 +                             then throw("Not enough coins removed")
1074 +                             else {
1075 +                                 let governanceFees = fraction(dy_fee, feeGovernance, feeScale6)
1076 +                                 let dy_and_fee = (dy + dy_fee)
1077 +                                 func makeNewBalances (acc,tokenBalance) =                                 {
1078 +                                     let $t02634526371 = acc
1079 +                                     let newBalances = $t02634526371._1
1080 +                                     let i = $t02634526371._2
1081 +                                     if ((i == outIndex))
1082 +                                         then $Tuple2((newBalances :+ (tokenBalance - dy_and_fee)), (i + 1))
1083 +                                         else $Tuple2((newBalances :+ tokenBalance), (i + 1))
1084 +                                     }
1085 + 
1086 +                                 let $t02653826599 = {
1087 +                                     let $l = xp
1088 +                                     let $s = size($l)
1089 +                                     let $acc0 = $Tuple2(nil, 0)
1090 +                                     func $f0_1 ($a,$i) =                                     if (($i >= $s))
1091 +                                         then $a
1092 +                                         else makeNewBalances($a, $l[$i])
1093 + 
1094 +                                     func $f0_2 ($a,$i) =                                     if (($i >= $s))
1095 +                                         then $a
1096 +                                         else throw("List size exceeds 15")
1097 + 
1098 +                                     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
1099 +                                     }
1100 +                                 let newBalances = $t02653826599._1
1101 +                                 let v = $t02653826599._2
1102 +                                 if (checkDAppThreshold(newBalances))
1103 +                                     then throw()
1104 +                                     else {
1105 +                                         let us = unstake(dy_and_fee, tokenOut)
1106 +                                         if ((us == us))
1107 +                                             then [ScriptTransfer(msg.originCaller, dy, fromBase58String(tokenOut)), IntegerEntry((assetIds[outIndex] + kAssetBalance), (xp[outIndex] - dy_and_fee)), Burn(shareAssetId, pmtAmount), ScriptTransfer(moneyBoxAddress, governanceFees, fromBase58String(tokenOut)), ScriptTransfer(capMoneyBoxAddress, (dy_fee - governanceFees), fromBase58String(tokenOut)), IntegerEntry(kShareAssetSupply, (shareSupply - pmtAmount))]
1108 +                                             else throw("Strict value is not equal to itself.")
1109 +                                         }
1110 +                                 }
1111 +                         }
1112 +                 }
1113 +         })
1114 + 
1115 + 
1116 + 
1117 + @Callable(msg)
1118 + func withdrawOneCoinWithUnlock (tokenOut,minAmount,unlockAmount) = valueOrElse(isActive(), if ((0 >= unlockAmount))
1119 +     then throw("Unlock amount must be positive")
1120 +     else {
1121 +         let suspicious = checkSuspicious()
1122 +         if (suspicious._1)
1123 +             then (suspendSuspicious(suspicious._2) ++ returnPayments(msg.caller, msg.payments))
1124 +             else {
1125 +                 let pmtAmount = if ((size(msg.payments) > 0))
1126 +                     then if ((size(msg.payments) != 1))
1127 +                         then throw("size(payments) != 1")
1128 +                         else {
1129 +                             let pmtAssetId = msg.payments[0].assetId
1130 +                             if ((shareAssetId != pmtAssetId))
1131 +                                 then throw("unknown payment token")
1132 +                                 else msg.payments[0].amount
1133 +                             }
1134 +                     else 0
1135 +                 let unlock = invoke(farmingAddress, "withdrawShareTokens", [toString(this), unlockAmount], nil)
1136 +                 if ((unlock == unlock))
1137 +                     then {
1138 +                         let withdrawAmount = (pmtAmount + unlockAmount)
1139 +                         let inv = invoke(this, "withdrawOneCoin", [tokenOut, minAmount], [AttachedPayment(shareAssetId, withdrawAmount)])
1140 +                         if ((inv == inv))
1141 +                             then nil
1142 +                             else throw("Strict value is not equal to itself.")
1143 +                         }
1144 +                     else throw("Strict value is not equal to itself.")
1145 +                 }
1146 +         })
1147 + 
1148 + 
1149 + 
1150 + @Callable(msg)
1151 + func A () = $Tuple2(nil, _A())
1152 + 
1153 + 
1154 + 
1155 + @Callable(msg)
1156 + func getVirtualPrice () = {
1157 +     let D = get_D(_xp(), _A())
1158 +     $Tuple2(nil, fraction(D, PRECISION, shareSupply))
1159 +     }
1160 + 
1161 + 
1162 + 
1163 + @Callable(msg)
1164 + func calcTokenAmount (amounts,deposit) = {
1165 +     let amp = _A()
1166 +     let balances = _xp()
1167 +     let D0 = getDMem(balances, amp)
1168 +     func calcNewBalances (acc,balance) =     {
1169 +         let $t02852328549 = acc
1170 +         let newBalances = $t02852328549._1
1171 +         let i = $t02852328549._2
1172 +         let newBalance = (balance + (if (deposit)
1173 +             then amounts[i]
1174 +             else -(amounts[i])))
1175 +         $Tuple2((newBalances :+ newBalance), (i + 1))
1176 +         }
1177 + 
1178 +     let newBalances = (    let $l = balances
1179 +     let $s = size($l)
1180 +     let $acc0 = $Tuple2(nil, 0)
1181 +     func $f0_1 ($a,$i) =     if (($i >= $s))
1182 +         then $a
1183 +         else calcNewBalances($a, $l[$i])
1184 + 
1185 +     func $f0_2 ($a,$i) =     if (($i >= $s))
1186 +         then $a
1187 +         else throw("List size exceeds 15")
1188 + 
1189 +     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15))._1
1190 +     let D1 = getDMem(newBalances, amp)
1191 +     let diff = if (deposit)
1192 +         then (D1 - D0)
1193 +         else (D0 - D1)
1194 +     $Tuple2(nil, fraction(diff, shareSupply, D0))
1195 +     }
1196 + 
1197 + 
1198 + 
1199 + @Callable(msg)
1200 + func rampA (_futureA,_futureTime) = valueOrElse(isActive(), valueOrElse(isAdminCall(msg), if (assert((blockTimestamp >= (initial_A_time + MIN_RAMP_TIME))))
1201 +     then throw("too often")
1202 +     else if (assert((_futureTime >= (blockTimestamp + MIN_RAMP_TIME))))
1203 +         then throw("insufficient time")
1204 +         else {
1205 +             let _initial_A = _A()
1206 +             if (assert(if ((_futureA > 0))
1207 +                 then (MAX_A > _futureA)
1208 +                 else false))
1209 +                 then throw("out of base range")
1210 +                 else if (assert(if (if ((_futureA >= _initial_A))
1211 +                     then ((_initial_A * MAX_A_CHANGE) >= _futureA)
1212 +                     else false)
1213 +                     then true
1214 +                     else if ((_initial_A > _futureA))
1215 +                         then ((_futureA * MAX_A_CHANGE) >= _initial_A)
1216 +                         else false))
1217 +                     then throw("out of range")
1218 +                     else [IntegerEntry("initial_A", _initial_A), IntegerEntry("future_A", _futureA), IntegerEntry("initial_A_time", blockTimestamp), IntegerEntry("future_A_time", _futureTime)]
1219 +             }))
1220 + 
1221 + 
1222 + 
1223 + @Callable(msg)
1224 + func stopRampA () = valueOrElse(isActive(), valueOrElse(isAdminCall(msg), {
1225 +     let currentA = _A()
1226 + [IntegerEntry("initial_A", currentA), IntegerEntry("future_A", currentA), IntegerEntry("initial_A_time", blockTimestamp), IntegerEntry("future_A_time", blockTimestamp)]
1227 +     }))
1228 + 
1229 + 
1230 + 
1231 + @Callable(msg)
1232 + func shutdown () = valueOrElse(isAdminCall(msg), if (!(active))
1233 +     then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, kCause), "the cause wasn't specified")))
1234 +     else suspend("Paused by admin"))
1235 + 
1236 + 
1237 + 
1238 + @Callable(msg)
1239 + func activate () = valueOrElse(isAdminCall(msg), if (active)
1240 +     then throwIsActive()
1241 +     else [BooleanEntry(kActive, true), DeleteEntry(kCause)])
1242 + 
1243 + 
1244 + 
1245 + @Callable(msg)
1246 + func keepLimitForFirstHarvest (shareLimit) = valueOrElse(isActive(), valueOrElse(isAdminCall(msg), [IntegerEntry(kShareLimit, shareLimit)]))
1247 + 
1248 + 
1249 + @Verifier(tx)
1250 + func verify () = {
1251 +     let multiSignedByAdmins = {
1252 +         let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
1253 +             then 1
1254 +             else 0
1255 +         let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
1256 +             then 1
1257 +             else 0
1258 +         let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
1259 +             then 1
1260 +             else 0
1261 +         (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
1262 +         }
1263 +     match tx {
1264 +         case inv: InvokeScriptTransaction => 
1265 +             let callTakeIntoAccount = if ((inv.dApp == this))
1266 +                 then (inv.function == "takeIntoAccountExtraFunds")
1267 +                 else false
1268 +             let signedByAdmin = if (if (if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
1269 +                 then true
1270 +                 else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey2))
1271 +                 then true
1272 +                 else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey3))
1273 +                 then true
1274 +                 else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKeyInvoke)
1275 +             if (if (callTakeIntoAccount)
1276 +                 then signedByAdmin
1277 +                 else false)
1278 +                 then true
1279 +                 else multiSignedByAdmins
1280 +         case _ => 
1281 +             multiSignedByAdmins
1282 +     }
1283 +     }
1284 +

Old	New		Differences
1		-	# no script
	1	+	{-# STDLIB_VERSION 6 #-}
	2	+	{-# SCRIPT_TYPE ACCOUNT #-}
	3	+	{-# CONTENT_TYPE DAPP #-}
	4	+	let PRECISION = 1000000
	5	+
	6	+	let MAX_A = 1000000
	7	+
	8	+	let MAX_A_CHANGE = 10
	9	+
	10	+	let DECIMALS = 6
	11	+
	12	+	let MIN_RAMP_TIME = (86400 / 60)
	13	+
	14	+	let version = "3.0.0"
	15	+
	16	+	let kVersion = "version"
	17	+
	18	+	let kAssets = "asset_ids"
	19	+
	20	+	let kAssetBalance = "_balance"
	21	+
	22	+	let kActive = "active"
	23	+
	24	+	let kCause = "shutdown_cause"
	25	+
	26	+	let kShareAssetId = "share_asset_id"
	27	+
	28	+	let kShareAssetSupply = "share_asset_supply"
	29	+
	30	+	let kFee = "commission"
	31	+
	32	+	let kDAppThresholdCoef = "dAppThresholdCoef"
	33	+
	34	+	let kUSDNAddress = "staking_usdnnsbt_address"
	35	+
	36	+	let kDiscounts = "discounts"
	37	+
	38	+	let kDiscountValues = "discount_values"
	39	+
	40	+	let kUserSwopInGov = "_SWOP_amount"
	41	+
	42	+	let kFirstHarvest = "first_harvest"
	43	+
	44	+	let kFirstHarvestHeight = "first_harvest_height"
	45	+
	46	+	let kShareLimit = "share_limit_on_first_harvest"
	47	+
	48	+	let kBasePeriod = "base_period"
	49	+
	50	+	let kPeriodLength = "period_length"
	51	+
	52	+	let kStartHeight = "start_height"
	53	+
	54	+	let kAdminPubKey1 = "admin_pub_1"
	55	+
	56	+	let kAdminPubKey2 = "admin_pub_2"
	57	+
	58	+	let kAdminPubKey3 = "admin_pub_3"
	59	+
	60	+	let kAdminInvokePubKey = "admin_invoke_pub"
	61	+
	62	+	let kMoneyBoxAddress = "money_box_address"
	63	+
	64	+	let kGovAddress = "governance_address"
	65	+
	66	+	let kVotingAddress = "voting_address"
	67	+
	68	+	let kFarmingAddress = "farming_address"
	69	+
	70	+	let oracle = Address(base58'3NBBWfzZtZtszaXbitTKnrB2xXwv26Bn7H9')
	71	+
	72	+	func getBase58FromOracle (key) = match getString(oracle, key) {
	73	+	case string: String =>
	74	+	fromBase58String(string)
	75	+	case nothing =>
	76	+	throw((key + "is empty"))
	77	+	}
	78	+
	79	+
	80	+	let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
	81	+
	82	+	let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
	83	+
	84	+	let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
	85	+
	86	+	let adminPubKeyInvoke = getBase58FromOracle(kAdminInvokePubKey)
	87	+
	88	+	let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
	89	+
	90	+	let govAddress = Address(getBase58FromOracle(kGovAddress))
	91	+
	92	+	let stakingUSDNAddress = Address(getBase58FromOracle(kUSDNAddress))
	93	+
	94	+	let votingAddress = Address(getBase58FromOracle(kVotingAddress))
	95	+
	96	+	let farmingAddress = Address(getBase58FromOracle(kFarmingAddress))
	97	+
	98	+	let capMoneyBoxAddress = Address(base58'3MxXHaGvmKQHH3kNrPBunhve1sDXf7M5RZt')
	99	+
	100	+	let USDN = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
	101	+
	102	+	let stakingAssets = [toBase58String(USDN)]
	103	+
	104	+	let basePeriod = valueOrErrorMessage(getInteger(votingAddress, kBasePeriod), "Empty kBasePeriod")
	105	+
	106	+	let startHeight = valueOrErrorMessage(getInteger(votingAddress, kStartHeight), "Empty kStartHeight")
	107	+
	108	+	let periodLength = valueOrErrorMessage(getInteger(votingAddress, kPeriodLength), "Empty kPeriodLength")
	109	+
	110	+	let firstHarvestEndPeriod = ((basePeriod + ((height - startHeight) / periodLength)) + 3)
	111	+
	112	+	let active = getBooleanValue(this, kActive)
	113	+
	114	+	let shareAssetId = fromBase58String(getStringValue(this, kShareAssetId))
	115	+
	116	+	let shareSupply = getIntegerValue(this, kShareAssetSupply)
	117	+
	118	+	let feeScale6 = 1000000
	119	+
	120	+	let fee = getIntegerValue(this, kFee)
	121	+
	122	+	let feeGovernance = fraction(40, feeScale6, 100)
	123	+
	124	+	let initial_A = getIntegerValue(this, "initial_A")
	125	+
	126	+	let future_A = getIntegerValue(this, "future_A")
	127	+
	128	+	let initial_A_time = valueOrElse(getInteger(this, "initial_A_time"), 0)
	129	+
	130	+	let future_A_time = valueOrElse(getInteger(this, "future_A_time"), 0)
	131	+
	132	+	let assetIds = split(getStringValue(this, kAssets), ",")
	133	+
	134	+	let nCoins = size(assetIds)
	135	+
	136	+	func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
	137	+
	138	+
	139	+	func throwIsActive () = throw("DApp is already active")
	140	+
	141	+
	142	+	func isActive () = if (active)
	143	+	then unit
	144	+	else throw("DApp is inactive at this moment")
	145	+
	146	+
	147	+	func isAdminCall (i) = if (containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey))
	148	+	then unit
	149	+	else throw("Only admin can call this function")
	150	+
	151	+
	152	+	func isSelfCall (i) = if ((this == i.caller))
	153	+	then unit
	154	+	else throw("Only contract itself can call this function")
	155	+
	156	+
	157	+	let big2 = toBigInt(2)
	158	+
	159	+	let blockTimestamp = height
	160	+
	161	+	func assert (a) = if (a)
	162	+	then false
	163	+	else true
	164	+
	165	+
	166	+	func calculateFeeDiscount (userAddr) = {
	167	+	let swopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserSwopInGov)), 0)
	168	+	let discountValues = split(getStringValue(oracle, kDiscountValues), ",")
	169	+	let discounts = split(getStringValue(oracle, kDiscounts), ",")
	170	+	if (if ((swopAmount >= parseIntValue(discountValues[0])))
	171	+	then (parseIntValue(discountValues[1]) > swopAmount)
	172	+	else false)
	173	+	then (feeScale6 - parseIntValue(discounts[0]))
	174	+	else if (if ((swopAmount >= parseIntValue(discountValues[1])))
	175	+	then (parseIntValue(discountValues[2]) > swopAmount)
	176	+	else false)
	177	+	then (feeScale6 - parseIntValue(discounts[1]))
	178	+	else if (if ((swopAmount >= parseIntValue(discountValues[2])))
	179	+	then (parseIntValue(discountValues[3]) > swopAmount)
	180	+	else false)
	181	+	then (feeScale6 - parseIntValue(discounts[2]))
	182	+	else if (if ((swopAmount >= parseIntValue(discountValues[3])))
	183	+	then (parseIntValue(discountValues[4]) > swopAmount)
	184	+	else false)
	185	+	then (feeScale6 - parseIntValue(discounts[3]))
	186	+	else if ((swopAmount >= parseIntValue(discountValues[4])))
	187	+	then (feeScale6 - parseIntValue(discounts[4]))
	188	+	else feeScale6
	189	+	}
	190	+
	191	+
	192	+	func _A () = {
	193	+	let t1 = future_A_time
	194	+	let A1 = future_A
	195	+	if ((t1 > blockTimestamp))
	196	+	then {
	197	+	let A0 = initial_A
	198	+	let t0 = initial_A_time
	199	+	if ((A1 > A0))
	200	+	then (A0 + (((A1 - A0) * (blockTimestamp - t0)) / (t1 - t0)))
	201	+	else (A0 - (((A0 - A1) * (blockTimestamp - t0)) / (t1 - t0)))
	202	+	}
	203	+	else A1
	204	+	}
	205	+
	206	+
	207	+	func _xp () = {
	208	+	func assetBalances (acc,assetId) = (acc :+ valueOrElse(getInteger(this, (assetId + kAssetBalance)), 0))
	209	+
	210	+	let $l = assetIds
	211	+	let $s = size($l)
	212	+	let $acc0 = nil
	213	+	func $f0_1 ($a,$i) = if (($i >= $s))
	214	+	then $a
	215	+	else assetBalances($a, $l[$i])
	216	+
	217	+	func $f0_2 ($a,$i) = if (($i >= $s))
	218	+	then $a
	219	+	else throw("List size exceeds 15")
	220	+
	221	+	$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
	222	+	}
	223	+
	224	+
	225	+	func _xp_mem (xp) = xp
	226	+
	227	+
	228	+	func sumList (acc,element) = (acc + element)
	229	+
	230	+
	231	+	func get_D (xp,amp) = {
	232	+	let @ = invoke(this, "D", [xp, amp], nil)
	233	+	if ($isInstanceOf(@, "Int"))
	234	+	then @
	235	+	else throw(($getType(invoke(this, "D", [xp, amp], nil)) + " couldn't be cast to Int"))
	236	+	}
	237	+
	238	+
	239	+	func get_D_internal (xp,amp) = {
	240	+	let S = {
	241	+	let $l = xp
	242	+	let $s = size($l)
	243	+	let $acc0 = 0
	244	+	func $f0_1 ($a,$i) = if (($i >= $s))
	245	+	then $a
	246	+	else sumList($a, $l[$i])
	247	+
	248	+	func $f0_2 ($a,$i) = if (($i >= $s))
	249	+	then $a
	250	+	else throw("List size exceeds 15")
	251	+
	252	+	$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
	253	+	}
	254	+	if ((S == 0))
	255	+	then 0
	256	+	else {
	257	+	let Ann = (amp * nCoins)
	258	+	let AnnS = (toBigInt(Ann) * toBigInt(S))
	259	+	let Ann1 = toBigInt((Ann - 1))
	260	+	func Dproc (acc,i) = if ((acc._2 == true))
	261	+	then acc
	262	+	else {
	263	+	let Dprev = acc._1
	264	+	func D_PProc (D_P,i) = if ((nCoins > i))
	265	+	then ((D_P * Dprev) / (toBigInt(xp[i]) * toBigInt(nCoins)))
	266	+	else D_P
	267	+
	268	+	let D_P = {
	269	+	let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
	270	+	let $s = size($l)
	271	+	let $acc0 = Dprev
	272	+	func $f1_1 ($a,$i) = if (($i >= $s))
	273	+	then $a
	274	+	else D_PProc($a, $l[$i])
	275	+
	276	+	func $f1_2 ($a,$i) = if (($i >= $s))
	277	+	then $a
	278	+	else throw("List size exceeds 15")
	279	+
	280	+	$f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
	281	+	}
	282	+	let D = fraction((AnnS + (toBigInt(nCoins) * D_P)), Dprev, ((Ann1 * Dprev) + (toBigInt((nCoins + 1)) * D_P)))
	283	+	if ((D > Dprev))
	284	+	then if ((1 >= toInt((D - Dprev))))
	285	+	then $Tuple2(D, true)
	286	+	else $Tuple2(D, false)
	287	+	else if ((1 >= toInt((Dprev - D))))
	288	+	then $Tuple2(D, true)
	289	+	else $Tuple2(D, false)
	290	+	}
	291	+
	292	+	let $t066756787 = {
	293	+	let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
	294	+	let $s = size($l)
	295	+	let $acc0 = $Tuple2(toBigInt(S), false)
	296	+	func $f1_1 ($a,$i) = if (($i >= $s))
	297	+	then $a
	298	+	else Dproc($a, $l[$i])
	299	+
	300	+	func $f1_2 ($a,$i) = if (($i >= $s))
	301	+	then $a
	302	+	else throw("List size exceeds 15")
	303	+
	304	+	$f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
	305	+	}
	306	+	let D = $t066756787._1
	307	+	let finished = $t066756787._2
	308	+	if ((finished == false))
	309	+	then throw(("get_D() not finished with " + toString(D)))
	310	+	else toInt(D)
	311	+	}
	312	+	}
	313	+
	314	+
	315	+	func getDMem (xp,amp) = get_D(_xp_mem(xp), amp)
	316	+
	317	+
	318	+	func getY (in,out,x,xp_) = if (assert((in != out)))
	319	+	then throw("same coin")
	320	+	else if (assert(if ((out >= 0))
	321	+	then (in >= 0)
	322	+	else false))
	323	+	then throw("below zero")
	324	+	else if (assert(if ((nCoins > out))
	325	+	then (nCoins > in)
	326	+	else false))
	327	+	then throw("above N_COINS")
	328	+	else {
	329	+	let amp = _A()
	330	+	let D = get_D(xp_, amp)
	331	+	let Ann = (amp * nCoins)
	332	+	func S_c (acc,i) = {
	333	+	let $t073587375 = acc
	334	+	let S_ = $t073587375._1
	335	+	let c = $t073587375._2
	336	+	let x_ = if ((in == i))
	337	+	then x
	338	+	else xp_[i]
	339	+	if (if ((i != out))
	340	+	then (nCoins > i)
	341	+	else false)
	342	+	then $Tuple2((S_ + x_), fraction(c, toBigInt(D), toBigInt((x_ * nCoins))))
	343	+	else $Tuple2(S_, c)
	344	+	}
	345	+
	346	+	let $t075837684 = {
	347	+	let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
	348	+	let $s = size($l)
	349	+	let $acc0 = $Tuple2(0, toBigInt(D))
	350	+	func $f0_1 ($a,$i) = if (($i >= $s))
	351	+	then $a
	352	+	else S_c($a, $l[$i])
	353	+
	354	+	func $f0_2 ($a,$i) = if (($i >= $s))
	355	+	then $a
	356	+	else throw("List size exceeds 15")
	357	+
	358	+	$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
	359	+	}
	360	+	let S_ = $t075837684._1
	361	+	let c_ = $t075837684._2
	362	+	let c = fraction(c_, toBigInt(D), toBigInt((Ann * nCoins)))
	363	+	let bD = toBigInt(((S_ + (D / Ann)) - D))
	364	+	func y_proc (acc,_i) = if ((acc._2 == true))
	365	+	then acc
	366	+	else {
	367	+	let y_prev = acc._1
	368	+	let y = (((y_prev * y_prev) + c) / ((big2 * y_prev) + bD))
	369	+	if ((y > y_prev))
	370	+	then if ((1 >= toInt((y - y_prev))))
	371	+	then $Tuple2(y, true)
	372	+	else $Tuple2(y, false)
	373	+	else if ((1 >= toInt((y_prev - y))))
	374	+	then $Tuple2(y, true)
	375	+	else $Tuple2(y, false)
	376	+	}
	377	+
	378	+	let $t081668283 = {
	379	+	let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
	380	+	let $s = size($l)
	381	+	let $acc0 = $Tuple2(toBigInt(D), false)
	382	+	func $f1_1 ($a,$i) = if (($i >= $s))
	383	+	then $a
	384	+	else y_proc($a, $l[$i])
	385	+
	386	+	func $f1_2 ($a,$i) = if (($i >= $s))
	387	+	then $a
	388	+	else throw("List size exceeds 16")
	389	+
	390	+	$f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
	391	+	}
	392	+	let y = $t081668283._1
	393	+	let finished = $t081668283._2
	394	+	if ((finished == false))
	395	+	then throw(("getY() not finished with " + toString(y)))
	396	+	else toInt(y)
	397	+	}
	398	+
	399	+
	400	+	func get_y_D (A_,in,xp,D) = if (assert((in >= 0)))
	401	+	then throw("i below zero")
	402	+	else if (assert((nCoins > in)))
	403	+	then throw("i above N_COINS")
	404	+	else {
	405	+	let Ann = (A_ * nCoins)
	406	+	func S_c (acc,i) = {
	407	+	let $t086628679 = acc
	408	+	let S_ = $t086628679._1
	409	+	let c = $t086628679._2
	410	+	let x_ = if (if ((in != i))
	411	+	then (nCoins > i)
	412	+	else false)
	413	+	then xp[i]
	414	+	else 0
	415	+	if (if ((nCoins > i))
	416	+	then (in != i)
	417	+	else false)
	418	+	then $Tuple2((S_ + x_), fraction(c, toBigInt(D), toBigInt((x_ * nCoins))))
	419	+	else $Tuple2(S_, c)
	420	+	}
	421	+
	422	+	let $t088999000 = {
	423	+	let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
	424	+	let $s = size($l)
	425	+	let $acc0 = $Tuple2(0, toBigInt(D))
	426	+	func $f0_1 ($a,$i) = if (($i >= $s))
	427	+	then $a
	428	+	else S_c($a, $l[$i])
	429	+
	430	+	func $f0_2 ($a,$i) = if (($i >= $s))
	431	+	then $a
	432	+	else throw("List size exceeds 15")
	433	+
	434	+	$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
	435	+	}
	436	+	let S_ = $t088999000._1
	437	+	let c_ = $t088999000._2
	438	+	let c = fraction(c_, toBigInt(D), toBigInt((Ann * nCoins)))
	439	+	let bD = toBigInt(((S_ + (D / Ann)) - D))
	440	+	func y_D_proc (acc,i) = if ((acc._2 == true))
	441	+	then acc
	442	+	else {
	443	+	let y_prev = acc._1
	444	+	let y = (((y_prev * y_prev) + c) / ((big2 * y_prev) + bD))
	445	+	if ((y > y_prev))
	446	+	then if ((1 >= toInt((y - y_prev))))
	447	+	then $Tuple2(y, true)
	448	+	else $Tuple2(y, false)
	449	+	else if ((1 >= toInt((y_prev - y))))
	450	+	then $Tuple2(y, true)
	451	+	else $Tuple2(y, false)
	452	+	}
	453	+
	454	+	let $t094839602 = {
	455	+	let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
	456	+	let $s = size($l)
	457	+	let $acc0 = $Tuple2(toBigInt(D), false)
	458	+	func $f1_1 ($a,$i) = if (($i >= $s))
	459	+	then $a
	460	+	else y_D_proc($a, $l[$i])
	461	+
	462	+	func $f1_2 ($a,$i) = if (($i >= $s))
	463	+	then $a
	464	+	else throw("List size exceeds 16")
	465	+
	466	+	$f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
	467	+	}
	468	+	let y = $t094839602._1
	469	+	let finished = $t094839602._2
	470	+	if ((finished == false))
	471	+	then throw(("get_y_D() not finished with " + toString(y)))
	472	+	else toInt(y)
	473	+	}
	474	+
	475	+
	476	+	func _calcWithdrawOneCoin (xp,_token_amount,i,caller) = {
	477	+	let feeDiscount = calculateFeeDiscount(caller)
	478	+	let amp = _A()
	479	+	let _fee = ((fraction(fee, feeDiscount, feeScale6, CEILING) * nCoins) / (4 * (nCoins - 1)))
	480	+	let total_supply = shareSupply
	481	+	let D0 = get_D(xp, amp)
	482	+	let D1 = (D0 - fraction(_token_amount, D0, total_supply))
	483	+	let new_y = get_y_D(amp, i, xp, D1)
	484	+	let dy_0 = (xp[i] - new_y)
	485	+	func xp_reduced_proc (acc,xp_j) = {
	486	+	let $t01024310272 = acc
	487	+	let xp_reduced = $t01024310272._1
	488	+	let index = $t01024310272._2
	489	+	let dx_expected = if ((index == i))
	490	+	then (fraction(xp_j, D1, D0) - new_y)
	491	+	else (xp_j - fraction(xp_j, D1, D0))
	492	+	$Tuple2((xp_reduced :+ (xp_j - fraction(_fee, dx_expected, feeScale6))), (index + 1))
	493	+	}
	494	+
	495	+	let $t01053410598 = {
	496	+	let $l = xp
	497	+	let $s = size($l)
	498	+	let $acc0 = $Tuple2(nil, 0)
	499	+	func $f0_1 ($a,$i) = if (($i >= $s))

github/deemru/w8io/026f985 
68.15 ms ◑