w8 · tx · 9m8···HfE

tx · 9m8Y3ghFXRA495jKNXFiVKwvopdSLv3MCM4MrdVkGHfE

3PPH7x7iqobW5ziyiRCic19rQqKr6nPYaK1:  -0.03600000 Waves

2022.11.25 10:56 [3397801] smart account 3PPH7x7iqobW5ziyiRCic19rQqKr6nPYaK1 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9m8Y3ghFXRA495jKNXFiVKwvopdSLv3MCM4MrdVkGHfE",
    "fee": 3600000,
    "feeAssetId": null,
    "timestamp": 1669362808181,
    "version": 2,
    "chainId": 87,
    "sender": "3PPH7x7iqobW5ziyiRCic19rQqKr6nPYaK1",
    "senderPublicKey": "5aTg4oxM77iRmUGy3y8Zavn5fhVbgtUciAuSGfCJAYjn",
    "proofs": [
        "",
        "38xogipeFQKgjRmSF2VadEyHdX5y4GQCXdh3kkRf5hLz8W1LyJoHQkA7wB84Dmj2uShUvK8686VVhjSTvXwJ3No4",
        "QwPrgUYPSfeWsm2gdbuQubV3jv7MxBSwxjvxRCX27wEUjnXnC4EWwyW1mS3f8iMLWrRboiiKAu3vhLMMF8xrwGD"
    ],
    "script": "base64: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",
    "height": 3397801,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 7qdbm9wRBNoPma9aig3p2teYZgQq2edusEK7qTCpaRLr
Next: G5aKQKKgTd2VJmYRxhWz3Z2oifsmJc2GQUvCaagyTPLT

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

