w8 · tx · CPJ···nJ4

tx · CPJBNgiqCoi4X64H6kPiZV8k5jRgYMuRPHtNh9CMpnJ4

3MpygN8qm376tUAHB6mhC5BxG5NKYortiyX:  -0.03600000 Waves

2022.11.24 23:10 [2331630] smart account 3MpygN8qm376tUAHB6mhC5BxG5NKYortiyX > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CPJBNgiqCoi4X64H6kPiZV8k5jRgYMuRPHtNh9CMpnJ4",
    "fee": 3600000,
    "feeAssetId": null,
    "timestamp": 1669320559477,
    "version": 2,
    "chainId": 84,
    "sender": "3MpygN8qm376tUAHB6mhC5BxG5NKYortiyX",
    "senderPublicKey": "BjnLnkAMaJLYAK36vQqSepUNjGeMDHfZGfmdYwGcLbmg",
    "proofs": [
        "22WLfVQrCioS7N68owkxKzVsyQQtfwoewZSV6zzT8yj7n6urGE36WNFjexDGMB6mffacTGAgxTkDWVjYpg8Vitt6",
        "49bzGPDiKvDxcRo8M6hGBhRT4ULncL3dAj4ma5VbbVfSwLM4zrwribEFX6QEf7HxJa6ZeXURjF1YKCQCHXqeiHsx"
    ],
    "script": "base64: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",
    "height": 2331630,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: A39GaZW6jN363AdoaKKBJKb8j8a7gV5dGrA81BzYiNZE
Next: AxEfEyEs8YwBVVDzHc6ehgNVkhK9mTwTX7Zx7cLsYXDg

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

Old	New		Differences
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

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

326	330		func throwIsActive () = throw("DApp is already active")
327	331
328	332
329		-	func isActive () = if (active)
	333	+	func isActive () = if (if (active)
	334	+	then activeGlob
	335	+	else false)
330	336		then unit
331	337		else throw("DApp is inactive at this moment")
332	338

360	366
361	367		func calcStakingParams (stake,amount,assetId) = if (stake)
362	368		then {
363		-	let $~~t01038310449~~ = calcStakingFuncAndAddres(stake, assetId)
364		-	let call = $~~t01038310449~~._1
365		-	let stakingAddr = $~~t01038310449~~._2
	369	+	let $t01050410570 = calcStakingFuncAndAddres(stake, assetId)
	370	+	let call = $t01050410570._1
	371	+	let stakingAddr = $t01050410570._2
366	372		$Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
367	373		}
368	374		else {
369		-	let $~~t01053510601~~ = calcStakingFuncAndAddres(stake, assetId)
370		-	let call = $~~t01053510601~~._1
371		-	let stakingAddr = $~~t01053510601~~._2
	375	+	let $t01065610722 = calcStakingFuncAndAddres(stake, assetId)
	376	+	let call = $t01065610722._1
	377	+	let stakingAddr = $t01065610722._2
372	378		$Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
373	379		}
374	380

