w8 · tx · G6h···eqs

tx · G6h8H5opUWfZsvRD2jNwRaJX44SbASk5HgFmEQjUCeqs

3MpygN8qm376tUAHB6mhC5BxG5NKYortiyX:  -0.03600000 Waves

2023.01.24 13:58 [2418954] smart account 3MpygN8qm376tUAHB6mhC5BxG5NKYortiyX > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "G6h8H5opUWfZsvRD2jNwRaJX44SbASk5HgFmEQjUCeqs",
    "fee": 3600000,
    "feeAssetId": null,
    "timestamp": 1674557964802,
    "version": 2,
    "chainId": 84,
    "sender": "3MpygN8qm376tUAHB6mhC5BxG5NKYortiyX",
    "senderPublicKey": "BjnLnkAMaJLYAK36vQqSepUNjGeMDHfZGfmdYwGcLbmg",
    "proofs": [
        "3pipZdzCTX1C3NadmW7kdyQNFvRh65hMoUp2tn9V2JjunKihytwRNNGmkACJeLxGj6kqV4AuMZF63hXDEdPEYcCu",
        "4XuP6UgrvvpcJ4YAhFdv2TLB86qtmteAuiJfDPhJB2MyGGPwaVocK6erFYxkUGAvHTAy8KvN4bDLU33NMdwJrvAL"
    ],
    "script": "base64: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",
    "height": 2418954,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 9YDcawhmDMtZ7wPHuCF2fvnAidcEHv8QMXz329ReBwiE