Old	New		Differences
1		-	{-# STDLIB_VERSION 5 #-}
	1	+	{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let version = "2.0.0"

6	6		let kVersion = "version"
7	7
8	8		let kActive = "active"
	9	+
	10	+	let kActiveGlob = "active_all_contracts"
9	11
10	12		let kAssetIdA = "A_asset_id"
11	13

35	37
36	38		let kUserSwopInGov = "_SWOP_amount"
37	39
	40	+	let kUserGSwopInGov = "_GSwop_amount"
	41	+
38	42		let kFirstHarvest = "first_harvest"
39	43
40	44		let kFirstHarvestHeight = "first_harvest_height"

59	63
60	64		let kGovAddress = "governance_address"
61	65
	66	+	let kFarmingAddress = "farming_address"
	67	+
62	68		let kVotingAddress = "voting_address"
	69	+
	70	+	let kUSDNAssetId = "usdn_asset_id"
	71	+
	72	+	let kStakingAssets = "staking_assets"
63	73
64	74		let oracle = Address(base58'3PEbqViERCoKnmcSULh6n2aiMvUdSQdCsom')
65	75

87	97
88	98		let votingAddress = Address(getBase58FromOracle(kVotingAddress))
89	99
90		-	let ~~USDN~~ = ~~base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'~~
	100	+	let farmingAddress = Address(getBase58FromOracle(kFarmingAddress))
91	101
92		-	let stakingAssets = [toBase58String(USDN)]
	102	+	let USDN = getBase58FromOracle(kUSDNAssetId)
	103	+
	104	+	let stakingAssets = getStringValue(oracle, kStakingAssets)
93	105
94	106		let basePeriod = valueOrErrorMessage(getInteger(votingAddress, kBasePeriod), "Empty kBasePeriod")
95	107

100	112		let firstHarvestEndPeriod = ((basePeriod + ((height - startHeight) / periodLength)) + 3)
101	113
102	114		let active = getBooleanValue(this, kActive)
	115	+
	116	+	let activeGlob = valueOrElse(getBoolean(oracle, kActiveGlob), true)
103	117
104	118		let strAssetIdA = getStringValue(this, kAssetIdA)
105	119

152	166		let scale8 = 100000000
153	167
154	168		let scale16 = 10000000000000000
155		-
156		-	let slippageScale3 = 1000
157	169
158	170		let digits8 = 8
159	171

226	238		}
227	239
228	240
229		-	func calculateSendAmount (amountToSendEstimated,minTokenReceiveAmount,tokenReceiveAmount,tokenId) = {
	241	+	func calculateSendAmount (amountToSendEstimated,minTokenReceiveAmount,tokenReceiveAmount,tokenId,balcA,balcB,invCur) = {
230	242		let worstAllowedNewInvariantRatio = (scale16 - ((scale16 * 1) / 10000000))
231	243		let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
232		-	let x = (~~balanceA~~ + tokenReceiveAmount)
233		-	let y = (~~balanceB~~ + tokenReceiveAmount)
	244	+	let x = (balcA + tokenReceiveAmount)
	245	+	let y = (balcB + tokenReceiveAmount)
234	246		func getStepAmount (acc,step) = if ((acc._1 == -1))
235	247		then {
236	248		let amountToSend = (amountToSendEstimated - (((step * deltaBetweenMaxAndMinSendValue) / 3) / scale3))
237	249		let stepInvariant = if ((tokenId == assetIdA))
238		-	then invariantCalc(x, (~~balanceB~~ - amountToSend))
239		-	else invariantCalc((~~balanceA~~ - amountToSend), y)
240		-	if ((stepInvariant > ~~invariant~~))
	250	+	then invariantCalc(x, (balcB - amountToSend))
	251	+	else invariantCalc((balcA - amountToSend), y)
	252	+	if ((stepInvariant > invCur))
241	253		then $Tuple2(amountToSend, stepInvariant)
242	254		else $Tuple2(-1, 0)
243	255		}

248	260		then throw("Price is worse than minReceived")
249	261		else {
250	262		let invEstimated = if ((tokenId == assetIdA))
251		-	then invariantCalc(x, (~~balanceB~~ - amountToSendEstimated))
	263	+	then invariantCalc(x, (balcB - amountToSendEstimated))
252	264		else if ((tokenId == assetIdB))
253		-	then invariantCalc((~~balanceA~~ - amountToSendEstimated), y)
	265	+	then invariantCalc((balcA - amountToSendEstimated), y)
254	266		else throw("Wrong asset in payment")
255		-	if ((~~invariant~~ > invEstimated))
256		-	then if ((worstAllowedNewInvariantRatio >= fraction(scale16, ~~invariant~~, invEstimated)))
	267	+	if ((invCur > invEstimated))
	268	+	then if ((worstAllowedNewInvariantRatio >= fraction(scale16, invCur, invEstimated)))
257	269		then throw("The requested price is too not profitable for user")
258	270		else {
259	271		let a = {

292	304		let tupleSendBetter = if ((0 > a._1))
293	305		then $Tuple2(amountToSendEstimated, invEstimated)
294	306		else a
295		-	if ((worstAllowedNewInvariantRatio >= fraction(scale16, ~~invariant~~, tupleSendBetter._2)))
	307	+	if ((worstAllowedNewInvariantRatio >= fraction(scale16, invCur, tupleSendBetter._2)))
296	308		then throw("The requested price is too not profitable for user")
297	309		else tupleSendBetter._1
298	310		}

318	330		func throwIsActive () = throw("DApp is already active")
319	331
320	332
321		-	func isActive () = if (active)
	333	+	func isActive () = if (if (active)
	334	+	then activeGlob
	335	+	else false)
322	336		then unit
323	337		else throw("DApp is inactive at this moment")
324	338

326	340		func isAdminCall (i) = if (containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey))
327	341		then unit
328	342		else throw("Only admin can call this function")
	343	+
	344	+
	345	+	func isSelfCall (i) = if ((this == i.caller))
	346	+	then unit
	347	+	else throw("Only contract itself can call this function")
329	348
330	349
331	350		func throwAssets () = throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))

347	366
348	367		func calcStakingParams (stake,amount,assetId) = if (stake)
349	368		then {
350		-	let $~~t01006410130~~ = calcStakingFuncAndAddres(stake, assetId)
351		-	let call = $~~t01006410130~~._1
352		-	let stakingAddr = $~~t01006410130~~._2
	369	+	let $t01050410570 = calcStakingFuncAndAddres(stake, assetId)
	370	+	let call = $t01050410570._1
	371	+	let stakingAddr = $t01050410570._2
353	372		$Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
354	373		}
355	374		else {
356		-	let $~~t01021610282~~ = calcStakingFuncAndAddres(stake, assetId)
357		-	let call = $~~t01021610282~~._1
358		-	let stakingAddr = $~~t01021610282~~._2
	375	+	let $t01065610722 = calcStakingFuncAndAddres(stake, assetId)
	376	+	let call = $t01065610722._1
	377	+	let stakingAddr = $t01065610722._2
359	378		$Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
360	379		}
361	380
362	381
363	382		func calculateFeeDiscount (userAddr) = {
364	383		let swopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserSwopInGov)), 0)
	384	+	let gSwopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserGSwopInGov)), 0)