400	406		}
401	407
402	408
	409	+	func replenishWithTwoTokensCalc (i,stakeFarming,lockType) = {
	410	+	let pmtAssetIdA = i.payments[0].assetId
	411	+	let pmtAssetIdB = i.payments[1].assetId
	412	+	let ratioShareTokensInA = fraction(scale8, i.payments[0].amount, balanceA)
	413	+	let ratioShareTokensInB = fraction(scale8, i.payments[1].amount, balanceB)
	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))
	423	+	then {
	424	+	let pmt = fraction(balanceB, ratioShareTokensInA, scale8, CEILING)
	425	+	$Tuple5(i.payments[0].amount, pmt, (i.payments[1].amount - pmt), pmtAssetIdB, ratioShareTokensInA)
	426	+	}
	427	+	else {
	428	+	let pmt = fraction(balanceA, ratioShareTokensInB, scale8, CEILING)
	429	+	$Tuple5(pmt, i.payments[1].amount, (i.payments[0].amount - pmt), pmtAssetIdA, ratioShareTokensInB)
	430	+	}
	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
	436	+	let shareTokenToPayAmount = fraction(shareTokenRatio, shareAssetSupply, scale8)
	437	+	if (if ((size(i.payments) != 2))
	438	+	then (size(i.payments) != 3)
	439	+	else false)
	440	+	then throw("Two or three payments expected")
	441	+	else if (if ((pmtAssetIdA != assetIdA))
	442	+	then true
	443	+	else (pmtAssetIdB != assetIdB))
	444	+	then throwAssets()
	445	+	else if ((shareTokenToPayAmount == 0))
	446	+	then throw("Too small amount to replenish")
	447	+	else if ((0 > change))
	448	+	then throw("Change < 0")
	449	+	else if (!(hasEnoughBalance))
	450	+	then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
	451	+	else {
	452	+	let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
	453	+	then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
	454	+	else 0
	455	+	if ((stake1 == stake1))
	456	+	then {
	457	+	let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
	458	+	then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
	459	+	else 0
	460	+	if ((stake2 == stake2))
	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	+	}
	482	+	else throw("Strict value is not equal to itself.")
	483	+	}
	484	+	else throw("Strict value is not equal to itself.")
	485	+	}
	486	+	}
	487	+
	488	+
	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
	497	+	let pmtMinThreshold = 5000000
	498	+	let thresholdValueForMinTolerance = 50000000
	499	+	let tolerance = if ((thresholdValueForMinTolerance > pmtAmount))
	500	+	then 100000
	501	+	else 1
	502	+	let slippageValueMinForReplenish = (scale8 - ((scale8 * tolerance) / 10000000))
	503	+	let slippageValueMaxForReplenish = (scale8 + ((scale8 * tolerance) / 10000000))
	504	+	let slippageValueMinForSwap = (scale8 - ((scale8 * 1) / 10000000))
	505	+	if ((pmtMinThreshold > pmtAmount))
	506	+	then throw((((("Payment amount " + toString(pmtAmount)) + " does not exceed the minimum amount of ") + toString(pmtMinThreshold)) + " tokens"))
	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")
	511	+	else if (!(hasEnoughBalance))
	512	+	then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
	513	+	else if (if ((pmtAssetId != assetIdA))
	514	+	then (pmtAssetId != assetIdB)
	515	+	else false)
	516	+	then throwAssets()
	517	+	else {
	518	+	let $t01656217204 = if ((pmtAssetId == assetIdA))
	519	+	then $Tuple6((pmtAmount - virtualSwapTokenPay), virtualSwapTokenGet, (balanceA + virtualSwapTokenPay), (balanceB - virtualSwapTokenGet), (balanceA + pmtAmount), balanceB)
	520	+	else $Tuple6(virtualSwapTokenGet, (pmtAmount - virtualSwapTokenPay), (balanceA - virtualSwapTokenGet), (balanceB + virtualSwapTokenPay), balanceA, (balanceB + pmtAmount))
	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
	527	+	let invariantNew = invariantCalc(balanceAfterSwapA, balanceAfterSwapB)
	528	+	let ratioVirtualBalanceToVirtualReplenish = (fraction(scale16, balanceAfterSwapA, balanceAfterSwapB) / fraction(scale8, virtualReplenishA, virtualReplenishB))
	529	+	let dAppThresholdAmount = fraction((newBalanceA + newBalanceB), dAppThreshold, (2 * dAppThresholdScale2))
	530	+	if (if ((slippageValueMinForSwap >= fraction(scale8, invariant, invariantNew)))
	531	+	then true
	532	+	else (invariant > invariantNew))
	533	+	then throw("Incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
	534	+	else if (if ((slippageValueMinForReplenish > ratioVirtualBalanceToVirtualReplenish))
	535	+	then true
	536	+	else (ratioVirtualBalanceToVirtualReplenish > slippageValueMaxForReplenish))
	537	+	then throw("Swap with virtualSwapTokenPay and virtualSwapTokenGet is possible, but ratio after virtual swap is incorrect")
	538	+	else if (if ((dAppThresholdAmount > newBalanceA))
	539	+	then true
	540	+	else (dAppThresholdAmount > newBalanceB))
	541	+	then throwThreshold(dAppThresholdAmount, newBalanceA, newBalanceB)
	542	+	else {
	543	+	let ratioShareTokensInA = fraction(virtualReplenishA, scale8, balanceAfterSwapA)
	544	+	let ratioShareTokensInB = fraction(virtualReplenishB, scale8, balanceAfterSwapB)
	545	+	let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scale8)
	546	+	let shareTokenToPayAmountAfterFee = fraction(shareTokenToPayAmount, (feeScale6 - (fee / 2)), feeScale6)
	547	+	let shareTokenGovernanceReward = fraction(shareTokenToPayAmount, (feeGovernance / 2), feeScale6)
	548	+	let governanceRewardTokenA = fraction(shareTokenGovernanceReward, balanceA, shareAssetSupply)
	549	+	let governanceRewardTokenB = fraction(shareTokenGovernanceReward, balanceB, shareAssetSupply)
	550	+	let $t01919419489 = if ((pmtStrAssetId == strAssetIdA))
	551	+	then $Tuple3((pmtAmount - governanceRewardTokenA), governanceRewardTokenB, strAssetIdB)
	552	+	else $Tuple3((pmtAmount - governanceRewardTokenB), governanceRewardTokenA, strAssetIdA)
	553	+	let stakeAmount = $t01919419489._1
	554	+	let unstakeAmount = $t01919419489._2
	555	+	let unstakeAsset = $t01919419489._3
	556	+	let stake1 = if (contains(stakingAssets, pmtStrAssetId))
	557	+	then invoke(this, "stakeUnstake", [true, stakeAmount, pmtStrAssetId], nil)
	558	+	else 0
	559	+	if ((stake1 == stake1))
	560	+	then {
	561	+	let stake2 = if (contains(stakingAssets, unstakeAsset))
	562	+	then invoke(this, "stakeUnstake", [false, unstakeAmount, unstakeAsset], nil)
	563	+	else 0
	564	+	if ((stake2 == stake2))
	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	+	}
	586	+	else throw("Strict value is not equal to itself.")
	587	+	}
	588	+	else throw("Strict value is not equal to itself.")
	589	+	}
	590	+	}
	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	+