Next: 5s2aGvED1frkfqqvbBojNurojgLjaoAftsRMWy5B5o2P

Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let version = "2.0.0"
5 5  
6 6  let kVersion = "version"
7 7  
8 8  let kActive = "active"
9 9  
10 10  let kActiveGlob = "active_all_contracts"
11 11  
12 12  let kDeprecated = "deprecated_"
13 13  
14 14  let kAssetIdA = "A_asset_id"
15 15  
16 16  let kAssetIdB = "B_asset_id"
17 17  
18 18  let kBalanceA = "A_asset_balance"
19 19  
20 20  let kBalanceB = "B_asset_balance"
21 21  
22 22  let kShareAssetId = "share_asset_id"
23 23  
24 24  let kShareAssetSupply = "share_asset_supply"
25 25  
26 26  let kFee = "commission"
27 27  
28 28  let kInvariant = "invariant"
29 29  
30 30  let kCause = "shutdown_cause"
31 31  
32 32  let kUSDNAddress = "staking_usdnnsbt_address"
33 33  
34 34  let kEURNAddress = "staking_eurn_address"
35 35  
36 36  let kDiscounts = "discounts"
37 37  
38 38  let kDiscountValues = "discount_values"
39 39  
40 40  let kUserSwopInGov = "_SWOP_amount"
41 41  
42 42  let kUserGSwopInGov = "_GSwop_amount"
43 43  
44 44  let kFirstHarvest = "first_harvest"
45 45  
46 46  let kFirstHarvestHeight = "first_harvest_height"
47 47  
48 48  let kShareLimit = "share_limit_on_first_harvest"
49 49  
50 50  let kBasePeriod = "base_period"
51 51  
52 52  let kPeriodLength = "period_length"
53 53  
54 54  let kStartHeight = "start_height"
55 55  
56 56  let kDAppThreshold = "dApp_threshold"
57 57  
58 58  let kAdminPubKey1 = "admin_pub_1"
59 59  
60 60  let kAdminPubKey2 = "admin_pub_2"
61 61  
62 62  let kAdminPubKey3 = "admin_pub_3"
63 63  
64 64  let kAdminInvokePubKey = "admin_invoke_pub"
65 65  
66 66  let kMoneyBoxAddress = "money_box_address"
67 67  
68 68  let kGovAddress = "governance_address"
69 69  
70 70  let kFarmingAddress = "farming_address"
71 71  
72 72  let kVotingAddress = "voting_address"
73 73  
74 74  let kUSDNAssetId = "usdn_asset_id"
75 75  
76 76  let kStakingAssets = "staking_assets"
77 77  
78 78  let oracle = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
79 79  
80 80  func getBase58FromOracle (key) = match getString(oracle, key) {
81 81      case string: String => 
82 82          fromBase58String(string)
83 83      case nothing => 
84 84          throw((key + "is empty"))
85 85  }
86 86  
87 87  
88 88  let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
89 89  
90 90  let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
91 91  
92 92  let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
93 93  
94 94  let adminPubKeyInvoke = getBase58FromOracle(kAdminInvokePubKey)
95 95  
96 96  let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
97 97  
98 98  let govAddress = Address(getBase58FromOracle(kGovAddress))
99 99  
100 100  let stakingUSDNAddress = Address(getBase58FromOracle(kUSDNAddress))
101 101  
102 102  let votingAddress = Address(getBase58FromOracle(kVotingAddress))
103 103  
104 104  let farmingAddress = Address(getBase58FromOracle(kFarmingAddress))
105 105  
106 106  let USDN = getBase58FromOracle(kUSDNAssetId)
107 107  
108 108  let stakingAssets = getStringValue(oracle, kStakingAssets)
109 109  
110 110  let basePeriod = valueOrErrorMessage(getInteger(votingAddress, kBasePeriod), "Empty kBasePeriod")
111 111  
112 112  let startHeight = valueOrErrorMessage(getInteger(votingAddress, kStartHeight), "Empty kStartHeight")
113 113  
114 114  let periodLength = valueOrErrorMessage(getInteger(votingAddress, kPeriodLength), "Empty kPeriodLength")
115 115  
116 116  let firstHarvestEndPeriod = ((basePeriod + ((height - startHeight) / periodLength)) + 3)
117 117  
118 118  let active = getBooleanValue(this, kActive)
119 119  
120 120  let activeGlob = valueOrElse(getBoolean(oracle, kActiveGlob), true)
121 121  
122 122  let deprecatedPool = valueOrElse(getBoolean(oracle, (kDeprecated + toString(this))), false)
123 123  
124 124  let strAssetIdA = getStringValue(this, kAssetIdA)
125 125  
126 126  let strAssetIdB = getStringValue(this, kAssetIdB)
127 127  
128 128  let assetIdA = if ((strAssetIdA == "WAVES"))
129 129      then unit
130 130      else fromBase58String(strAssetIdA)
131 131  
132 132  let assetIdB = if ((strAssetIdB == "WAVES"))
133 133      then unit
134 134      else fromBase58String(strAssetIdB)
135 135  
136 136  let assetNameA = match assetIdA {
137 137      case id: ByteVector => 
138 138          value(assetInfo(id)).name
139 139      case waves: Unit => 
140 140          "WAVES"
141 141      case _ => 
142 142          throw("Match error")
143 143  }
144 144  
145 145  let assetNameB = match assetIdB {
146 146      case id: ByteVector => 
147 147          value(assetInfo(id)).name
148 148      case waves: Unit => 
149 149          "WAVES"
150 150      case _ => 
151 151          throw("Match error")
152 152  }
153 153  
154 154  let balanceA = getIntegerValue(this, kBalanceA)
155 155  
156 156  let balanceB = getIntegerValue(this, kBalanceB)
157 157  
158 158  let shareAssetId = fromBase58String(getStringValue(this, kShareAssetId))
159 159  
160 160  let shareAssetSupply = getIntegerValue(this, kShareAssetSupply)
161 161  
162 162  let invariant = getIntegerValue(this, kInvariant)
163 163  
164 164  let fee = getIntegerValue(this, kFee)
165 165  
166 166  let feeGovernance = fraction(fee, 40, 100)
167 167  
168 168  let feeScale6 = 1000000
169 169  
170 170  let scale3 = 1000
171 171  
172 172  let scale8 = 100000000
173 173  
174 174  let scale16 = 10000000000000000
175 175  
176 176  let digits8 = 8
177 177  
178 178  let exchangeRatioLimitMin = 60000000
179 179  
180 180  let exchangeRatioLimitMax = 140000000
181 181  
182 182  let alpha = 50
183 183  
184 184  let alphaDigits = 2
185 185  
186 186  let beta = 4600000000000000
187 187  
188 188  func accountBalance (assetId) = match assetId {
189 189      case id: ByteVector => 
190 190          assetBalance(this, id)
191 191      case waves: Unit => 
192 192          wavesBalance(this).available
193 193      case _ => 
194 194          throw("Match error")
195 195  }
196 196  
197 197  
198 198  func stakedAmount (assetId) = {
199 199      let stakedAmountCalculated =     match assetId {
200 200          case aId: ByteVector => 
201 201              if ((aId == USDN))
202 202                  then getInteger(stakingUSDNAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(this)))
203 203                  else 0
204 204          case _: Unit => 
205 205              0
206 206          case _ => 
207 207              throw("Match error")
208 208      }
209 209      match stakedAmountCalculated {
210 210          case i: Int => 
211 211              i
212 212          case _ => 
213 213              0
214 214      }
215 215      }
216 216  
217 217  
218 218  let stakedAmountA = stakedAmount(assetIdA)
219 219  
220 220  let stakedAmountB = stakedAmount(assetIdB)
221 221  
222 222  let availableBalanceA = (balanceA - stakedAmountA)
223 223  
224 224  let availableBalanceB = (balanceB - stakedAmountB)
225 225  
226 226  let accountBalanceWithStakedA = (accountBalance(assetIdA) + stakedAmountA)
227 227  
228 228  let accountBalanceWithStakedB = (accountBalance(assetIdB) + stakedAmountB)
229 229  
230 230  let hasEnoughBalance = if ((accountBalanceWithStakedA >= balanceA))
231 231      then (accountBalanceWithStakedB >= balanceB)
232 232      else false
233 233  
234 234  func skewness (x,y) = ((fraction(scale16, x, y) + fraction(scale16, y, x)) / 2)
235 235  
236 236  
237 237  func invariantCalc (x,y) = {
238 238      let sk = skewness(x, y)
239 239      (fraction((x + y), scale16, pow(sk, digits8, alpha, alphaDigits, digits8, CEILING)) + (2 * fraction(toInt(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN)), pow((sk - beta), digits8, alpha, alphaDigits, digits8, DOWN), scale8)))
240 240      }
241 241  
242 242  
243 243  func calculateSendAmount (amountToSendEstimated,minTokenReceiveAmount,tokenReceiveAmount,tokenId,balcA,balcB,invCur) = {
244 244      let worstAllowedNewInvariantRatio = (scale16 - ((scale16 * 1) / 10000000))
245 245      let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
246 246      let x = (balcA + tokenReceiveAmount)
247 247      let y = (balcB + tokenReceiveAmount)
248 248      func getStepAmount (acc,step) =     if ((acc._1 == -1))
249 249          then {
250 250              let amountToSend = (amountToSendEstimated - (((step * deltaBetweenMaxAndMinSendValue) / 3) / scale3))
251 251              let stepInvariant = if ((tokenId == assetIdA))
252 252                  then invariantCalc(x, (balcB - amountToSend))
253 253                  else invariantCalc((balcA - amountToSend), y)
254 254              if ((stepInvariant > invCur))
255 255                  then $Tuple2(amountToSend, stepInvariant)
256 256                  else $Tuple2(-1, 0)
257 257              }
258 258          else acc
259 259  
260 260      let amountToSendMin = getStepAmount($Tuple2(-1, 0), 3000)
261 261      if ((0 > amountToSendMin._1))
262 262          then throw("Price is worse than minReceived")
263 263          else {
264 264              let invEstimated = if ((tokenId == assetIdA))
265 265                  then invariantCalc(x, (balcB - amountToSendEstimated))
266 266                  else if ((tokenId == assetIdB))
267 267                      then invariantCalc((balcA - amountToSendEstimated), y)
268 268                      else throw("Wrong asset in payment")
269 269              if ((invCur > invEstimated))
270 270                  then if ((worstAllowedNewInvariantRatio >= fraction(scale16, invCur, invEstimated)))
271 271                      then throw("The requested price is too not profitable for user")
272 272                      else {
273 273                          let a = {
274 274                              let $l = [25, 200, 500]
275 275                              let $s = size($l)
276 276                              let $acc0 = $Tuple2(-1, 0)
277 277                              func $f0_1 ($a,$i) =                             if (($i >= $s))
278 278                                  then $a
279 279                                  else getStepAmount($a, $l[$i])
280 280  
281 281                              func $f0_2 ($a,$i) =                             if (($i >= $s))
282 282                                  then $a
283 283                                  else throw("List size exceeds 3")
284 284  
285 285                              $f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
286 286                              }
287 287                          if ((0 > a._1))
288 288                              then amountToSendMin._1
289 289                              else a._1
290 290                          }
291 291                  else {
292 292                      let a = {
293 293                          let $l = [-500, -200, -25]
294 294                          let $s = size($l)
295 295                          let $acc0 = $Tuple2(-1, 0)
296 296                          func $f0_1 ($a,$i) =                         if (($i >= $s))
297 297                              then $a
298 298                              else getStepAmount($a, $l[$i])
299 299  
300 300                          func $f0_2 ($a,$i) =                         if (($i >= $s))
301 301                              then $a
302 302                              else throw("List size exceeds 3")
303 303  
304 304                          $f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
305 305                          }
306 306                      let tupleSendBetter = if ((0 > a._1))
307 307                          then $Tuple2(amountToSendEstimated, invEstimated)
308 308                          else a
309 309                      if ((worstAllowedNewInvariantRatio >= fraction(scale16, invCur, tupleSendBetter._2)))
310 310                          then throw("The requested price is too not profitable for user")
311 311                          else tupleSendBetter._1
312 312                      }
313 313              }
314 314      }
315 315  
316 316  
317 317  func getAssetInfo (assetId) = match assetId {
318 318      case id: ByteVector => 
319 319          let stringId = toBase58String(id)
320 320          let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
321 321          $Tuple3(stringId, info.name, info.decimals)
322 322      case waves: Unit => 
323 323          $Tuple3("WAVES", "WAVES", 8)
324 324      case _ => 
325 325          throw("Match error")
326 326  }
327 327  
328 328  
329 329  func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
330 330  
331 331  
332 332  func throwIsActive () = throw("DApp is already active")
333 333  
334 334  
335 335  func isActive () = if (if (active)
336 336      then activeGlob
337 337      else false)
338 338      then unit
339 339      else throw("DApp is inactive at this moment")
340 340  
341 341  
342 342  func isDepricated () = if (!(deprecatedPool))
343 343      then unit
344 344      else throw("Pool is deprecated. Only withdraw action allowed.")
345 345  
346 346  
347 347  func isAdminCall (i) = if (containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey))
348 348      then unit
349 349      else throw("Only admin can call this function")
350 350  
351 351  
352 352  func isSelfCall (i) = if ((this == i.caller))
353 353      then unit
354 354      else throw("Only contract itself can call this function")
355 355  
356 356  
357 357  func throwAssets () = throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
358 358  
359 359  
360 360  func throwOnePayment () = throw("One attached payment expected")
361 361  
362 362  
363 363  func suspendSuspicious () = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB) + ". State: ") + toString(accountBalance(assetIdA))) + " ") + assetNameA) + ", ") + toString(accountBalance(assetIdB))) + " ") + assetNameB))
364 364  
365 365  
366 366  func calcStakingFuncAndAddres (stake,assetId) = if (stake)
367 367      then $Tuple2("lockNeutrino", stakingUSDNAddress)
368 368      else $Tuple2("unlockNeutrino", stakingUSDNAddress)
369 369  
370 370  
371 371  func calcStakingParams (stake,amount,assetId) = if (stake)
372 372      then {
373 373          let $t01044410510 = calcStakingFuncAndAddres(stake, assetId)
374 374          let call = $t01044410510._1
375 375          let stakingAddr = $t01044410510._2
376 376          $Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
377 377          }
378 378      else {
379 379          let $t01059610662 = calcStakingFuncAndAddres(stake, assetId)
380 380          let call = $t01059610662._1
381 381          let stakingAddr = $t01059610662._2
382 382          $Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
383 383          }
384 384  
385 385  
386 386  func calculateFeeDiscount (userAddr) = {
387 387      let swopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserSwopInGov)), 0)
388 388      let gSwopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserGSwopInGov)), swopAmount)
389 389      let discountValues = split(getStringValue(oracle, kDiscountValues), ",")
390 390      let discounts = split(getStringValue(oracle, kDiscounts), ",")
391 391      if (if ((gSwopAmount >= parseIntValue(discountValues[0])))
392 392          then (parseIntValue(discountValues[1]) > gSwopAmount)
393 393          else false)
394 394          then (feeScale6 - parseIntValue(discounts[0]))
395 395          else if (if ((gSwopAmount >= parseIntValue(discountValues[1])))
396 396              then (parseIntValue(discountValues[2]) > gSwopAmount)
397 397              else false)
398 398              then (feeScale6 - parseIntValue(discounts[1]))
399 399              else if (if ((gSwopAmount >= parseIntValue(discountValues[2])))
400 400                  then (parseIntValue(discountValues[3]) > gSwopAmount)
401 401                  else false)
402 402                  then (feeScale6 - parseIntValue(discounts[2]))
403 403                  else if (if ((gSwopAmount >= parseIntValue(discountValues[3])))
404 404                      then (parseIntValue(discountValues[4]) > gSwopAmount)
405 405                      else false)
406 406                      then (feeScale6 - parseIntValue(discounts[3]))
407 407                      else if ((gSwopAmount >= parseIntValue(discountValues[4])))
408 408                          then (feeScale6 - parseIntValue(discounts[4]))
409 409                          else feeScale6
410 410      }
411 411  
412 412  
413 413  func checkDAppThreshold (newBalanceA,newBalanceB,pmtAssetId) = {
414 414      let dAppThreshold = getIntegerValue(this, kDAppThreshold)
415 415      let ratio = if (if ((pmtAssetId == assetIdA))
416 416          then (newBalanceA > newBalanceB)
417 417          else false)
418 418          then fraction(newBalanceA, 1, newBalanceB, CEILING)
419 419          else if (if ((pmtAssetId == assetIdB))
420 420              then (newBalanceB > newBalanceA)
421 421              else false)
422 422              then fraction(newBalanceB, 1, newBalanceA, CEILING)
423 423              else 0
424 424      if ((ratio > dAppThreshold))
425 425          then {
426 426              let $t01240712515 = if ((pmtAssetId == assetIdA))
427 427                  then $Tuple2(assetNameB, assetNameA)
428 428                  else $Tuple2(assetNameA, assetNameB)
429 429              let token1 = $t01240712515._1
430 430              let token2 = $t01240712515._2
431 431              throw((((("Buying " + token1) + " is temporarily unavailable due to the ") + token2) + " depeg"))
432 432              }
433 433          else true
434 434      }
435 435  
436 436  
437 437  func replenishWithTwoTokensCalc (i,stakeFarming,lockType) = {
438 438      let pmtAssetIdA = i.payments[0].assetId
439 439      let pmtAssetIdB = i.payments[1].assetId
440 440      let ratioShareTokensInA = fraction(scale8, i.payments[0].amount, balanceA)
441 441      let ratioShareTokensInB = fraction(scale8, i.payments[1].amount, balanceB)
442 442      let $t01297513052 = getAssetInfo(pmtAssetIdA)
443 443      let pmtStrAssetIdA = $t01297513052._1
444 444      let pmtAssetNameA = $t01297513052._2
445 445      let pmtDecimalsA = $t01297513052._3
446 446      let $t01305713174 = getAssetInfo(pmtAssetIdB)
447 447      let pmtStrAssetIdB = $t01305713174._1
448 448      let pmtAssetNameB = $t01305713174._2
449 449      let pmtDecimalsB = $t01305713174._3
450 450      let $t01317913683 = if ((ratioShareTokensInB > ratioShareTokensInA))
451 451          then {
452 452              let pmt = fraction(balanceB, ratioShareTokensInA, scale8, CEILING)
453 453              $Tuple5(i.payments[0].amount, pmt, (i.payments[1].amount - pmt), pmtAssetIdB, ratioShareTokensInA)
454 454              }
455 455          else {
456 456              let pmt = fraction(balanceA, ratioShareTokensInB, scale8, CEILING)
457 457              $Tuple5(pmt, i.payments[1].amount, (i.payments[0].amount - pmt), pmtAssetIdA, ratioShareTokensInB)
458 458              }
459 459      let pmtAmountA = $t01317913683._1
460 460      let pmtAmountB = $t01317913683._2
461 461      let change = $t01317913683._3
462 462      let changeAssetId = $t01317913683._4
463 463      let shareTokenRatio = $t01317913683._5
464 464      let shareTokenToPayAmount = fraction(shareTokenRatio, shareAssetSupply, scale8)
465 465      if (if ((size(i.payments) != 2))
466 466          then (size(i.payments) != 3)
467 467          else false)
468 468          then throw("Two or three payments expected")
469 469          else if (if ((pmtAssetIdA != assetIdA))
470 470              then true
471 471              else (pmtAssetIdB != assetIdB))
472 472              then throwAssets()
473 473              else if ((shareTokenToPayAmount == 0))
474 474                  then throw("Too small amount to replenish")
475 475                  else if ((0 > change))
476 476                      then throw("Change < 0")
477 477                      else if (!(hasEnoughBalance))
478 478                          then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
479 479                          else {
480 480                              let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
481 481                                  then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
482 482                                  else 0
483 483                              if ((stake1 == stake1))
484 484                                  then {
485 485                                      let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
486 486                                          then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
487 487                                          else 0
488 488                                      if ((stake2 == stake2))
489 489                                          then {
490 490                                              let scriptActions = [IntegerEntry(kBalanceA, (balanceA + pmtAmountA)), IntegerEntry(kBalanceB, (balanceB + pmtAmountB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(kInvariant, invariantCalc((balanceA + pmtAmountA), (balanceB + pmtAmountB))), ScriptTransfer(i.caller, change, changeAssetId)]
491 491                                              if (stakeFarming)
492 492                                                  then {
493 493                                                      let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmount)] ++ (if ((size(i.payments) == 3))
494 494                                                          then [AttachedPayment(if ((i.payments[2].assetId == base58''))
495 495                                                              then unit
496 496                                                              else i.payments[2].assetId, i.payments[2].amount)]
497 497                                                          else nil))
498 498                                                      let re = invoke(this, "reissueShare", [shareTokenToPayAmount], nil)
499 499                                                      if ((re == re))
500 500                                                          then {
501 501                                                              let s = invoke(farmingAddress, "lockShareTokensFromPool", [i.caller.bytes, toString(this), lockType], stPayments)
502 502                                                              if ((s == s))
503 503                                                                  then scriptActions
504 504                                                                  else throw("Strict value is not equal to itself.")
505 505                                                              }
506 506                                                          else throw("Strict value is not equal to itself.")
507 507                                                      }
508 508                                                  else (scriptActions ++ [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId)])
509 509                                              }
510 510                                          else throw("Strict value is not equal to itself.")
511 511                                      }
512 512                                  else throw("Strict value is not equal to itself.")
513 513                              }
514 514      }
515 515  
516 516  
517 517  func replenishWithOneTokenCalc (i,virtualSwapTokenPay,virtualSwapTokenGet,stakeFarming,lockType) = {
518 518      let $t01607316148 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
519 519      let pmtAmount = $t01607316148._1
520 520      let pmtAssetId = $t01607316148._2
521 521      let $t01615316226 = getAssetInfo(pmtAssetId)
522 522      let pmtStrAssetId = $t01615316226._1
523 523      let pmtAssetName = $t01615316226._2
524 524      let pmtDecimals = $t01615316226._3
525 525      let pmtMinThreshold = 5000000
526 526      let thresholdValueForMinTolerance = 50000000
527 527      let tolerance = if ((thresholdValueForMinTolerance > pmtAmount))
528 528          then 100000
529 529          else 1
530 530      let slippageValueMinForReplenish = (scale8 - ((scale8 * tolerance) / 10000000))
531 531      let slippageValueMaxForReplenish = (scale8 + ((scale8 * tolerance) / 10000000))
532 532      let slippageValueMinForSwap = (scale8 - ((scale8 * 1) / 10000000))
533 533      if ((pmtMinThreshold > pmtAmount))
534 534          then throw((((("Payment amount " + toString(pmtAmount)) + " does not exceed the minimum amount of ") + toString(pmtMinThreshold)) + " tokens"))
535 535          else if (if ((size(i.payments) != 1))
536 536              then (size(i.payments) != 2)
537 537              else false)
538 538              then throw("One or two payments expected")
539 539              else if (!(hasEnoughBalance))
540 540                  then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
541 541                  else if (if ((pmtAssetId != assetIdA))
542 542                      then (pmtAssetId != assetIdB)
543 543                      else false)
544 544                      then throwAssets()
545 545                      else {
546 546                          let $t01722817870 = if ((pmtAssetId == assetIdA))
547 547                              then $Tuple6((pmtAmount - virtualSwapTokenPay), virtualSwapTokenGet, (balanceA + virtualSwapTokenPay), (balanceB - virtualSwapTokenGet), (balanceA + pmtAmount), balanceB)
548 548                              else $Tuple6(virtualSwapTokenGet, (pmtAmount - virtualSwapTokenPay), (balanceA - virtualSwapTokenGet), (balanceB + virtualSwapTokenPay), balanceA, (balanceB + pmtAmount))
549 549                          let virtualReplenishA = $t01722817870._1
550 550                          let virtualReplenishB = $t01722817870._2
551 551                          let balanceAfterSwapA = $t01722817870._3
552 552                          let balanceAfterSwapB = $t01722817870._4
553 553                          let newBalanceA = $t01722817870._5
554 554                          let newBalanceB = $t01722817870._6
555 555                          let invariantNew = invariantCalc(balanceAfterSwapA, balanceAfterSwapB)
556 556                          let ratioVirtualBalanceToVirtualReplenish = (fraction(scale16, balanceAfterSwapA, balanceAfterSwapB) / fraction(scale8, virtualReplenishA, virtualReplenishB))
557 557                          if (if ((slippageValueMinForSwap >= fraction(scale8, invariant, invariantNew)))
558 558                              then true
559 559                              else (invariant > invariantNew))
560 560                              then throw("Incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
561 561                              else if (if ((slippageValueMinForReplenish > ratioVirtualBalanceToVirtualReplenish))
562 562                                  then true
563 563                                  else (ratioVirtualBalanceToVirtualReplenish > slippageValueMaxForReplenish))
564 564                                  then throw("Swap with virtualSwapTokenPay and virtualSwapTokenGet is possible, but ratio after virtual swap is incorrect")
565 565                                  else if (!(checkDAppThreshold(newBalanceA, newBalanceB, pmtAssetId)))
566 566                                      then throw()
567 567                                      else {
568 568                                          let ratioShareTokensInA = fraction(virtualReplenishA, scale8, balanceAfterSwapA)
569 569                                          let ratioShareTokensInB = fraction(virtualReplenishB, scale8, balanceAfterSwapB)
570 570                                          let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scale8)
571 571                                          let shareTokenToPayAmountAfterFee = fraction(shareTokenToPayAmount, (feeScale6 - (fee / 2)), feeScale6)
572 572                                          let shareTokenGovernanceReward = fraction(shareTokenToPayAmount, (feeGovernance / 2), feeScale6)
573 573                                          let governanceRewardTokenA = fraction(shareTokenGovernanceReward, balanceA, shareAssetSupply)
574 574                                          let governanceRewardTokenB = fraction(shareTokenGovernanceReward, balanceB, shareAssetSupply)
575 575                                          let $t01962119904 = if ((pmtStrAssetId == strAssetIdA))
576 576                                              then $Tuple3((pmtAmount - governanceRewardTokenA), governanceRewardTokenB, strAssetIdB)
577 577                                              else $Tuple3((pmtAmount - governanceRewardTokenB), governanceRewardTokenA, strAssetIdA)
578 578                                          let stakeAmount = $t01962119904._1
579 579                                          let unstakeAmount = $t01962119904._2
580 580                                          let unstakeAsset = $t01962119904._3
581 581                                          let stake1 = if (contains(stakingAssets, pmtStrAssetId))
582 582                                              then invoke(this, "stakeUnstake", [true, stakeAmount, pmtStrAssetId], nil)
583 583                                              else 0
584 584                                          if ((stake1 == stake1))
585 585                                              then {
586 586                                                  let stake2 = if (contains(stakingAssets, unstakeAsset))
587 587                                                      then invoke(this, "stakeUnstake", [false, unstakeAmount, unstakeAsset], nil)
588 588                                                      else 0
589 589                                                  if ((stake2 == stake2))
590 590                                                      then {
591 591                                                          let scriptActions = [IntegerEntry(kBalanceA, (newBalanceA - governanceRewardTokenA)), IntegerEntry(kBalanceB, (newBalanceB - governanceRewardTokenB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmountAfterFee)), IntegerEntry(kInvariant, invariantCalc((newBalanceA - governanceRewardTokenA), (newBalanceB - governanceRewardTokenB))), ScriptTransfer(moneyBoxAddress, governanceRewardTokenA, assetIdA), ScriptTransfer(moneyBoxAddress, governanceRewardTokenB, assetIdB)]
592 592                                                          if (stakeFarming)
593 593                                                              then {
594 594                                                                  let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmountAfterFee)] ++ (if ((size(i.payments) == 2))
595 595                                                                      then [AttachedPayment(if ((i.payments[1].assetId == base58''))
596 596                                                                          then unit
597 597                                                                          else i.payments[1].assetId, i.payments[1].amount)]
598 598                                                                      else nil))
599 599                                                                  let re = invoke(this, "reissueShare", [shareTokenToPayAmountAfterFee], nil)
600 600                                                                  if ((re == re))
601 601                                                                      then {
602 602                                                                          let s = invoke(farmingAddress, "lockShareTokensFromPool", [i.caller.bytes, toString(this), lockType], stPayments)
603 603                                                                          if ((s == s))
604 604                                                                              then scriptActions
605 605                                                                              else throw("Strict value is not equal to itself.")
606 606                                                                          }
607 607                                                                      else throw("Strict value is not equal to itself.")
608 608                                                                  }
609 609                                                              else (scriptActions ++ [Reissue(shareAssetId, shareTokenToPayAmountAfterFee, true), ScriptTransfer(i.caller, shareTokenToPayAmountAfterFee, shareAssetId)])
610 610                                                          }
611 611                                                      else throw("Strict value is not equal to itself.")
612 612                                                  }
613 613                                              else throw("Strict value is not equal to itself.")
614 614                                          }
615 615                          }
616 616      }
617 617  
618 618  
619 619  func withdrawCalc (i,unlockAmount) = {
620 620      let $t02175322088 = if ((size(i.payments) == 1))
621 621          then if ((i.payments[0].assetId != shareAssetId))
622 622              then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
623 623              else $Tuple2(i.payments[0].amount, i.payments[0].assetId)
624 624          else $Tuple2(0, shareAssetId)
625 625      let pmtAmount = $t02175322088._1
626 626      let pmtAssetId = $t02175322088._2
627 627      if (!(hasEnoughBalance))
628 628          then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
629 629          else {
630 630              let unlock = if ((unlockAmount > 0))
631 631                  then invoke(farmingAddress, "withdrawShareTokensFromPool", [i.caller.bytes, toString(this), unlockAmount], nil)
632 632                  else 0
633 633              if ((unlock == unlock))
634 634                  then {
635 635                      let withdrawAmount = (pmtAmount + unlockAmount)
636 636                      let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
637 637                      let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
638 638                      let invariantCalculated = invariantCalc((balanceA - amountToPayA), (balanceB - amountToPayB))
639 639                      let stake1 = if (contains(stakingAssets, strAssetIdA))
640 640                          then invoke(this, "stakeUnstake", [false, amountToPayA, strAssetIdA], nil)
641 641                          else 0
642 642                      if ((stake1 == stake1))
643 643                          then {
644 644                              let stake2 = if (contains(stakingAssets, strAssetIdB))
645 645                                  then invoke(this, "stakeUnstake", [false, amountToPayB, strAssetIdB], nil)
646 646                                  else 0
647 647                              if ((stake2 == stake2))
648 648                                  then [IntegerEntry(kBalanceA, (balanceA - amountToPayA)), IntegerEntry(kBalanceB, (balanceB - amountToPayB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), IntegerEntry(kInvariant, invariantCalculated), Burn(shareAssetId, withdrawAmount), ScriptTransfer(i.caller, amountToPayA, assetIdA), ScriptTransfer(i.caller, amountToPayB, assetIdB)]
649 649                                  else throw("Strict value is not equal to itself.")
650 650                              }
651 651                          else throw("Strict value is not equal to itself.")
652 652                      }
653 653                  else throw("Strict value is not equal to itself.")
654 654              }
655 655      }
656 656  
657 657  
658 658  @Callable(i)
659 659  func init (firstHarvest) = {
660 660      let $t02364023717 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
661 661      let pmtAmountA = $t02364023717._1
662 662      let pmtAssetIdA = $t02364023717._2
663 663      let $t02372223799 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
664 664      let pmtAmountB = $t02372223799._1
665 665      let pmtAssetIdB = $t02372223799._2
666 666      let $t02380423881 = getAssetInfo(pmtAssetIdA)
667 667      let pmtStrAssetIdA = $t02380423881._1
668 668      let pmtAssetNameA = $t02380423881._2
669 669      let pmtDecimalsA = $t02380423881._3
670 670      let $t02388623963 = getAssetInfo(pmtAssetIdB)
671 671      let pmtStrAssetIdB = $t02388623963._1
672 672      let pmtAssetNameB = $t02388623963._2
673 673      let pmtDecimalsB = $t02388623963._3
674 674      if (isDefined(getBoolean(this, kActive)))
675 675          then throwIsActive()
676 676          else if ((pmtAssetIdA == pmtAssetIdB))
677 677              then throw("Assets must be different")
678 678              else {
679 679                  let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
680 680                  let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
681 681                  let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
682 682                  let shareInitialSupply = fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN), pow(10, 0, shareDecimals, 0, 0, DOWN))
683 683                  let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
684 684                  let shareIssueId = calculateAssetId(shareIssue)
685 685                  let invariantCalculated = invariantCalc(pmtAmountA, pmtAmountB)
686 686                  let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
687 687                      then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
688 688                      else 0
689 689                  if ((stake1 == stake1))
690 690                      then {
691 691                          let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
692 692                              then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
693 693                              else 0
694 694                          if ((stake2 == stake2))
695 695                              then {
696 696                                  let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceA, pmtAmountA), IntegerEntry(kBalanceB, pmtAmountB), IntegerEntry(kInvariant, invariantCalculated), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_flat")), IntegerEntry(kDAppThreshold, 3), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
697 697                                  if (firstHarvest)
698 698                                      then (baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))])
699 699                                      else baseEntry
700 700                                  }
701 701                              else throw("Strict value is not equal to itself.")
702 702                          }
703 703                      else throw("Strict value is not equal to itself.")
704 704                  }
705 705      }
706 706  
707 707  
708 708  
709 709  @Callable(i)
710 710  func replenishWithTwoTokensV2 (stakeFarming,lockType) = valueOrElse(isActive(), valueOrElse(isDepricated(), replenishWithTwoTokensCalc(i, stakeFarming, lockType)))
711 711  
712 712  
713 713  
714 714  @Callable(i)
715 715  func replenishWithOneTokenV2 (virtualSwapTokenPay,virtualSwapTokenGet,stakeFarming,lockType) = valueOrElse(isActive(), valueOrElse(isDepricated(), replenishWithOneTokenCalc(i, virtualSwapTokenPay, virtualSwapTokenGet, stakeFarming, lockType)))
716 716  
717 717  
718 718  
719 719  @Callable(i)
720 720  func withdrawV2 (unlockAmount) = valueOrElse(isActive(), withdrawCalc(i, unlockAmount))
721 721  
722 722  
723 723  
724 724  @Callable(i)
725 725  func withdrawOneToken (unlockAmount,withdrawAsset,estimatedAmountToReceive,minAmountToReceive) = valueOrElse(isActive(), valueOrElse(isDepricated(), {
726 726      let $t02752527884 = if ((size(i.payments) == 1))
727 727          then if ((i.payments[0].assetId != shareAssetId))
728 728              then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
729 729              else $Tuple2(i.payments[0].amount, i.payments[0].assetId)
730 730          else $Tuple2(0, shareAssetId)
731 731      let pmtAmount = $t02752527884._1
732 732      let pmtAssetId = $t02752527884._2
733 733      let withdrawAmount = (pmtAmount + unlockAmount)
734 734      if (if ((withdrawAsset != strAssetIdA))
735 735          then (withdrawAsset != strAssetIdB)
736 736          else false)
737 737          then throw("Incorrect withdraw asset")
738 738          else if ((0 >= withdrawAmount))
739 739              then throw("withdraw amount must be grater than 0")
740 740              else if (!(hasEnoughBalance))
741 741                  then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
742 742                  else {
743 743                      let unlock = if ((unlockAmount > 0))
744 744                          then invoke(farmingAddress, "withdrawShareTokensFromPool", [i.caller.bytes, toString(this), unlockAmount], nil)
745 745                          else 0
746 746                      if ((unlock == unlock))
747 747                          then {
748 748                              let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
749 749                              let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
750 750                              let newVirtBalcA = (balanceA - amountToPayA)
751 751                              let newVirtBalcB = (balanceB - amountToPayB)
752 752                              let feeDiscount = calculateFeeDiscount(i.originCaller)
753 753                              let amountExchangedWithFee = if ((withdrawAsset == strAssetIdA))
754 754                                  then calculateSendAmount(estimatedAmountToReceive, minAmountToReceive, amountToPayB, assetIdB, newVirtBalcA, newVirtBalcB, invariantCalc(newVirtBalcA, newVirtBalcB))
755 755                                  else calculateSendAmount(estimatedAmountToReceive, minAmountToReceive, amountToPayA, assetIdA, newVirtBalcA, newVirtBalcB, invariantCalc(newVirtBalcA, newVirtBalcB))
756 756                              let govReward = fraction(amountExchangedWithFee, fraction(feeGovernance, feeDiscount, feeScale6, CEILING), feeScale6)
757 757                              let amountExchanged = fraction(amountExchangedWithFee, (feeScale6 - fraction(fee, feeDiscount, feeScale6, CEILING)), feeScale6)
758 758                              let $t02957529949 = if ((withdrawAsset == strAssetIdA))
759 759                                  then $Tuple4((amountToPayA + amountExchanged), (((balanceA - amountToPayA) - amountExchanged) - govReward), balanceB, assetIdB)
760 760                                  else $Tuple4((amountToPayB + amountExchanged), balanceA, (((balanceB - amountToPayB) - amountExchanged) - govReward), assetIdA)
761 761                              let amountToPay = $t02957529949._1
762 762                              let balanceANew = $t02957529949._2
763 763                              let balanceBNew = $t02957529949._3
764 764                              let virtAssetId = $t02957529949._4
765 765                              if (!(checkDAppThreshold(balanceANew, balanceBNew, virtAssetId)))
766 766                                  then throw()
767 767                                  else {
768 768                                      let invariantCalculated = invariantCalc(balanceANew, balanceBNew)
769 769                                      let stake1 = if (contains(stakingAssets, withdrawAsset))
770 770                                          then invoke(this, "stakeUnstake", [false, (amountToPay + govReward), withdrawAsset], nil)
771 771                                          else 0
772 772                                      if ((stake1 == stake1))
773 773                                          then [IntegerEntry(kBalanceA, balanceANew), IntegerEntry(kBalanceB, balanceBNew), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), IntegerEntry(kInvariant, invariantCalculated), Burn(shareAssetId, withdrawAmount), ScriptTransfer(i.caller, amountToPay, fromBase58String(withdrawAsset)), ScriptTransfer(moneyBoxAddress, govReward, fromBase58String(withdrawAsset))]
774 774                                          else throw("Strict value is not equal to itself.")
775 775                                      }
776 776                              }
777 777                          else throw("Strict value is not equal to itself.")
778 778                      }
779 779      }))
780 780  
781 781  
782 782  
783 783  @Callable(i)
784 784  func exchange (estimatedAmountToReceive,minAmountToReceive) = valueOrElse(isActive(), valueOrElse(isDepricated(), {
785 785      let $t03101931094 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
786 786      let pmtAmount = $t03101931094._1
787 787      let pmtAssetId = $t03101931094._2
788 788      if ((0 >= estimatedAmountToReceive))
789 789          then throw(("Estimated amount must be positive. Actual: " + toString(estimatedAmountToReceive)))
790 790          else if ((minAmountToReceive > estimatedAmountToReceive))
791 791              then throw("Minimal amount can't be greater than estimated.")
792 792              else if ((size(i.payments) != 1))
793 793                  then throwOnePayment()
794 794                  else if (!(hasEnoughBalance))
795 795                      then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
796 796                      else if (if ((pmtAssetId != assetIdA))
797 797                          then (pmtAssetId != assetIdB)
798 798                          else false)
799 799                          then throwAssets()
800 800                          else if ((10000000 > pmtAmount))
801 801                              then throw("Only swap of 10.000000 or more tokens is allowed")
802 802                              else if (if ((exchangeRatioLimitMin > fraction(scale8, minAmountToReceive, pmtAmount)))
803 803                                  then true
804 804                                  else (fraction(scale8, estimatedAmountToReceive, pmtAmount) > exchangeRatioLimitMax))
805 805                                  then throw("Incorrect args and pmt ratio")
806 806                                  else {
807 807                                      let sendAssetId = if ((pmtAssetId == assetIdA))
808 808                                          then assetIdB
809 809                                          else assetIdA
810 810                                      let amount = calculateSendAmount(estimatedAmountToReceive, minAmountToReceive, pmtAmount, pmtAssetId, balanceA, balanceB, invariant)
811 811                                      let feeDiscount = calculateFeeDiscount(i.originCaller)
812 812                                      let governanceReward = fraction(amount, fraction(feeGovernance, feeDiscount, feeScale6, CEILING), feeScale6)
813 813                                      let amountMinusFee = fraction(amount, (feeScale6 - fraction(fee, feeDiscount, feeScale6, CEILING)), feeScale6)
814 814                                      let $t03269032968 = if ((pmtAssetId == assetIdA))
815 815                                          then $Tuple2((balanceA + pmtAmount), ((balanceB - amountMinusFee) - governanceReward))
816 816                                          else $Tuple2(((balanceA - amountMinusFee) - governanceReward), (balanceB + pmtAmount))
817 817                                      let newBalanceA = $t03269032968._1
818 818                                      let newBalanceB = $t03269032968._2
819 819                                      if (!(checkDAppThreshold(newBalanceA, newBalanceB, pmtAssetId)))
820 820                                          then throw()
821 821                                          else {
822 822                                              let $t03307433147 = getAssetInfo(pmtAssetId)
823 823                                              let pmtStrAssetId = $t03307433147._1
824 824                                              let pmtAssetName = $t03307433147._2
825 825                                              let pmtDecimals = $t03307433147._3
826 826                                              let $t03316033237 = getAssetInfo(sendAssetId)
827 827                                              let sendStrAssetId = $t03316033237._1
828 828                                              let sendAssetName = $t03316033237._2
829 829                                              let sendDecimals = $t03316033237._3
830 830                                              let stake1 = if (contains(stakingAssets, pmtStrAssetId))
831 831                                                  then invoke(this, "stakeUnstake", [true, pmtAmount, pmtStrAssetId], nil)
832 832                                                  else 0
833 833                                              if ((stake1 == stake1))
834 834                                                  then {
835 835                                                      let stake2 = if (contains(stakingAssets, sendStrAssetId))
836 836                                                          then invoke(this, "stakeUnstake", [false, (amountMinusFee + governanceReward), sendStrAssetId], nil)
837 837                                                          else 0
838 838                                                      if ((stake2 == stake2))
839 839                                                          then $Tuple2([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), IntegerEntry(kInvariant, invariantCalc(newBalanceA, newBalanceB)), ScriptTransfer(i.caller, amountMinusFee, sendAssetId), ScriptTransfer(moneyBoxAddress, governanceReward, sendAssetId)], [amountMinusFee, sendAssetId])
840 840                                                          else throw("Strict value is not equal to itself.")
841 841                                                      }
842 842                                                  else throw("Strict value is not equal to itself.")
843 843                                              }
844 844                                      }
845 845      }))
846 846  
847 847  
848 848  
849 849  @Callable(msg)
850 850  func reissueShare (amount) = valueOrElse(isSelfCall(msg), [Reissue(shareAssetId, amount, true)])
851 851  
852 852  
853 853  
854 854  @Callable(i)
855 855  func shutdown () = valueOrElse(isAdminCall(i), if (!(active))
856 856      then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, kCause), "the cause wasn't specified")))
857 857      else suspend("Paused by admin"))
858 858  
859 859  
860 860  
861 861  @Callable(i)
862 862  func activate () = valueOrElse(isAdminCall(i), if (active)
863 863      then throwIsActive()
864 864      else [BooleanEntry(kActive, true), DeleteEntry(kCause)])
865 865  
866 866  
867 867  
868 868  @Callable(i)
869 869  func takeIntoAccountExtraFunds () = valueOrElse(isActive(), {
870 870      let claim = if (if ((assetIdA == USDN))
871 871          then true
872 872          else (assetIdB == USDN))
873 873          then invoke(stakingUSDNAddress, "claimRewards", nil, nil)
874 874          else 0
875 875      if ((claim == claim))
876 876          then {
877 877              let amountEnrollA = (accountBalanceWithStakedA - balanceA)
878 878              let amountEnrollB = (accountBalanceWithStakedB - balanceB)
879 879              let invariantNew = invariantCalc((balanceA + amountEnrollA), (balanceB + amountEnrollB))
880 880              if ((i.caller != moneyBoxAddress))
881 881                  then throw("Only the money box can call this function")
882 882                  else if (if ((0 > amountEnrollA))
883 883                      then true
884 884                      else (0 > amountEnrollB))
885 885                      then suspend("Enroll amount negative")
886 886                      else if (if ((amountEnrollA == 0))
887 887                          then (amountEnrollB == 0)
888 888                          else false)
889 889                          then throw("No money to take")
890 890                          else {
891 891                              let stake1 = if (if (contains(stakingAssets, strAssetIdA))
892 892                                  then (amountEnrollA > 0)
893 893                                  else false)
894 894                                  then invoke(this, "stakeUnstake", [true, amountEnrollA, strAssetIdA], nil)
895 895                                  else 0
896 896                              if ((stake1 == stake1))
897 897                                  then {
898 898                                      let stake2 = if (if (contains(stakingAssets, strAssetIdB))
899 899                                          then (amountEnrollB > 0)
900 900                                          else false)
901 901                                          then invoke(this, "stakeUnstake", [true, amountEnrollB, strAssetIdB], nil)
902 902                                          else 0
903 903                                      if ((stake2 == stake2))
904 904                                          then [IntegerEntry(kInvariant, invariantNew), IntegerEntry(kBalanceA, (balanceA + amountEnrollA)), IntegerEntry(kBalanceB, (balanceB + amountEnrollB))]
905 905                                          else throw("Strict value is not equal to itself.")
906 906                                      }
907 907                                  else throw("Strict value is not equal to itself.")
908 908                              }
909 909              }
910 910          else throw("Strict value is not equal to itself.")
911 911      })
912 912  
913 913  
914 914  
915 915  @Callable(i)
916 916  func keepLimitForFirstHarvest (shareLimit) = valueOrElse(isActive(), valueOrElse(isAdminCall(i), [IntegerEntry(kShareLimit, shareLimit)]))
917 917  
918 918  
919 919  
920 920  @Callable(i)
921 921  func stakeUnstake (stake,amount,assetIdString) = if ((i.caller != this))
922 922      then throw("Only contract itself can invoke this function")
923 923      else {
924 924          let $t03688936992 = calcStakingParams(stake, amount, fromBase58String(assetIdString))
925 925          let call = $t03688936992._1
926 926          let addr = $t03688936992._2
927 927          let params = $t03688936992._3
928 928          let payments = $t03688936992._4
929 929          let inv = invoke(addr, call, params, payments)
930 930          if ((inv == inv))
931 931              then nil
932 932              else throw("Strict value is not equal to itself.")
933 933          }
934 934  
935 935  
936 936  
937 937  @Callable(i)
938 938  func replenishWithTwoTokens () = valueOrElse(isActive(), valueOrElse(isDepricated(), replenishWithTwoTokensCalc(i, false, 0)))
939 939  
940 940  
941 941  
942 942  @Callable(i)
943 943  func replenishWithOneToken (virtualSwapTokenPay,virtualSwapTokenGet) = valueOrElse(isActive(), valueOrElse(isDepricated(), replenishWithOneTokenCalc(i, virtualSwapTokenPay, virtualSwapTokenGet, false, 0)))
944 944  
945 945  
946 946  
947 947  @Callable(i)
948 948  func withdraw () = valueOrElse(isActive(), withdrawCalc(i, 0))
949 949  
950 950  
951 951  @Verifier(tx)
952 952  func verify () = {
953 953      let multiSignedByAdmins = {
954 954          let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
955 955              then 1
956 956              else 0
957 957          let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
958 958              then 1
959 959              else 0
960 960          let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
961 961              then 1
962 962              else 0
963 963          (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
964 964          }
965 965      match tx {
966 966          case inv: InvokeScriptTransaction => 
967 967              let callTakeIntoAccount = if ((inv.dApp == this))
968 968                  then (inv.function == "takeIntoAccountExtraFunds")
969 969                  else false
970 970              let signedByAdmin = if (if (if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
971 971                  then true
972 972                  else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey2))
973 973                  then true
974 974                  else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey3))
975 975                  then true
976 976                  else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKeyInvoke)
977 977              if (if (callTakeIntoAccount)
978 978                  then signedByAdmin
979 979                  else false)
980 980                  then true
981 981                  else multiSignedByAdmins
982 982          case _ => 
983 983              multiSignedByAdmins
984 984      }
985 985      }
986 986