365	385		let discountValues = split(getStringValue(oracle, kDiscountValues), ",")
366	386		let discounts = split(getStringValue(oracle, kDiscounts), ",")
367		-	if (if ((~~swopAmount~~ >= parseIntValue(discountValues[0])))
368		-	then (parseIntValue(discountValues[1]) > ~~swopAmount~~)
	387	+	if (if ((gSwopAmount >= parseIntValue(discountValues[0])))
	388	+	then (parseIntValue(discountValues[1]) > gSwopAmount)
369	389		else false)
370	390		then (feeScale6 - parseIntValue(discounts[0]))
371		-	else if (if ((~~swopAmount~~ >= parseIntValue(discountValues[1])))
372		-	then (parseIntValue(discountValues[2]) > ~~swopAmount~~)
	391	+	else if (if ((gSwopAmount >= parseIntValue(discountValues[1])))
	392	+	then (parseIntValue(discountValues[2]) > gSwopAmount)
373	393		else false)
374	394		then (feeScale6 - parseIntValue(discounts[1]))
375		-	else if (if ((~~swopAmount~~ >= parseIntValue(discountValues[2])))
376		-	then (parseIntValue(discountValues[3]) > ~~swopAmount~~)
	395	+	else if (if ((gSwopAmount >= parseIntValue(discountValues[2])))
	396	+	then (parseIntValue(discountValues[3]) > gSwopAmount)
377	397		else false)
378	398		then (feeScale6 - parseIntValue(discounts[2]))
379		-	else if (if ((~~swopAmount~~ >= parseIntValue(discountValues[3])))
380		-	then (parseIntValue(discountValues[4]) > ~~swopAmount~~)
	399	+	else if (if ((gSwopAmount >= parseIntValue(discountValues[3])))
	400	+	then (parseIntValue(discountValues[4]) > gSwopAmount)
381	401		else false)
382	402		then (feeScale6 - parseIntValue(discounts[3]))
383		-	else if ((~~swopAmount~~ >= parseIntValue(discountValues[4])))
	403	+	else if ((gSwopAmount >= parseIntValue(discountValues[4])))
384	404		then (feeScale6 - parseIntValue(discounts[4]))
385	405		else feeScale6
386	406		}
387	407
388	408
389		-	@Callable(i)
390		-	func init (firstHarvest) = {
391		-	let $t01147511552 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
392		-	let pmtAmountA = $t01147511552._1
393		-	let pmtAssetIdA = $t01147511552._2
394		-	let $t01155711634 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
395		-	let pmtAmountB = $t01155711634._1
396		-	let pmtAssetIdB = $t01155711634._2
397		-	let $t01163911716 = getAssetInfo(pmtAssetIdA)
398		-	let pmtStrAssetIdA = $t01163911716._1
399		-	let pmtAssetNameA = $t01163911716._2
400		-	let pmtDecimalsA = $t01163911716._3
401		-	let $t01172111798 = getAssetInfo(pmtAssetIdB)
402		-	let pmtStrAssetIdB = $t01172111798._1
403		-	let pmtAssetNameB = $t01172111798._2
404		-	let pmtDecimalsB = $t01172111798._3
405		-	if (isDefined(getBoolean(this, kActive)))
406		-	then throwIsActive()
407		-	else if ((pmtAssetIdA == pmtAssetIdB))
408		-	then throw("Assets must be different")
409		-	else {
410		-	let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
411		-	let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
412		-	let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
413		-	let shareInitialSupply = fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN), pow(10, 0, shareDecimals, 0, 0, DOWN))
414		-	let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
415		-	let shareIssueId = calculateAssetId(shareIssue)
416		-	let invariantCalculated = invariantCalc(pmtAmountA, pmtAmountB)
417		-	let stake1 = if (containsElement(stakingAssets, pmtStrAssetIdA))
418		-	then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
419		-	else 0
420		-	if ((stake1 == stake1))
421		-	then {
422		-	let stake2 = if (containsElement(stakingAssets, pmtStrAssetIdB))
423		-	then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
424		-	else 0
425		-	if ((stake2 == stake2))
426		-	then {
427		-	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")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
428		-	if (firstHarvest)
429		-	then (baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))])
430		-	else baseEntry
431		-	}
432		-	else throw("Strict value is not equal to itself.")
433		-	}
434		-	else throw("Strict value is not equal to itself.")
435		-	}
436		-	}
437		-
438		-
439		-
440		-	@Callable(i)
441		-	func replenishWithTwoTokens () = valueOrElse(isActive(), {
	409	+	func replenishWithTwoTokensCalc (i,stakeFarming,lockType) = {
442	410		let pmtAssetIdA = i.payments[0].assetId
443	411		let pmtAssetIdB = i.payments[1].assetId
444	412		let ratioShareTokensInA = fraction(scale8, i.payments[0].amount, balanceA)
445	413		let ratioShareTokensInB = fraction(scale8, i.payments[1].amount, balanceB)
446		-	let $~~t01474614823~~ = getAssetInfo(pmtAssetIdA)
447		-	let pmtStrAssetIdA = $~~t01474614823~~._1
448		-	let pmtAssetNameA = $~~t01474614823~~._2
449		-	let pmtDecimalsA = $~~t01474614823~~._3
450		-	let $~~t01482814945~~ = getAssetInfo(pmtAssetIdB)
451		-	let pmtStrAssetIdB = $~~t01482814945~~._1
452		-	let pmtAssetNameB = $~~t01482814945~~._2
453		-	let pmtDecimalsB = $~~t01482814945~~._3
454		-	let $~~t01495015454~~ = if ((ratioShareTokensInB > ratioShareTokensInA))
	414	+	let $t01230412381 = getAssetInfo(pmtAssetIdA)
	415	+	let pmtStrAssetIdA = $t01230412381._1
	416	+	let pmtAssetNameA = $t01230412381._2
	417	+	let pmtDecimalsA = $t01230412381._3
	418	+	let $t01238612503 = getAssetInfo(pmtAssetIdB)
	419	+	let pmtStrAssetIdB = $t01238612503._1
	420	+	let pmtAssetNameB = $t01238612503._2
	421	+	let pmtDecimalsB = $t01238612503._3
	422	+	let $t01250813012 = if ((ratioShareTokensInB > ratioShareTokensInA))
455	423		then {
456	424		let pmt = fraction(balanceB, ratioShareTokensInA, scale8, CEILING)
457	425		$Tuple5(i.payments[0].amount, pmt, (i.payments[1].amount - pmt), pmtAssetIdB, ratioShareTokensInA)

460	428		let pmt = fraction(balanceA, ratioShareTokensInB, scale8, CEILING)
461	429		$Tuple5(pmt, i.payments[1].amount, (i.payments[0].amount - pmt), pmtAssetIdA, ratioShareTokensInB)
462	430		}
463		-	let pmtAmountA = $~~t01495015454~~._1
464		-	let pmtAmountB = $~~t01495015454~~._2
465		-	let change = $~~t01495015454~~._3
466		-	let changeAssetId = $~~t01495015454~~._4
467		-	let shareTokenRatio = $~~t01495015454~~._5
	431	+	let pmtAmountA = $t01250813012._1
	432	+	let pmtAmountB = $t01250813012._2
	433	+	let change = $t01250813012._3
	434	+	let changeAssetId = $t01250813012._4
	435	+	let shareTokenRatio = $t01250813012._5
468	436		let shareTokenToPayAmount = fraction(shareTokenRatio, shareAssetSupply, scale8)
469		-	if ((size(i.payments) != 2))
470		-	then throw("Two attached assets expected")
	437	+	if (if ((size(i.payments) != 2))
	438	+	then (size(i.payments) != 3)
	439	+	else false)
	440	+	then throw("Two or three payments expected")
471	441		else if (if ((pmtAssetIdA != assetIdA))
472	442		then true
473	443		else (pmtAssetIdB != assetIdB))

479	449		else if (!(hasEnoughBalance))
480	450		then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
481	451		else {
482		-	let stake1 = if (~~containsElement~~(stakingAssets, pmtStrAssetIdA))
	452	+	let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
483	453		then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
484	454		else 0
485	455		if ((stake1 == stake1))
486	456		then {
487		-	let stake2 = if (~~containsElement~~(stakingAssets, pmtStrAssetIdB))
	457	+	let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
488	458		then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
489	459		else 0
490	460		if ((stake2 == stake2))
491		-	then [IntegerEntry(kBalanceA, (balanceA + pmtAmountA)), IntegerEntry(kBalanceB, (balanceB + pmtAmountB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(kInvariant, invariantCalc((balanceA + pmtAmountA), (balanceB + pmtAmountB))), Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId), ScriptTransfer(i.caller, change, changeAssetId)]
	461	+	then {
	462	+	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)]
	463	+	if (stakeFarming)
	464	+	then {
	465	+	let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmount)] ++ (if ((size(i.payments) == 3))
	466	+	then [AttachedPayment(if ((i.payments[2].assetId == base58''))
	467	+	then unit
	468	+	else i.payments[2].assetId, i.payments[2].amount)]
	469	+	else nil))
	470	+	let re = invoke(this, "reissueShare", [shareTokenToPayAmount], nil)
	471	+	if ((re == re))
	472	+	then {
	473	+	let s = invoke(farmingAddress, "lockShareTokensFromPool", [i.caller.bytes, toString(this), lockType], stPayments)
	474	+	if ((s == s))
	475	+	then scriptActions
	476	+	else throw("Strict value is not equal to itself.")
	477	+	}
	478	+	else throw("Strict value is not equal to itself.")
	479	+	}
	480	+	else (scriptActions ++ [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId)])
	481	+	}