403	633		@Callable(i)
404	634		func init (firstHarvest) = {
405		-	let $~~t01190111978~~ = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
406		-	let pmtAmountA = $~~t01190111978~~._1
407		-	let pmtAssetIdA = $~~t01190111978~~._2
408		-	let $~~t01198312060~~ = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
409		-	let pmtAmountB = $~~t01198312060~~._1
410		-	let pmtAssetIdB = $~~t01198312060~~._2
411		-	let $~~t01206512142~~ = getAssetInfo(pmtAssetIdA)
412		-	let pmtStrAssetIdA = $~~t01206512142~~._1
413		-	let pmtAssetNameA = $~~t01206512142~~._2
414		-	let pmtDecimalsA = $~~t01206512142~~._3
415		-	let $~~t01214712224~~ = getAssetInfo(pmtAssetIdB)
416		-	let pmtStrAssetIdB = $~~t01214712224~~._1
417		-	let pmtAssetNameB = $~~t01214712224~~._2
418		-	let pmtDecimalsB = $~~t01214712224~~._3
	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
419	649		if (isDefined(getBoolean(this, kActive)))
420	650		then throwIsActive()
421	651		else if ((pmtAssetIdA == pmtAssetIdB))

452	682
453	683
454	684		@Callable(i)
455		-	func replenishWithTwoTokens (stakeFarming,lockType) = valueOrElse(isActive(), {
456		-	let pmtAssetIdA = i.payments[0].assetId
457		-	let pmtAssetIdB = i.payments[1].assetId
458		-	let ratioShareTokensInA = fraction(scale8, i.payments[0].amount, balanceA)
459		-	let ratioShareTokensInB = fraction(scale8, i.payments[1].amount, balanceB)
460		-	let $t01519415271 = getAssetInfo(pmtAssetIdA)
461		-	let pmtStrAssetIdA = $t01519415271._1
462		-	let pmtAssetNameA = $t01519415271._2
463		-	let pmtDecimalsA = $t01519415271._3
464		-	let $t01527615393 = getAssetInfo(pmtAssetIdB)
465		-	let pmtStrAssetIdB = $t01527615393._1
466		-	let pmtAssetNameB = $t01527615393._2
467		-	let pmtDecimalsB = $t01527615393._3
468		-	let $t01539815902 = if ((ratioShareTokensInB > ratioShareTokensInA))
469		-	then {
470		-	let pmt = fraction(balanceB, ratioShareTokensInA, scale8, CEILING)
471		-	$Tuple5(i.payments[0].amount, pmt, (i.payments[1].amount - pmt), pmtAssetIdB, ratioShareTokensInA)
472		-	}
473		-	else {
474		-	let pmt = fraction(balanceA, ratioShareTokensInB, scale8, CEILING)
475		-	$Tuple5(pmt, i.payments[1].amount, (i.payments[0].amount - pmt), pmtAssetIdA, ratioShareTokensInB)
476		-	}
477		-	let pmtAmountA = $t01539815902._1
478		-	let pmtAmountB = $t01539815902._2
479		-	let change = $t01539815902._3
480		-	let changeAssetId = $t01539815902._4
481		-	let shareTokenRatio = $t01539815902._5
482		-	let shareTokenToPayAmount = fraction(shareTokenRatio, shareAssetSupply, scale8)
483		-	if (if ((size(i.payments) != 2))
484		-	then (size(i.payments) != 3)
	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))
	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)
485	711		else false)
486		-	then throw("Two or three payments expected")
487		-	else if (if ((pmtAssetIdA != assetIdA))
488		-	then true
489		-	else (pmtAssetIdB != assetIdB))
490		-	then throwAssets()
491		-	else if ((shareTokenToPayAmount == 0))
492		-	then throw("Too small amount to replenish")
493		-	else if ((0 > change))
494		-	then throw("Change < 0")
495		-	else if (!(hasEnoughBalance))
496		-	then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
497		-	else {
498		-	let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
499		-	then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
	712	+	then throw("Incorrect withdraw asset")
	713	+	else if ((0 >= withdrawAmount))
	714	+	then throw("withdraw amount must be grater than 0")
	715	+	else if (!(hasEnoughBalance))
	716	+	then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
	717	+	else {
	718	+	let unlock = if ((unlockAmount > 0))
	719	+	then invoke(farmingAddress, "withdrawShareTokensFromPool", [i.caller.bytes, toString(this), unlockAmount], nil)
	720	+	else 0
	721	+	if ((unlock == unlock))
	722	+	then {
	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)
500	742		else 0
501	743		if ((stake1 == stake1))
502		-	then {
503		-	let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
504		-	then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
505		-	else 0
506		-	if ((stake2 == stake2))
507		-	then {
508		-	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)]
509		-	if (stakeFarming)
510		-	then {
511		-	let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmount)] ++ (if ((size(i.payments) == 3))
512		-	then [AttachedPayment(i.payments[2].assetId, i.payments[2].amount)]
513		-	else nil))
514		-	let re = invoke(this, "reissueShare", [shareTokenToPayAmount], nil)
515		-	if ((re == re))
516		-	then {
517		-	let s = invoke(farmingAddress, "lockShareTokens", [toString(this), lockType], stPayments)
518		-	if ((s == s))
519		-	then scriptActions
520		-	else throw("Strict value is not equal to itself.")
521		-	}
522		-	else throw("Strict value is not equal to itself.")
523		-	}
524		-	else (scriptActions ++ [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId)])
525		-	}
526		-	else throw("Strict value is not equal to itself.")
527		-	}
	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))]