Old	New	Differences
1	1	{-# STDLIB_VERSION 6 #-}
2	2	{-# SCRIPT_TYPE ACCOUNT #-}
3	3	{-# CONTENT_TYPE DAPP #-}
4	4	let version = "2.0.0"
5	5
6	6	let kVersion = "version"
7	7
8	8	let kActive = "active"
9	9
10	10	let kActiveGlob = "active_all_contracts"
11	11
12	12	let kDeprecated = "deprecated_"
13	13
14	14	let kAssetIdA = "A_asset_id"
15	15
16	16	let kAssetIdB = "B_asset_id"
17	17
18	18	let kBalanceA = "A_asset_balance"
19	19
20	20	let kBalanceB = "B_asset_balance"
21	21
22	22	let kShareAssetId = "share_asset_id"
23	23
24	24	let kShareAssetSupply = "share_asset_supply"
25	25
26	26	let kFee = "commission"
27	27
28	28	let kInvariant = "invariant"
29	29
30	30	let kCause = "shutdown_cause"
31	31
32	32	let kUSDNAddress = "staking_usdnnsbt_address"
33	33
34	34	let kEURNAddress = "staking_eurn_address"
35	35
36	36	let kDiscounts = "discounts"
37	37
38	38	let kDiscountValues = "discount_values"
39	39
40	40	let kUserSwopInGov = "_SWOP_amount"
41	41
42	42	let kUserGSwopInGov = "_GSwop_amount"
43	43
44	44	let kFirstHarvest = "first_harvest"
45	45
46	46	let kFirstHarvestHeight = "first_harvest_height"
47	47
48	48	let kShareLimit = "share_limit_on_first_harvest"
49	49
50	50	let kBasePeriod = "base_period"
51	51
52	52	let kPeriodLength = "period_length"
53	53
54	54	let kStartHeight = "start_height"
55	55
56	56	let kDAppThreshold = "dApp_threshold"
57	57
58	58	let kAdminPubKey1 = "admin_pub_1"
59	59
60	60	let kAdminPubKey2 = "admin_pub_2"
61	61
62	62	let kAdminPubKey3 = "admin_pub_3"
63	63
64	64	let kAdminInvokePubKey = "admin_invoke_pub"
65	65
66	66	let kMoneyBoxAddress = "money_box_address"
67	67
68	68	let kGovAddress = "governance_address"
69	69
70	70	let kFarmingAddress = "farming_address"
71	71
72	72	let kVotingAddress = "voting_address"
73	73
74	74	let kUSDNAssetId = "usdn_asset_id"
75	75
76	76	let kStakingAssets = "staking_assets"
77	77
78	78	let oracle = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
79	79
80	80	func getBase58FromOracle (key) = match getString(oracle, key) {
81	81	case string: String =>
82	82	fromBase58String(string)
83	83	case nothing =>
84	84	throw((key + "is empty"))
85	85	}
86	86
87	87
88	88	let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
89	89
90	90	let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
91	91
92	92	let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
93	93
94	94	let adminPubKeyInvoke = getBase58FromOracle(kAdminInvokePubKey)
95	95
96	96	let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
97	97
98	98	let govAddress = Address(getBase58FromOracle(kGovAddress))
99	99
100	100	let stakingUSDNAddress = Address(getBase58FromOracle(kUSDNAddress))
101	101
102	102	let votingAddress = Address(getBase58FromOracle(kVotingAddress))
103	103
104	104	let farmingAddress = Address(getBase58FromOracle(kFarmingAddress))
105	105
106	106	let USDN = getBase58FromOracle(kUSDNAssetId)
107	107
108	108	let stakingAssets = getStringValue(oracle, kStakingAssets)
109	109
110	110	let basePeriod = valueOrErrorMessage(getInteger(votingAddress, kBasePeriod), "Empty kBasePeriod")
111	111
112	112	let startHeight = valueOrErrorMessage(getInteger(votingAddress, kStartHeight), "Empty kStartHeight")
113	113
114	114	let periodLength = valueOrErrorMessage(getInteger(votingAddress, kPeriodLength), "Empty kPeriodLength")
115	115
116	116	let firstHarvestEndPeriod = ((basePeriod + ((height - startHeight) / periodLength)) + 3)
117	117
118	118	let active = getBooleanValue(this, kActive)
119	119
120	120	let activeGlob = valueOrElse(getBoolean(oracle, kActiveGlob), true)
121	121
122	122	let deprecatedPool = valueOrElse(getBoolean(oracle, (kDeprecated + toString(this))), false)
123	123
124	124	let strAssetIdA = getStringValue(this, kAssetIdA)
125	125
126	126	let strAssetIdB = getStringValue(this, kAssetIdB)
127	127
128	128	let assetIdA = if ((strAssetIdA == "WAVES"))
129	129	then unit
130	130	else fromBase58String(strAssetIdA)
131	131
132	132	let assetIdB = if ((strAssetIdB == "WAVES"))
133	133	then unit
134	134	else fromBase58String(strAssetIdB)
135	135
136	136	let assetNameA = match assetIdA {
137	137	case id: ByteVector =>
138	138	value(assetInfo(id)).name
139	139	case waves: Unit =>
140	140	"WAVES"
141	141	case _ =>
142	142	throw("Match error")
143	143	}
144	144
145	145	let assetNameB = match assetIdB {
146	146	case id: ByteVector =>
147	147	value(assetInfo(id)).name
148	148	case waves: Unit =>
149	149	"WAVES"
150	150	case _ =>
151	151	throw("Match error")
152	152	}
153	153
154	154	let balanceA = getIntegerValue(this, kBalanceA)
155	155
156	156	let balanceB = getIntegerValue(this, kBalanceB)
157	157
158	158	let shareAssetId = fromBase58String(getStringValue(this, kShareAssetId))
159	159
160	160	let shareAssetSupply = getIntegerValue(this, kShareAssetSupply)
161	161
162	162	let invariant = getIntegerValue(this, kInvariant)
163	163
164	164	let fee = getIntegerValue(this, kFee)
165	165
166	166	let feeGovernance = fraction(fee, 40, 100)
167	167
168	168	let feeScale6 = 1000000
169	169
170	170	let scale3 = 1000
171	171
172	172	let scale8 = 100000000
173	173
174	174	let scale16 = 10000000000000000
175	175
176	176	let digits8 = 8
177	177
178	178	let exchangeRatioLimitMin = 60000000
179	179
180	180	let exchangeRatioLimitMax = 140000000
181	181
182	182	let alpha = 50
183	183
184	184	let alphaDigits = 2
185	185
186	186	let beta = 4600000000000000
187	187
188	188	func accountBalance (assetId) = match assetId {
189	189	case id: ByteVector =>
190	190	assetBalance(this, id)
191	191	case waves: Unit =>
192	192	wavesBalance(this).available
193	193	case _ =>
194	194	throw("Match error")
195	195	}
196	196
197	197
198	198	func stakedAmount (assetId) = {
199	199	let stakedAmountCalculated = match assetId {
200	200	case aId: ByteVector =>
201	201	if ((aId == USDN))
202	202	then getInteger(stakingUSDNAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(this)))
203	203	else 0
204	204	case _: Unit =>
205	205	0
206	206	case _ =>
207	207	throw("Match error")
208	208	}
209	209	match stakedAmountCalculated {
210	210	case i: Int =>
211	211	i
212	212	case _ =>
213	213	0
214	214	}
215	215	}
216	216
217	217
218	218	let stakedAmountA = stakedAmount(assetIdA)
219	219
220	220	let stakedAmountB = stakedAmount(assetIdB)
221	221
222	222	let availableBalanceA = (balanceA - stakedAmountA)
223	223
224	224	let availableBalanceB = (balanceB - stakedAmountB)
225	225
226	226	let accountBalanceWithStakedA = (accountBalance(assetIdA) + stakedAmountA)
227	227
228	228	let accountBalanceWithStakedB = (accountBalance(assetIdB) + stakedAmountB)
229	229
230	230	let hasEnoughBalance = if ((accountBalanceWithStakedA >= balanceA))
231	231	then (accountBalanceWithStakedB >= balanceB)
232	232	else false
233	233
234	234	func skewness (x,y) = ((fraction(scale16, x, y) + fraction(scale16, y, x)) / 2)
235	235
236	236
237	237	func invariantCalc (x,y) = {
238	238	let sk = skewness(x, y)
239	239	(fraction((x + y), scale16, pow(sk, digits8, alpha, alphaDigits, digits8, CEILING)) + (2 * fraction(toInt(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN)), pow((sk - beta), digits8, alpha, alphaDigits, digits8, DOWN), scale8)))
240	240	}
241	241
242	242
243	243	func calculateSendAmount (amountToSendEstimated,minTokenReceiveAmount,tokenReceiveAmount,tokenId,balcA,balcB,invCur) = {
244	244	let worstAllowedNewInvariantRatio = (scale16 - ((scale16 * 1) / 10000000))
245	245	let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
246	246	let x = (balcA + tokenReceiveAmount)
247	247	let y = (balcB + tokenReceiveAmount)
248	248	func getStepAmount (acc,step) = if ((acc._1 == -1))
249	249	then {
250	250	let amountToSend = (amountToSendEstimated - (((step * deltaBetweenMaxAndMinSendValue) / 3) / scale3))
251	251	let stepInvariant = if ((tokenId == assetIdA))
252	252	then invariantCalc(x, (balcB - amountToSend))
253	253	else invariantCalc((balcA - amountToSend), y)
254	254	if ((stepInvariant > invCur))
255	255	then $Tuple2(amountToSend, stepInvariant)
256	256	else $Tuple2(-1, 0)
257	257	}
258	258	else acc
259	259
260	260	let amountToSendMin = getStepAmount($Tuple2(-1, 0), 3000)
261	261	if ((0 > amountToSendMin._1))
262	262	then throw("Price is worse than minReceived")
263	263	else {
264	264	let invEstimated = if ((tokenId == assetIdA))
265	265	then invariantCalc(x, (balcB - amountToSendEstimated))
266	266	else if ((tokenId == assetIdB))
267	267	then invariantCalc((balcA - amountToSendEstimated), y)
268	268	else throw("Wrong asset in payment")
269	269	if ((invCur > invEstimated))
270	270	then if ((worstAllowedNewInvariantRatio >= fraction(scale16, invCur, invEstimated)))
271	271	then throw("The requested price is too not profitable for user")
272	272	else {
273	273	let a = {
274	274	let $l = [25, 200, 500]
275	275	let $s = size($l)
276	276	let $acc0 = $Tuple2(-1, 0)
277	277	func $f0_1 ($a,$i) = if (($i >= $s))
278	278	then $a
279	279	else getStepAmount($a, $l[$i])
280	280
281	281	func $f0_2 ($a,$i) = if (($i >= $s))
282	282	then $a
283	283	else throw("List size exceeds 3")
284	284
285	285	$f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
286	286	}
287	287	if ((0 > a._1))
288	288	then amountToSendMin._1
289	289	else a._1
290	290	}
291	291	else {
292	292	let a = {
293	293	let $l = [-500, -200, -25]
294	294	let $s = size($l)
295	295	let $acc0 = $Tuple2(-1, 0)
296	296	func $f0_1 ($a,$i) = if (($i >= $s))
297	297	then $a
298	298	else getStepAmount($a, $l[$i])
299	299
300	300	func $f0_2 ($a,$i) = if (($i >= $s))
301	301	then $a
302	302	else throw("List size exceeds 3")
303	303
304	304	$f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
305	305	}
306	306	let tupleSendBetter = if ((0 > a._1))
307	307	then $Tuple2(amountToSendEstimated, invEstimated)
308	308	else a
309	309	if ((worstAllowedNewInvariantRatio >= fraction(scale16, invCur, tupleSendBetter._2)))
310	310	then throw("The requested price is too not profitable for user")
311	311	else tupleSendBetter._1
312	312	}
313	313	}
314	314	}
315	315
316	316
317	317	func getAssetInfo (assetId) = match assetId {
318	318	case id: ByteVector =>
319	319	let stringId = toBase58String(id)
320	320	let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
321	321	$Tuple3(stringId, info.name, info.decimals)
322	322	case waves: Unit =>
323	323	$Tuple3("WAVES", "WAVES", 8)
324	324	case _ =>
325	325	throw("Match error")
326	326	}
327	327
328	328
329	329	func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
330	330
331	331
332	332	func throwIsActive () = throw("DApp is already active")
333	333
334	334
335	335	func isActive () = if (if (active)
336	336	then activeGlob
337	337	else false)
338	338	then unit
339	339	else throw("DApp is inactive at this moment")
340	340
341	341
342	342	func isDepricated () = if (!(deprecatedPool))
343	343	then unit
344	344	else throw("Pool is deprecated. Only withdraw action allowed.")
345	345
346	346
347	347	func isAdminCall (i) = if (containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey))
348	348	then unit
349	349	else throw("Only admin can call this function")
350	350
351	351
352	352	func isSelfCall (i) = if ((this == i.caller))
353	353	then unit
354	354	else throw("Only contract itself can call this function")
355	355
356	356
357	357	func throwAssets () = throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
358	358
359	359
360	360	func throwOnePayment () = throw("One attached payment expected")
361	361
362	362
363	363	func suspendSuspicious () = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB) + ". State: ") + toString(accountBalance(assetIdA))) + " ") + assetNameA) + ", ") + toString(accountBalance(assetIdB))) + " ") + assetNameB))
364	364
365	365
366	366	func calcStakingFuncAndAddres (stake,assetId) = if (stake)
367	367	then $Tuple2("lockNeutrino", stakingUSDNAddress)
368	368	else $Tuple2("unlockNeutrino", stakingUSDNAddress)
369	369
370	370
371	371	func calcStakingParams (stake,amount,assetId) = if (stake)
372	372	then {
373	373	let $t01044410510 = calcStakingFuncAndAddres(stake, assetId)
374	374	let call = $t01044410510._1
375	375	let stakingAddr = $t01044410510._2
376	376	$Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
377	377	}
378	378	else {
379	379	let $t01059610662 = calcStakingFuncAndAddres(stake, assetId)
380	380	let call = $t01059610662._1
381	381	let stakingAddr = $t01059610662._2
382	382	$Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
383	383	}
384	384
385	385
386	386	func calculateFeeDiscount (userAddr) = {
387	387	let swopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserSwopInGov)), 0)
388	388	let gSwopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserGSwopInGov)), swopAmount)
389	389	let discountValues = split(getStringValue(oracle, kDiscountValues), ",")
390	390	let discounts = split(getStringValue(oracle, kDiscounts), ",")
391	391	if (if ((gSwopAmount >= parseIntValue(discountValues[0])))
392	392	then (parseIntValue(discountValues[1]) > gSwopAmount)
393	393	else false)
394	394	then (feeScale6 - parseIntValue(discounts[0]))
395	395	else if (if ((gSwopAmount >= parseIntValue(discountValues[1])))
396	396	then (parseIntValue(discountValues[2]) > gSwopAmount)
397	397	else false)
398	398	then (feeScale6 - parseIntValue(discounts[1]))
399	399	else if (if ((gSwopAmount >= parseIntValue(discountValues[2])))
400	400	then (parseIntValue(discountValues[3]) > gSwopAmount)
401	401	else false)
402	402	then (feeScale6 - parseIntValue(discounts[2]))
403	403	else if (if ((gSwopAmount >= parseIntValue(discountValues[3])))
404	404	then (parseIntValue(discountValues[4]) > gSwopAmount)
405	405	else false)
406	406	then (feeScale6 - parseIntValue(discounts[3]))
407	407	else if ((gSwopAmount >= parseIntValue(discountValues[4])))
408	408	then (feeScale6 - parseIntValue(discounts[4]))
409	409	else feeScale6
410	410	}
411	411
412	412
413	413	func checkDAppThreshold (newBalanceA,newBalanceB,pmtAssetId) = {
414	414	let dAppThreshold = getIntegerValue(this, kDAppThreshold)
415	415	let ratio = if (if ((pmtAssetId == assetIdA))
416	416	then (newBalanceA > newBalanceB)
417	417	else false)
418	418	then fraction(newBalanceA, 1, newBalanceB, CEILING)
419	419	else if (if ((pmtAssetId == assetIdB))
420	420	then (newBalanceB > newBalanceA)
421	421	else false)
422	422	then fraction(newBalanceB, 1, newBalanceA, CEILING)
423	423	else 0
424	424	if ((ratio > dAppThreshold))
425	425	then {
426	426	let $t01240712515 = if ((pmtAssetId == assetIdA))
427	427	then $Tuple2(assetNameB, assetNameA)
428	428	else $Tuple2(assetNameA, assetNameB)
429	429	let token1 = $t01240712515._1
430	430	let token2 = $t01240712515._2
431	431	throw((((("Buying " + token1) + " is temporarily unavailable due to the ") + token2) + " depeg"))
432	432	}
433	433	else true
434	434	}
435	435
436	436
437	437	func replenishWithTwoTokensCalc (i,stakeFarming,lockType) = {
438	438	let pmtAssetIdA = i.payments[0].assetId
439	439	let pmtAssetIdB = i.payments[1].assetId
440	440	let ratioShareTokensInA = fraction(scale8, i.payments[0].amount, balanceA)
441	441	let ratioShareTokensInB = fraction(scale8, i.payments[1].amount, balanceB)
442	442	let $t01297513052 = getAssetInfo(pmtAssetIdA)
443	443	let pmtStrAssetIdA = $t01297513052._1
444	444	let pmtAssetNameA = $t01297513052._2
445	445	let pmtDecimalsA = $t01297513052._3
446	446	let $t01305713174 = getAssetInfo(pmtAssetIdB)
447	447	let pmtStrAssetIdB = $t01305713174._1
448	448	let pmtAssetNameB = $t01305713174._2
449	449	let pmtDecimalsB = $t01305713174._3
450	450	let $t01317913683 = if ((ratioShareTokensInB > ratioShareTokensInA))
451	451	then {
452	452	let pmt = fraction(balanceB, ratioShareTokensInA, scale8, CEILING)
453	453	$Tuple5(i.payments[0].amount, pmt, (i.payments[1].amount - pmt), pmtAssetIdB, ratioShareTokensInA)
454	454	}
455	455	else {
456	456	let pmt = fraction(balanceA, ratioShareTokensInB, scale8, CEILING)
457	457	$Tuple5(pmt, i.payments[1].amount, (i.payments[0].amount - pmt), pmtAssetIdA, ratioShareTokensInB)
458	458	}
459	459	let pmtAmountA = $t01317913683._1
460	460	let pmtAmountB = $t01317913683._2
461	461	let change = $t01317913683._3
462	462	let changeAssetId = $t01317913683._4
463	463	let shareTokenRatio = $t01317913683._5
464	464	let shareTokenToPayAmount = fraction(shareTokenRatio, shareAssetSupply, scale8)
465	465	if (if ((size(i.payments) != 2))
466	466	then (size(i.payments) != 3)
467	467	else false)
468	468	then throw("Two or three payments expected")
469	469	else if (if ((pmtAssetIdA != assetIdA))
470	470	then true
471	471	else (pmtAssetIdB != assetIdB))
472	472	then throwAssets()
473	473	else if ((shareTokenToPayAmount == 0))
474	474	then throw("Too small amount to replenish")
475	475	else if ((0 > change))
476	476	then throw("Change < 0")
477	477	else if (!(hasEnoughBalance))
478	478	then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
479	479	else {
480	480	let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
481	481	then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
482	482	else 0
483	483	if ((stake1 == stake1))
484	484	then {
485	485	let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
486	486	then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
487	487	else 0
488	488	if ((stake2 == stake2))
489	489	then {
490	490	let scriptActions = [IntegerEntry(kBalanceA, (balanceA + pmtAmountA)), IntegerEntry(kBalanceB, (balanceB + pmtAmountB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(kInvariant, invariantCalc((balanceA + pmtAmountA), (balanceB + pmtAmountB))), ScriptTransfer(i.caller, change, changeAssetId)]
491	491	if (stakeFarming)
492	492	then {
493	493	let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmount)] ++ (if ((size(i.payments) == 3))
494	494	then [AttachedPayment(if ((i.payments[2].assetId == base58''))
495	495	then unit
496	496	else i.payments[2].assetId, i.payments[2].amount)]
497	497	else nil))
498	498	let re = invoke(this, "reissueShare", [shareTokenToPayAmount], nil)
499	499	if ((re == re))
500	500	then {

github/deemru/w8io/026f985 
87.03 ms ◑