492	482		else throw("Strict value is not equal to itself.")
493	483		}
494	484		else throw("Strict value is not equal to itself.")
495	485		}
496		-	})
	486	+	}
497	487
498	488
499		-
500		-	@Callable(i)
501		-	func replenishWithOneToken (virtualSwapTokenPay,virtualSwapTokenGet) = valueOrElse(isActive(), {
502		-	let $t01718717262 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
503		-	let pmtAmount = $t01718717262._1
504		-	let pmtAssetId = $t01718717262._2
505		-	let $t01726717340 = getAssetInfo(pmtAssetId)
506		-	let pmtStrAssetId = $t01726717340._1
507		-	let pmtAssetName = $t01726717340._2
508		-	let pmtDecimals = $t01726717340._3
	489	+	func replenishWithOneTokenCalc (i,virtualSwapTokenPay,virtualSwapTokenGet,stakeFarming,lockType) = {
	490	+	let $t01540215477 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
	491	+	let pmtAmount = $t01540215477._1
	492	+	let pmtAssetId = $t01540215477._2
	493	+	let $t01548215555 = getAssetInfo(pmtAssetId)
	494	+	let pmtStrAssetId = $t01548215555._1
	495	+	let pmtAssetName = $t01548215555._2
	496	+	let pmtDecimals = $t01548215555._3
509	497		let pmtMinThreshold = 5000000
510	498		let thresholdValueForMinTolerance = 50000000
511	499		let tolerance = if ((thresholdValueForMinTolerance > pmtAmount))

516	504		let slippageValueMinForSwap = (scale8 - ((scale8 * 1) / 10000000))
517	505		if ((pmtMinThreshold > pmtAmount))
518	506		then throw((((("Payment amount " + toString(pmtAmount)) + " does not exceed the minimum amount of ") + toString(pmtMinThreshold)) + " tokens"))
519		-	else if ((size(i.payments) != 1))
520		-	then throwOnePayment()
	507	+	else if (if ((size(i.payments) != 1))
	508	+	then (size(i.payments) != 2)
	509	+	else false)
	510	+	then throw("One or two payments expected")
521	511		else if (!(hasEnoughBalance))
522	512		then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
523	513		else if (if ((pmtAssetId != assetIdA))

525	515		else false)
526	516		then throwAssets()
527	517		else {
528		-	let $~~t01831818960~~ = if ((pmtAssetId == assetIdA))
	518	+	let $t01656217204 = if ((pmtAssetId == assetIdA))
529	519		then $Tuple6((pmtAmount - virtualSwapTokenPay), virtualSwapTokenGet, (balanceA + virtualSwapTokenPay), (balanceB - virtualSwapTokenGet), (balanceA + pmtAmount), balanceB)
530	520		else $Tuple6(virtualSwapTokenGet, (pmtAmount - virtualSwapTokenPay), (balanceA - virtualSwapTokenGet), (balanceB + virtualSwapTokenPay), balanceA, (balanceB + pmtAmount))
531		-	let virtualReplenishA = $~~t01831818960~~._1
532		-	let virtualReplenishB = $~~t01831818960~~._2
533		-	let balanceAfterSwapA = $~~t01831818960~~._3
534		-	let balanceAfterSwapB = $~~t01831818960~~._4
535		-	let newBalanceA = $~~t01831818960~~._5
536		-	let newBalanceB = $~~t01831818960~~._6
	521	+	let virtualReplenishA = $t01656217204._1
	522	+	let virtualReplenishB = $t01656217204._2
	523	+	let balanceAfterSwapA = $t01656217204._3
	524	+	let balanceAfterSwapB = $t01656217204._4
	525	+	let newBalanceA = $t01656217204._5
	526	+	let newBalanceB = $t01656217204._6
537	527		let invariantNew = invariantCalc(balanceAfterSwapA, balanceAfterSwapB)
538	528		let ratioVirtualBalanceToVirtualReplenish = (fraction(scale16, balanceAfterSwapA, balanceAfterSwapB) / fraction(scale8, virtualReplenishA, virtualReplenishB))
539	529		let dAppThresholdAmount = fraction((newBalanceA + newBalanceB), dAppThreshold, (2 * dAppThresholdScale2))

557	547		let shareTokenGovernanceReward = fraction(shareTokenToPayAmount, (feeGovernance / 2), feeScale6)
558	548		let governanceRewardTokenA = fraction(shareTokenGovernanceReward, balanceA, shareAssetSupply)
559	549		let governanceRewardTokenB = fraction(shareTokenGovernanceReward, balanceB, shareAssetSupply)
560		-	let $~~t02094721242~~ = if ((pmtStrAssetId == strAssetIdA))
	550	+	let $t01919419489 = if ((pmtStrAssetId == strAssetIdA))
561	551		then $Tuple3((pmtAmount - governanceRewardTokenA), governanceRewardTokenB, strAssetIdB)
562	552		else $Tuple3((pmtAmount - governanceRewardTokenB), governanceRewardTokenA, strAssetIdA)
563		-	let stakeAmount = $~~t02094721242~~._1
564		-	let unstakeAmount = $~~t02094721242~~._2
565		-	let unstakeAsset = $~~t02094721242~~._3
566		-	let stake1 = if (~~containsElement~~(stakingAssets, pmtStrAssetId))
	553	+	let stakeAmount = $t01919419489._1
	554	+	let unstakeAmount = $t01919419489._2
	555	+	let unstakeAsset = $t01919419489._3
	556	+	let stake1 = if (contains(stakingAssets, pmtStrAssetId))
567	557		then invoke(this, "stakeUnstake", [true, stakeAmount, pmtStrAssetId], nil)
568	558		else 0
569	559		if ((stake1 == stake1))
570	560		then {
571		-	let stake2 = if (~~containsElement~~(stakingAssets, unstakeAsset))
	561	+	let stake2 = if (contains(stakingAssets, unstakeAsset))
572	562		then invoke(this, "stakeUnstake", [false, unstakeAmount, unstakeAsset], nil)
573	563		else 0
574	564		if ((stake2 == stake2))
575		-	then [Reissue(shareAssetId, shareTokenToPayAmountAfterFee, true), ScriptTransfer(i.caller, shareTokenToPayAmountAfterFee, shareAssetId), ScriptTransfer(moneyBoxAddress, governanceRewardTokenA, assetIdA), ScriptTransfer(moneyBoxAddress, governanceRewardTokenB, assetIdB), IntegerEntry(kBalanceA, (newBalanceA - governanceRewardTokenA)), IntegerEntry(kBalanceB, (newBalanceB - governanceRewardTokenB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmountAfterFee)), IntegerEntry(kInvariant, invariantCalc((newBalanceA - governanceRewardTokenA), (newBalanceB - governanceRewardTokenB)))]
	565	+	then {
	566	+	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)]
	567	+	if (stakeFarming)
	568	+	then {
	569	+	let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmountAfterFee)] ++ (if ((size(i.payments) == 2))
	570	+	then [AttachedPayment(if ((i.payments[1].assetId == base58''))
	571	+	then unit
	572	+	else i.payments[1].assetId, i.payments[1].amount)]
	573	+	else nil))
	574	+	let re = invoke(this, "reissueShare", [shareTokenToPayAmountAfterFee], nil)
	575	+	if ((re == re))
	576	+	then {
	577	+	let s = invoke(farmingAddress, "lockShareTokensFromPool", [i.caller.bytes, toString(this), lockType], stPayments)
	578	+	if ((s == s))
	579	+	then scriptActions
	580	+	else throw("Strict value is not equal to itself.")
	581	+	}
	582	+	else throw("Strict value is not equal to itself.")
	583	+	}
	584	+	else (scriptActions ++ [Reissue(shareAssetId, shareTokenToPayAmountAfterFee, true), ScriptTransfer(i.caller, shareTokenToPayAmountAfterFee, shareAssetId)])
	585	+	}