528	745		else throw("Strict value is not equal to itself.")
529	746		}
	747	+	else throw("Strict value is not equal to itself.")
	748	+	}
530	749		})
531	750
532	751
533	752
534	753		@Callable(i)
535		-	func replenishWithOneToken (virtualSwapTokenPay,virtualSwapTokenGet,stakeFarming,lockType) = valueOrElse(isActive(), {
536		-	let $t01828118356 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
537		-	let pmtAmount = $t01828118356._1
538		-	let pmtAssetId = $t01828118356._2
539		-	let $t01836118434 = getAssetInfo(pmtAssetId)
540		-	let pmtStrAssetId = $t01836118434._1
541		-	let pmtAssetName = $t01836118434._2
542		-	let pmtDecimals = $t01836118434._3
543		-	let pmtMinThreshold = 5000000
544		-	let thresholdValueForMinTolerance = 50000000
545		-	let tolerance = if ((thresholdValueForMinTolerance > pmtAmount))
546		-	then 100000
547		-	else 1
548		-	let slippageValueMinForReplenish = (scale8 - ((scale8 * tolerance) / 10000000))
549		-	let slippageValueMaxForReplenish = (scale8 + ((scale8 * tolerance) / 10000000))
550		-	let slippageValueMinForSwap = (scale8 - ((scale8 * 1) / 10000000))
551		-	if ((pmtMinThreshold > pmtAmount))
552		-	then throw((((("Payment amount " + toString(pmtAmount)) + " does not exceed the minimum amount of ") + toString(pmtMinThreshold)) + " tokens"))
553		-	else if (if ((size(i.payments) != 1))
554		-	then (size(i.payments) != 2)
555		-	else false)
556		-	then throw("One or two payments expected")
557		-	else if (!(hasEnoughBalance))
558		-	then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
559		-	else if (if ((pmtAssetId != assetIdA))
560		-	then (pmtAssetId != assetIdB)
561		-	else false)
562		-	then throwAssets()
563		-	else {
564		-	let $t01944120083 = if ((pmtAssetId == assetIdA))
565		-	then $Tuple6((pmtAmount - virtualSwapTokenPay), virtualSwapTokenGet, (balanceA + virtualSwapTokenPay), (balanceB - virtualSwapTokenGet), (balanceA + pmtAmount), balanceB)
566		-	else $Tuple6(virtualSwapTokenGet, (pmtAmount - virtualSwapTokenPay), (balanceA - virtualSwapTokenGet), (balanceB + virtualSwapTokenPay), balanceA, (balanceB + pmtAmount))
567		-	let virtualReplenishA = $t01944120083._1
568		-	let virtualReplenishB = $t01944120083._2
569		-	let balanceAfterSwapA = $t01944120083._3
570		-	let balanceAfterSwapB = $t01944120083._4
571		-	let newBalanceA = $t01944120083._5
572		-	let newBalanceB = $t01944120083._6
573		-	let invariantNew = invariantCalc(balanceAfterSwapA, balanceAfterSwapB)
574		-	let ratioVirtualBalanceToVirtualReplenish = (fraction(scale16, balanceAfterSwapA, balanceAfterSwapB) / fraction(scale8, virtualReplenishA, virtualReplenishB))
575		-	let dAppThresholdAmount = fraction((newBalanceA + newBalanceB), dAppThreshold, (2 * dAppThresholdScale2))
576		-	if (if ((slippageValueMinForSwap >= fraction(scale8, invariant, invariantNew)))
577		-	then true
578		-	else (invariant > invariantNew))
579		-	then throw("Incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
580		-	else if (if ((slippageValueMinForReplenish > ratioVirtualBalanceToVirtualReplenish))

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

github/deemru/w8io/026f985 
217.60 ms ◑