576	586		else throw("Strict value is not equal to itself.")
577	587		}
578	588		else throw("Strict value is not equal to itself.")
579	589		}
580	590		}
581		-	})
	591	+	}
	592	+
	593	+
	594	+	func withdrawCalc (i,unlockAmount) = {
	595	+	let $t02147621811 = if ((size(i.payments) == 1))
	596	+	then if ((i.payments[0].assetId != shareAssetId))
	597	+	then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
	598	+	else $Tuple2(i.payments[0].amount, i.payments[0].assetId)
	599	+	else $Tuple2(0, shareAssetId)
	600	+	let pmtAmount = $t02147621811._1
	601	+	let pmtAssetId = $t02147621811._2
	602	+	if (!(hasEnoughBalance))
	603	+	then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
	604	+	else {
	605	+	let unlock = if ((unlockAmount > 0))
	606	+	then invoke(farmingAddress, "withdrawShareTokensFromPool", [i.caller.bytes, toString(this), unlockAmount], nil)
	607	+	else 0
	608	+	if ((unlock == unlock))
	609	+	then {
	610	+	let withdrawAmount = (pmtAmount + unlockAmount)
	611	+	let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
	612	+	let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
	613	+	let invariantCalculated = invariantCalc((balanceA - amountToPayA), (balanceB - amountToPayB))
	614	+	let stake1 = if (contains(stakingAssets, strAssetIdA))
	615	+	then invoke(this, "stakeUnstake", [false, amountToPayA, strAssetIdA], nil)
	616	+	else 0
	617	+	if ((stake1 == stake1))
	618	+	then {
	619	+	let stake2 = if (contains(stakingAssets, strAssetIdB))
	620	+	then invoke(this, "stakeUnstake", [false, amountToPayB, strAssetIdB], nil)
	621	+	else 0
	622	+	if ((stake2 == stake2))
	623	+	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)]
	624	+	else throw("Strict value is not equal to itself.")
	625	+	}
	626	+	else throw("Strict value is not equal to itself.")
	627	+	}
	628	+	else throw("Strict value is not equal to itself.")
	629	+	}
	630	+	}

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

github/deemru/w8io/6500d08 
156.72 ms ◑