w8 · tx · 6aP···Jnj

tx · 6aPstHmZWmyaVRNYNgVFpC4qoTVXvhCf2zjikf4PKJnj

3N8iNNRC4UfDK4aJctSvHajiZ81fzSumCeP:  -0.04200000 Waves

2023.04.06 11:53 [2522486] smart account 3N8iNNRC4UfDK4aJctSvHajiZ81fzSumCeP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6aPstHmZWmyaVRNYNgVFpC4qoTVXvhCf2zjikf4PKJnj",
    "fee": 4200000,
    "feeAssetId": null,
    "timestamp": 1680771218256,
    "version": 2,
    "chainId": 84,
    "sender": "3N8iNNRC4UfDK4aJctSvHajiZ81fzSumCeP",
    "senderPublicKey": "F7NZd812aXMUyDcj1XaB3wgMJXJfUsq3RhPhrEZ9b6ND",
    "proofs": [
        "gB1ZocgbLsmFXGbWRtNrN5Mh76iw38GBKuofJm4RpLwuZPDfH5mbjL38PjedhRMaK1vBPJ6npsyCpKDB2W9UXMp"
    ],
    "script": "base64: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",
    "height": 2522486,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8ByFGpJQt7MP9gyB1mv3doCs2hAezip4FVvQKsScUQuC
Next: 26zDT2xf2xxiZLxj4e8Zn43n2LYyiKyPB8yaQZWwRLdL

Diff: 
Old New Differences
468 468      }
469 469  
470 470  
471 - func cP (cQ,cR,cS,cT) = {
472 -     let cU = D(cS, cQ)
473 -     let cV = D(cT, cR)
474 -     bM(cV, cU)
471 + func cP (cQ,cR) = {
472 +     let cS = cK(aM(this, ae()), cQ)
473 +     let cT = cK(aM(this, af()), cR)
474 +     (cS ++ cT)
475 475      }
476 476  
477 477  
478 - func cW (cS,cT,cX) = {
479 -     let cY = ba()
480 -     let cZ = parseIntValue(cY[t])
481 -     let da = parseIntValue(cY[u])
482 -     let db = cP(cZ, da, cS, cT)
483 -     let bO = D(cS, cZ)
484 -     let bN = D(cT, da)
485 -     let dc = D(cX, b)
486 -     let dd = bM(bO, dc)
487 -     let de = bM(bN, dc)
488 - [db, dd, de]
478 + func cU (cV,cW,cX,cY) = {
479 +     let cZ = D(cX, cV)
480 +     let da = D(cY, cW)
481 +     bM(da, cZ)
489 482      }
490 483  
491 484  
492 - func df (cS,cT,cX) = {
493 -     let dg = cW(cS, cT, cX)
494 - [H(dg[0], b), H(dg[1], b), H(dg[2], b)]
485 + func db (cX,cY,dc) = {
486 +     let dd = ba()
487 +     let de = parseIntValue(dd[t])
488 +     let df = parseIntValue(dd[u])
489 +     let dg = cU(de, df, cX, cY)
490 +     let bO = D(cX, de)
491 +     let bN = D(cY, df)
492 +     let dh = D(dc, b)
493 +     let di = bM(bO, dh)
494 +     let dj = bM(bN, dh)
495 + [dg, di, dj]
495 496      }
496 497  
497 498  
498 - func dh (di,dj,dk,ab) = {
499 -     let cY = ba()
500 -     let dl = cY[q]
501 -     let dm = cY[r]
502 -     let dn = cY[s]
503 -     let cQ = parseIntValue(cY[t])
504 -     let cR = parseIntValue(cY[u])
505 -     let do = cY[p]
506 -     let dp = valueOrErrorMessage(assetInfo(fromBase58String(dl)), (("Asset " + dl) + " doesn't exist")).quantity
507 -     if ((dl != dj))
499 + func dk (cX,cY,dc) = {
500 +     let dl = db(cX, cY, dc)
501 + [H(dl[0], b), H(dl[1], b), H(dl[2], b)]
502 +     }
503 + 
504 + 
505 + func dm (dn,do,dp,ab) = {
506 +     let dd = ba()
507 +     let dq = dd[q]
508 +     let dr = dd[r]
509 +     let ds = dd[s]
510 +     let cV = parseIntValue(dd[t])
511 +     let cW = parseIntValue(dd[u])
512 +     let dt = dd[p]
513 +     let du = valueOrErrorMessage(assetInfo(fromBase58String(dq)), (("Asset " + dq) + " doesn't exist")).quantity
514 +     if ((dq != do))
508 515          then throw("Invalid asset passed.")
509 516          else {
510 -             let dq = bJ(dm)
511 -             let dr = D(dq, cQ)
512 -             let ds = bJ(dn)
513 -             let dt = D(ds, cR)
514 -             let du = bM(dt, dr)
515 -             let dv = H(du, b)
516 -             let dw = D(dk, b)
517 -             let dx = D(dp, b)
518 -             let dy = fraction(dr, dw, dx)
519 -             let dz = fraction(dt, dw, dx)
520 -             let dA = K(dy, cQ, FLOOR)
521 -             let dB = K(dz, cR, FLOOR)
522 -             let dC = cK(dm, dA)
523 -             let dD = cK(dn, dB)
524 -             let dE = if ((di == ""))
517 +             let dv = bJ(dr)
518 +             let dw = D(dv, cV)
519 +             let dx = bJ(ds)
520 +             let dy = D(dx, cW)
521 +             let dz = bM(dy, dw)
522 +             let dA = H(dz, b)
523 +             let dB = D(dp, b)
524 +             let dC = D(du, b)
525 +             let dD = fraction(dw, dB, dC)
526 +             let dE = fraction(dy, dB, dC)
527 +             let dF = K(dD, cV, FLOOR)
528 +             let dG = K(dE, cW, FLOOR)
529 +             let dH = if ((dn == ""))
525 530                  then nil
526 -                 else ((dC ++ dD) ++ [ScriptTransfer(ab, dA, if ((dm == "WAVES"))
531 +                 else [ScriptTransfer(ab, dF, if ((dr == "WAVES"))
527 532                      then unit
528 -                     else fromBase58String(dm)), ScriptTransfer(ab, dB, if ((dn == "WAVES"))
533 +                     else fromBase58String(dr)), ScriptTransfer(ab, dG, if ((ds == "WAVES"))
529 534                      then unit
530 -                     else fromBase58String(dn)), StringEntry(ad(toString(ab), di), bF(dA, dB, dk, dv, height, lastBlock.timestamp)), IntegerEntry(W(), dv), IntegerEntry(X(height, lastBlock.timestamp), dv)])
531 -             $Tuple10(dA, dB, dm, dn, dq, ds, dp, du, do, dE)
535 +                     else fromBase58String(ds)), StringEntry(ad(toString(ab), dn), bF(dF, dG, dp, dA, height, lastBlock.timestamp)), IntegerEntry(W(), dA), IntegerEntry(X(height, lastBlock.timestamp), dA)]
536 +             $Tuple10(dF, dG, dr, ds, dv, dx, du, dz, dt, dH)
532 537              }
533 538      }
534 539  
535 540  
536 - func dF (di,dG,dH,dI,dJ,dK,ab,dL,dM) = {
537 -     let cY = ba()
538 -     let dl = fromBase58String(cY[q])
539 -     let dN = cY[r]
540 -     let dO = cY[s]
541 -     let dP = cY[v]
542 -     let dQ = cY[w]
543 -     let cZ = parseIntValue(cY[t])
544 -     let da = parseIntValue(cY[u])
545 -     let do = cY[p]
546 -     let dp = valueOrErrorMessage(assetInfo(dl), (("Asset " + toBase58String(dl)) + " doesn't exist")).quantity
547 -     let dR = toBase58String(valueOrElse(dI, fromBase58String("WAVES")))
548 -     let dS = toBase58String(valueOrElse(dK, fromBase58String("WAVES")))
549 -     if (if ((dN != dR))
541 + func dI (dn,dJ,dK,dL,dM,dN,ab,dO,dP) = {
542 +     let dd = ba()
543 +     let dq = fromBase58String(dd[q])
544 +     let dQ = dd[r]
545 +     let dR = dd[s]
546 +     let dS = dd[v]
547 +     let dT = dd[w]
548 +     let de = parseIntValue(dd[t])
549 +     let df = parseIntValue(dd[u])
550 +     let dt = dd[p]
551 +     let du = valueOrErrorMessage(assetInfo(dq), (("Asset " + toBase58String(dq)) + " doesn't exist")).quantity
552 +     let dU = toBase58String(valueOrElse(dL, fromBase58String("WAVES")))
553 +     let dV = toBase58String(valueOrElse(dN, fromBase58String("WAVES")))
554 +     if (if ((dQ != dU))
550 555          then true
551 -         else (dO != dS))
556 +         else (dR != dV))
552 557          then throw("Invalid amt or price asset passed.")
553 558          else {
554 -             let dq = if (dL)
555 -                 then bJ(dN)
556 -                 else (bJ(dN) - dH)
557 -             let ds = if (dL)
558 -                 then bJ(dO)
559 -                 else (bJ(dO) - dJ)
560 -             let dT = D(dH, cZ)
561 -             let dU = D(dJ, da)
562 -             let dV = bM(dU, dT)
563 -             let dr = D(dq, cZ)
564 -             let dt = D(ds, da)
565 -             let dW = if ((dp == 0))
559 +             let dv = if (dO)
560 +                 then bJ(dQ)
561 +                 else (bJ(dQ) - dK)
562 +             let dx = if (dO)
563 +                 then bJ(dR)
564 +                 else (bJ(dR) - dM)
565 +             let dW = D(dK, de)
566 +             let dX = D(dM, df)
567 +             let dY = bM(dX, dW)
568 +             let dw = D(dv, de)
569 +             let dy = D(dx, df)
570 +             let dZ = if ((du == 0))
566 571                  then {
567 -                     let du = e
568 -                     let dX = e
569 -                     let dc = pow((dT * dU), 0, toBigInt(5), 1, 0, DOWN)
570 -                     $Tuple5(H(dc, b), H(dT, cZ), H(dU, da), bM((dt + dU), (dr + dT)), dX)
572 +                     let dz = e
573 +                     let ea = e
574 +                     let dh = pow((dW * dX), 0, toBigInt(5), 1, 0, DOWN)
575 +                     $Tuple5(H(dh, b), H(dW, de), H(dX, df), bM((dy + dX), (dw + dW)), ea)
571 576                      }
572 577                  else {
573 -                     let du = bM(dt, dr)
574 -                     let dX = fraction(R((du - dV)), d, du)
575 -                     let dY = D(dG, b)
576 -                     if (if ((du != e))
577 -                         then (dX > dY)
578 +                     let dz = bM(dy, dw)
579 +                     let ea = fraction(R((dz - dY)), d, dz)
580 +                     let eb = D(dJ, b)
581 +                     if (if ((dz != e))
582 +                         then (ea > eb)
578 583                          else false)
579 -                         then throw(((("Price slippage " + toString(dX)) + " exceeded the passed limit of ") + toString(dY)))
584 +                         then throw(((("Price slippage " + toString(ea)) + " exceeded the passed limit of ") + toString(eb)))
580 585                          else {
581 -                             let dx = D(dp, b)
582 -                             let dZ = fraction(dT, bP(dt, dr, CEILING), d, CEILING)
583 -                             let ea = fraction(dU, d, bP(dt, dr, FLOOR), CEILING)
584 -                             let eb = if ((dZ > dU))
585 -                                 then $Tuple2(ea, dU)
586 -                                 else $Tuple2(dT, dZ)
587 -                             let ec = eb._1
588 -                             let ed = eb._2
589 -                             let dc = fraction(dx, ed, dt, FLOOR)
590 -                             $Tuple5(K(dc, b, FLOOR), K(ec, cZ, CEILING), K(ed, da, CEILING), du, dX)
586 +                             let dC = D(du, b)
587 +                             let ec = fraction(dW, bP(dy, dw, CEILING), d, CEILING)
588 +                             let ed = fraction(dX, d, bP(dy, dw, FLOOR), CEILING)
589 +                             let ee = if ((ec > dX))
590 +                                 then $Tuple2(ed, dX)
591 +                                 else $Tuple2(dW, ec)
592 +                             let ef = ee._1
593 +                             let eg = ee._2
594 +                             let dh = fraction(dC, eg, dy, FLOOR)
595 +                             $Tuple5(K(dh, b, FLOOR), K(ef, de, CEILING), K(eg, df, CEILING), dz, ea)
591 596                              }
592 597                      }
593 -             let ee = dW._1
594 -             let ef = dW._2
595 -             let eg = dW._3
596 -             let dv = H(dW._4, b)
597 -             let eh = H(dW._5, b)
598 -             if ((0 >= ee))
598 +             let eh = dZ._1
599 +             let ei = dZ._2
600 +             let ej = dZ._3
601 +             let dA = H(dZ._4, b)
602 +             let ek = H(dZ._5, b)
603 +             if ((0 >= eh))
599 604                  then throw("Invalid calculations. LP calculated is less than zero.")
600 605                  else {
601 -                     let ei = if (!(dM))
606 +                     let el = if (!(dP))
602 607                          then 0
603 -                         else ee
604 -                     let ej = (dH - ef)
605 -                     let ek = (dJ - eg)
606 -                     let el = [IntegerEntry(W(), dv), IntegerEntry(X(height, lastBlock.timestamp), dv), StringEntry(aa(ab, di), bu(ef, eg, ei, dv, dG, eh, height, lastBlock.timestamp, ej, ek))]
607 -                     $Tuple13(ee, ei, dv, dq, ds, dp, dl, do, el, ej, ek, dI, dK)
608 +                         else eh
609 +                     let em = (dK - ei)
610 +                     let en = (dM - ej)
611 +                     let eo = [IntegerEntry(W(), dA), IntegerEntry(X(height, lastBlock.timestamp), dA), StringEntry(aa(ab, dn), bu(ei, ej, el, dA, dJ, ek, height, lastBlock.timestamp, em, en))]
612 +                     $Tuple13(eh, el, dA, dv, dx, du, dq, dt, eo, em, en, dL, dN)
608 613                      }
609 614              }
610 615      }
611 616  
612 617  
613 - func em (en,eo,dp) = {
614 -     let ep = G(en, toBigInt(bp))
615 -     let eq = G(eo, toBigInt(bq))
616 -     let er = fraction(pow((ep * eq), 0, toBigInt(5), 1, 18, DOWN), g, dp)
617 -     if ((dp == f))
618 + func ep (eq,er,du) = {
619 +     let es = G(eq, toBigInt(bp))
620 +     let et = G(er, toBigInt(bq))
621 +     let eu = fraction(pow((es * et), 0, toBigInt(5), 1, 18, DOWN), g, du)
622 +     if ((du == f))
618 623          then f
619 -         else er
624 +         else eu
620 625      }
621 626  
622 627  
623 - func es (et,eu,ev) = {
624 -     let ew = (toBigInt(bJ(bf(bn))) - et)
625 -     let ex = (toBigInt(bJ(bf(bo))) - eu)
626 -     let ey = (toBigInt(value(assetInfo(bm)).quantity) - ev)
627 -     let ez = em(ew, ex, ey)
628 -     ez
628 + func ev (ew,ex,ey) = {
629 +     let ez = (toBigInt(bJ(bf(bn))) - ew)
630 +     let eA = (toBigInt(bJ(bf(bo))) - ex)
631 +     let eB = (toBigInt(value(assetInfo(bm)).quantity) - ey)
632 +     let eC = ep(ez, eA, eB)
633 +     eC
629 634      }
630 635  
631 636  
632 - func eA (eB,eC,ev) = {
633 -     let ew = (bJ(bf(bn)) + eB)
634 -     let ex = (bJ(bf(bo)) + eC)
635 -     let ey = (value(assetInfo(bm)).quantity + ev)
636 -     let er = em(toBigInt(ew), toBigInt(ex), toBigInt(ey))
637 -     let eD = [IntegerEntry(ak, height), StringEntry(aj, toString(er))]
638 -     $Tuple2(eD, er)
637 + func eD (eE,eF,ey) = {
638 +     let ez = (bJ(bf(bn)) + eE)
639 +     let eA = (bJ(bf(bo)) + eF)
640 +     let eB = (value(assetInfo(bm)).quantity + ey)
641 +     let eu = ep(toBigInt(ez), toBigInt(eA), toBigInt(eB))
642 +     let eG = [IntegerEntry(ak, height), StringEntry(aj, toString(eu))]
643 +     $Tuple2(eG, eu)
639 644      }
640 645  
641 646  
642 - func eE (eF,er) = if ((er >= eF))
647 + func eH (eI,eu) = if ((eu >= eI))
643 648      then true
644 -     else aQ(makeString(["updated KLp lower than current KLp", toString(eF), toString(er)], " "))
649 +     else aQ(makeString(["updated KLp lower than current KLp", toString(eI), toString(eu)], " "))
645 650  
646 651  
647 - func eG (eH) = {
648 -     let ew = bJ(bf(bn))
649 -     let ex = bJ(bf(bo))
650 -     let eI = eH.amount
651 -     let eJ = fraction(eH.amount, eH.price, b, FLOOR)
652 -     let eK = if ((eH.orderType == Buy))
653 -         then $Tuple2(eI, -(eJ))
654 -         else $Tuple2(-(eI), eJ)
655 -     let eB = eK._1
656 -     let eC = eK._2
652 + func eJ (eK) = {
653 +     let ez = bJ(bf(bn))
654 +     let eA = bJ(bf(bo))
655 +     let eL = eK.amount
656 +     let eM = fraction(eK.amount, eK.price, b, FLOOR)
657 +     let eN = if ((eK.orderType == Buy))
658 +         then $Tuple2(eL, -(eM))
659 +         else $Tuple2(-(eL), eM)
660 +     let eE = eN._1
661 +     let eF = eN._2
657 662      if (if (if (aY())
658 663          then true
659 664          else (bl == m))
660 665          then true
661 666          else (bl == n))
662 667          then throw("Exchange operations disabled")
663 -         else if (if ((eH.assetPair.amountAsset != bn))
668 +         else if (if ((eK.assetPair.amountAsset != bn))
664 669              then true
665 -             else (eH.assetPair.priceAsset != bo))
670 +             else (eK.assetPair.priceAsset != bo))
666 671              then throw("Wrong order assets.")
667 672              else {
668 -                 let eL = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
669 -                 let eM = eA(eB, eC, 0)
670 -                 let eN = eM._1
671 -                 let eO = eM._2
672 -                 let eP = (eO >= eL)
673 -                 let eQ = makeString(["kLp=", toString(eL), " kLpNew=", toString(eO), " amountAssetBalance=", toString(ew), " priceAssetBalance=", toString(ex), " amountAssetBalanceDelta=", toString(eB), " priceAssetBalanceDelta=", toString(eC), " height=", toString(height)], "")
674 -                 $Tuple2(eP, eQ)
673 +                 let eO = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
674 +                 let eP = eD(eE, eF, 0)
675 +                 let eQ = eP._1
676 +                 let eR = eP._2
677 +                 let eS = (eR >= eO)
678 +                 let eT = makeString(["kLp=", toString(eO), " kLpNew=", toString(eR), " amountAssetBalance=", toString(ez), " priceAssetBalance=", toString(eA), " amountAssetBalanceDelta=", toString(eE), " priceAssetBalanceDelta=", toString(eF), " height=", toString(height)], "")
679 +                 $Tuple2(eS, eT)
675 680                  }
676 681      }
677 682  
678 683  
679 - func eR (eS) = if ((size(eS.payments) != 1))
684 + func eU (eV) = if ((size(eV.payments) != 1))
680 685      then throw("exactly 1 payment is expected")
681 686      else {
682 -         let eT = value(eS.payments[0])
683 -         let dj = value(eT.assetId)
684 -         let eU = eT.amount
685 -         let dW = dh(toBase58String(eS.transactionId), toBase58String(dj), eU, eS.caller)
686 -         let dA = dW._1
687 -         let dB = dW._2
688 -         let do = parseIntValue(dW._9)
689 -         let dE = dW._10
687 +         let eW = value(eV.payments[0])
688 +         let do = value(eW.assetId)
689 +         let eX = eW.amount
690 +         let dZ = dm(toBase58String(eV.transactionId), toBase58String(do), eX, eV.caller)
691 +         let dF = dZ._1
692 +         let dG = dZ._2
693 +         let dt = parseIntValue(dZ._9)
694 +         let dH = dZ._10
690 695          if (if (aY())
691 696              then true
692 -             else (do == n))
693 -             then throw(("Get operation is blocked by admin. Status = " + toString(do)))
694 -             else $Tuple5(dA, dB, eU, dj, dE)
697 +             else (dt == n))
698 +             then throw(("Get operation is blocked by admin. Status = " + toString(dt)))
699 +             else $Tuple5(dF, dG, eX, do, dH)
695 700          }
696 701  
697 702  
698 - func eV (eS,dG,dM) = if ((size(eS.payments) != 2))
703 + func eY (eV,dJ,dP) = if ((size(eV.payments) != 2))
699 704      then throw("exactly 2 payments are expected")
700 705      else {
701 -         let eW = value(eS.payments[0])
702 -         let eX = value(eS.payments[1])
703 -         let eY = dF(toBase58String(eS.transactionId), dG, eW.amount, eW.assetId, eX.amount, eX.assetId, toString(eS.caller), false, dM)
704 -         let do = parseIntValue(eY._8)
706 +         let eZ = value(eV.payments[0])
707 +         let fa = value(eV.payments[1])
708 +         let fb = dI(toBase58String(eV.transactionId), dJ, eZ.amount, eZ.assetId, fa.amount, fa.assetId, toString(eV.caller), false, dP)
709 +         let dt = parseIntValue(fb._8)
705 710          if (if (if (aY())
706 711              then true
707 -             else (do == l))
712 +             else (dt == l))
708 713              then true
709 -             else (do == n))
710 -             then throw(("Put operation is blocked by admin. Status = " + toString(do)))
711 -             else eY
714 +             else (dt == n))
715 +             then throw(("Put operation is blocked by admin. Status = " + toString(dt)))
716 +             else fb
712 717          }
713 718  
714 719  
715 - func eZ (bW) = {
716 -     let fa = invoke(aT, "emit", [bW], nil)
717 -     if ((fa == fa))
720 + func fc (bW) = {
721 +     let fd = invoke(aT, "emit", [bW], nil)
722 +     if ((fd == fd))
718 723          then {
719 -             let fb = {
720 -                 let bT = fa
724 +             let fe = {
725 +                 let bT = fd
721 726                  if ($isInstanceOf(bT, "Address"))
722 727                      then {
723 -                         let fc = bT
724 -                         invoke(fc, "emit", [bW], nil)
728 +                         let ff = bT
729 +                         invoke(ff, "emit", [bW], nil)
725 730                          }
726 731                      else unit
727 732                  }
728 -             if ((fb == fb))
733 +             if ((fe == fe))
729 734                  then bW
730 735                  else throw("Strict value is not equal to itself.")
731 736              }
733 738      }
734 739  
735 740  
736 - func fd (bW,ai) = {
737 -     let fe = if ((ai == 0))
741 + func fg (bW,ai) = {
742 +     let fh = if ((ai == 0))
738 743          then 0
739 744          else fraction(bW, ai, b)
740 -     $Tuple2((bW - fe), fe)
745 +     $Tuple2((bW - fh), fh)
741 746      }
742 747  
743 748  
744 - func ff (fg,fh,ab,ac) = {
745 -     let fi = (ac == unit)
746 -     let fj = bJ(bf(bn))
747 -     let fk = bJ(bf(bo))
748 -     let fl = if ((fh == bn))
749 + func fi (fj,fk,ab,ac) = {
750 +     let fl = (ac == unit)
751 +     let fm = bJ(bf(bn))
752 +     let fn = bJ(bf(bo))
753 +     let fo = if ((fk == bn))
749 754          then true
750 -         else if ((fh == bo))
755 +         else if ((fk == bo))
751 756              then false
752 757              else aQ("invalid asset")
753 -     let fm = if (fi)
754 -         then $Tuple2(fj, fk)
755 -         else if (fl)
756 -             then $Tuple2((fj - fg), fk)
757 -             else $Tuple2(fj, (fk - fg))
758 -     let fn = fm._1
759 -     let fo = fm._2
760 758      let fp = if (fl)
761 -         then $Tuple2(fg, 0)
762 -         else $Tuple2(0, fg)
759 +         then $Tuple2(fm, fn)
760 +         else if (fo)
761 +             then $Tuple2((fm - fj), fn)
762 +             else $Tuple2(fm, (fn - fj))
763 763      let fq = fp._1
764 764      let fr = fp._2
765 -     let eI = fd(fq, aV)._1
766 -     let eJ = fd(fr, aV)._1
767 -     let fs = fd(fg, aV)
765 +     let fs = if (fo)
766 +         then $Tuple2(fj, 0)
767 +         else $Tuple2(0, fj)
768 768      let ft = fs._1
769 -     let fe = fs._2
770 -     let fu = (fn + eI)
771 -     let fv = (fo + eJ)
772 -     let fw = bM(D(fv, bq), D(fu, bp))
773 -     let fx = H(fw, b)
774 -     let fy = if (fl)
775 -         then fn
776 -         else fo
777 -     let fz = toBigInt(fy)
778 -     let fA = toBigInt(valueOrErrorMessage(assetInfo(bm), (("asset " + toBase58String(bm)) + " doesn't exist")).quantity)
779 -     let fB = if ((fA > f))
769 +     let fu = fs._2
770 +     let eL = fg(ft, aV)._1
771 +     let eM = fg(fu, aV)._1
772 +     let fv = fg(fj, aV)
773 +     let fw = fv._1
774 +     let fh = fv._2
775 +     let fx = (fq + eL)
776 +     let fy = (fr + eM)
777 +     let fz = bM(D(fy, bq), D(fx, bp))
778 +     let fA = H(fz, b)
779 +     let fB = if (fo)
780 +         then fq
781 +         else fr
782 +     let fC = toBigInt(fB)
783 +     let fD = toBigInt(valueOrErrorMessage(assetInfo(bm), (("asset " + toBase58String(bm)) + " doesn't exist")).quantity)
784 +     let fE = if ((fD > f))
780 785          then true
781 786          else aQ("initial deposit requires all coins")
782 -     if ((fB == fB))
787 +     if ((fE == fE))
783 788          then {
784 -             let fC = toBigInt(ft)
785 -             let fD = max([0, toInt(((fA * (sqrtBigInt((d + ((fC * d) / fz)), 18, 18, DOWN) - d)) / d))])
786 -             let el = if (fi)
789 +             let fF = toBigInt(fw)
790 +             let fG = max([0, toInt(((fD * (sqrtBigInt((d + ((fF * d) / fC)), 18, 18, DOWN) - d)) / d))])
791 +             let eo = if (fl)
787 792                  then nil
788 -                 else [IntegerEntry(W(), fx), IntegerEntry(X(height, lastBlock.timestamp), fx), StringEntry(aa(toString(value(ab)), toBase58String(value(ac))), bu(fq, fr, fD, fx, 0, 0, height, lastBlock.timestamp, 0, 0))]
789 -             let fE = bM(D(fo, bq), D(fn, bp))
790 -             let fF = H(fE, b)
791 -             let fG = {
792 -                 let fH = if (fl)
793 -                     then $Tuple2(fq, fn)
794 -                     else $Tuple2(fr, fo)
795 -                 let bW = fH._1
796 -                 let fI = fH._2
797 -                 let fJ = toInt(fraction(fA, toBigInt((bW / 2)), toBigInt(fI)))
798 -                 fraction((fD - fJ), b, fJ)
793 +                 else [IntegerEntry(W(), fA), IntegerEntry(X(height, lastBlock.timestamp), fA), StringEntry(aa(toString(value(ab)), toBase58String(value(ac))), bu(ft, fu, fG, fA, 0, 0, height, lastBlock.timestamp, 0, 0))]
794 +             let fH = bM(D(fr, bq), D(fq, bp))
795 +             let fI = H(fH, b)
796 +             let fJ = {
797 +                 let fK = if (fo)
798 +                     then $Tuple2(ft, fq)
799 +                     else $Tuple2(fu, fr)
800 +                 let bW = fK._1
801 +                 let fL = fK._2
802 +                 let fM = toInt(fraction(fD, toBigInt((bW / 2)), toBigInt(fL)))
803 +                 fraction((fG - fM), b, fM)
799 804                  }
800 -             $Tuple5(fD, el, fe, fG, fl)
805 +             $Tuple5(fG, eo, fh, fJ, fo)
801 806              }
802 807          else throw("Strict value is not equal to itself.")
803 808      }
804 809  
805 810  
806 - func fK (fL,ft,fh,ab,ac) = {
807 -     let fi = (ac == unit)
808 -     let cY = ba()
809 -     let cZ = parseIntValue(cY[t])
810 -     let da = parseIntValue(cY[u])
811 -     let fM = [if ((fh == bm))
811 + func fN (fO,fw,fk,ab,ac) = {
812 +     let fl = (ac == unit)
813 +     let dd = ba()
814 +     let de = parseIntValue(dd[t])
815 +     let df = parseIntValue(dd[u])
816 +     let fP = [if ((fk == bm))
812 817          then true
813 818          else aQ("invalid lp asset")]
814 -     if ((fM == fM))
819 +     if ((fP == fP))
815 820          then {
816 -             let fN = if ((fL == bn))
821 +             let fQ = if ((fO == bn))
817 822                  then true
818 -                 else if ((fL == bo))
823 +                 else if ((fO == bo))
819 824                      then false
820 825                      else aQ("invalid asset")
821 -             let fO = if (fN)
826 +             let fR = if (fQ)
822 827                  then toBigInt(bJ(bf(bn)))
823 828                  else toBigInt(bJ(bf(bo)))
824 -             let fP = if (fN)
825 -                 then cZ
826 -                 else da
827 -             let fQ = bJ(bf(bn))
828 -             let fR = bJ(bf(bo))
829 -             let fS = if (fN)
830 -                 then fQ
831 -                 else fR
832 -             let fT = toBigInt(fS)
833 -             let fA = toBigInt(valueOrErrorMessage(assetInfo(bm), (("asset " + toBase58String(bm)) + " doesn't exist")).quantity)
834 -             let fU = toBigInt(ft)
835 -             let fV = max([0, toInt(((fO * (d - pow((d - ((fU * d) / fA)), 18, h, 0, 18, DOWN))) / d))])
836 -             let fW = fd(fV, aX)
837 -             let fX = fW._1
838 -             let fe = fW._2
839 -             let fY = if (fN)
840 -                 then $Tuple4(fX, 0, (fQ - fV), fR)
841 -                 else $Tuple4(0, fX, fQ, (fR - fV))
842 -             let fZ = fY._1
843 -             let ga = fY._2
844 -             let gb = fY._3
845 -             let gc = fY._4
846 -             let fw = bM(D(gc, bq), D(gb, bp))
847 -             let fx = H(fw, b)
848 -             let el = if (fi)
829 +             let fS = if (fQ)
830 +                 then de
831 +                 else df
832 +             let fT = bJ(bf(bn))
833 +             let fU = bJ(bf(bo))
834 +             let fV = if (fQ)
835 +                 then fT
836 +                 else fU
837 +             let fW = toBigInt(fV)
838 +             let fD = toBigInt(valueOrErrorMessage(assetInfo(bm), (("asset " + toBase58String(bm)) + " doesn't exist")).quantity)
839 +             let fX = toBigInt(fw)
840 +             let fY = max([0, toInt(((fR * (d - pow((d - ((fX * d) / fD)), 18, h, 0, 18, DOWN))) / d))])
841 +             let fZ = fg(fY, aX)
842 +             let ga = fZ._1
843 +             let fh = fZ._2
844 +             let gb = if (fQ)
845 +                 then $Tuple4(ga, 0, (fT - fY), fU)
846 +                 else $Tuple4(0, ga, fT, (fU - fY))
847 +             let gc = gb._1
848 +             let gd = gb._2
849 +             let ge = gb._3
850 +             let gf = gb._4
851 +             let fz = bM(D(gf, bq), D(ge, bp))
852 +             let fA = H(fz, b)
853 +             let eo = if (fl)
849 854                  then nil
850 -                 else [StringEntry(ad(toString(value(ab)), toBase58String(value(ac))), bF(fZ, ga, ft, fx, height, lastBlock.timestamp)), IntegerEntry(W(), fx), IntegerEntry(X(height, lastBlock.timestamp), fx)]
851 -             let fE = bM(D(fR, bq), D(fQ, bp))
852 -             let fF = H(fE, b)
853 -             let fG = {
854 -                 let gd = (toInt(fraction(fO, fU, fA)) * 2)
855 -                 fraction((fX - gd), b, gd)
855 +                 else [StringEntry(ad(toString(value(ab)), toBase58String(value(ac))), bF(gc, gd, fw, fA, height, lastBlock.timestamp)), IntegerEntry(W(), fA), IntegerEntry(X(height, lastBlock.timestamp), fA)]
856 +             let fH = bM(D(fU, bq), D(fT, bp))
857 +             let fI = H(fH, b)
858 +             let fJ = {
859 +                 let gg = (toInt(fraction(fR, fX, fD)) * 2)
860 +                 fraction((ga - gg), b, gg)
856 861                  }
857 -             $Tuple5(fX, el, fe, fG, fN)
862 +             $Tuple5(ga, eo, fh, fJ, fQ)
858 863              }
859 864          else throw("Strict value is not equal to itself.")
860 865      }
861 866  
862 867  
863 - func ge () = {
868 + func gh () = {
864 869      let bT = getString(U())
865 870      if ($isInstanceOf(bT, "String"))
866 871          then {
867 -             let gf = bT
868 -             fromBase58String(gf)
872 +             let gi = bT
873 +             fromBase58String(gi)
869 874              }
870 875          else if ($isInstanceOf(bT, "Unit"))
871 876              then unit
873 878      }
874 879  
875 880  
876 - func gg () = {
881 + func gj () = {
877 882      let bT = getString(V())
878 883      if ($isInstanceOf(bT, "String"))
879 884          then {
880 -             let gf = bT
881 -             fromBase58String(gf)
885 +             let gi = bT
886 +             fromBase58String(gi)
882 887              }
883 888          else if ($isInstanceOf(bT, "Unit"))
884 889              then unit
886 891      }
887 892  
888 893  
889 - func gh (eS) = {
890 -     let bT = ge()
894 + func gk (eV) = {
895 +     let bT = gh()
891 896      if ($isInstanceOf(bT, "ByteVector"))
892 897          then {
893 -             let gi = bT
894 -             (eS.callerPublicKey == gi)
898 +             let gl = bT
899 +             (eV.callerPublicKey == gl)
895 900              }
896 901          else if ($isInstanceOf(bT, "Unit"))
897 -             then (eS.caller == this)
902 +             then (eV.caller == this)
898 903              else throw("Match error")
899 904      }
900 905  
901 906  
902 - func gj (eS) = {
903 -     let gk = throw("Permission denied")
904 -     let bT = ge()
907 + func gm (eV) = {
908 +     let gn = throw("Permission denied")
909 +     let bT = gh()
905 910      if ($isInstanceOf(bT, "ByteVector"))
906 911          then {
907 -             let gi = bT
908 -             if ((eS.callerPublicKey == gi))
912 +             let gl = bT
913 +             if ((eV.callerPublicKey == gl))
909 914                  then true
910 -                 else gk
915 +                 else gn
911 916              }
912 917          else if ($isInstanceOf(bT, "Unit"))
913 -             then if ((eS.caller == this))
918 +             then if ((eV.caller == this))
914 919                  then true
915 -                 else gk
920 +                 else gn
916 921              else throw("Match error")
917 922      }
918 923  
919 924  
920 - @Callable(eS)
925 + @Callable(eV)
921 926  func rebalance () = (cD(aM(this, ae())) ++ cD(aM(this, af())))
922 927  
923 928  
924 929  
925 - @Callable(eS)
926 - func calculateAmountOutForSwapREADONLY (gl,gm,gn) = {
927 -     let go = if ((gm == false))
930 + @Callable(eV)
931 + func calculateAmountOutForSwapREADONLY (go,gp,gq) = {
932 +     let gr = if ((gp == false))
928 933          then {
929 -             let gp = aM(this, af())
930 -             let gq = aM(this, ae())
931 -             $Tuple2(gp, gq)
934 +             let gs = aM(this, af())
935 +             let gt = aM(this, ae())
936 +             $Tuple2(gs, gt)
932 937              }
933 938          else {
934 -             let gp = aM(this, ae())
935 -             let gq = aM(this, af())
936 -             $Tuple2(gp, gq)
939 +             let gs = aM(this, ae())
940 +             let gt = aM(this, af())
941 +             $Tuple2(gs, gt)
937 942              }
938 -     let gp = go._1
939 -     let gq = go._2
940 -     let gr = bJ(gq)
941 -     let gs = bJ(gp)
942 -     let gt = fraction(gs, gl, (gr + gl))
943 -     let gu = (toBigInt(gr) * toBigInt(gs))
944 -     let gv = (((toBigInt(bJ(gq)) + toBigInt(gl)) + toBigInt(gn)) * (toBigInt(bJ(gp)) - toBigInt(gt)))
945 -     let gw = if ((gv >= gu))
943 +     let gs = gr._1
944 +     let gt = gr._2
945 +     let gu = bJ(gt)
946 +     let gv = bJ(gs)
947 +     let gw = fraction(gv, go, (gu + go))
948 +     let gx = (toBigInt(gu) * toBigInt(gv))
949 +     let gy = (((toBigInt(bJ(gt)) + toBigInt(go)) + toBigInt(gq)) * (toBigInt(bJ(gs)) - toBigInt(gw)))
950 +     let gz = if ((gy >= gx))
946 951          then true
947 952          else throw("new K is fewer error")
948 -     if ((gw == gw))
949 -         then $Tuple2(nil, gt)
953 +     if ((gz == gz))
954 +         then $Tuple2(nil, gw)
950 955          else throw("Strict value is not equal to itself.")
951 956      }
952 957  
953 958  
954 959  
955 - @Callable(eS)
956 - func calculateAmountOutForSwapAndSendTokens (gl,gm,gx,gy,gn) = {
957 -     let gz = {
960 + @Callable(eV)
961 + func calculateAmountOutForSwapAndSendTokens (go,gp,gA,gB,gq) = {
962 +     let gC = {
958 963          let aW = invoke(aT, "getSwapContractREADONLY", nil, nil)
959 964          if ($isInstanceOf(aW, "String"))
960 965              then aW
961 966              else throw(($getType(aW) + " couldn't be cast to String"))
962 967          }
963 -     let fM = [if ((value(eS.payments[0]).amount >= gl))
968 +     let fP = [if ((value(eV.payments[0]).amount >= go))
964 969          then true
965 -         else aQ("Wrong amount"), if ((eS.caller == addressFromStringValue(gz)))
970 +         else aQ("Wrong amount"), if ((eV.caller == addressFromStringValue(gC)))
966 971          then true
967 972          else aQ("Permission denied")]
968 -     if ((fM == fM))
973 +     if ((fP == fP))
969 974          then {
970 -             let eT = value(eS.payments[0])
971 -             let gq = bf(eT.assetId)
972 -             let gp = if ((gm == false))
975 +             let eW = value(eV.payments[0])
976 +             let gt = bf(eW.assetId)
977 +             let gs = if ((gp == false))
973 978                  then aM(this, af())
974 979                  else aM(this, ae())
975 -             let gr = (bJ(gq) - value(eS.payments[0]).amount)
976 -             let gs = bJ(gp)
977 -             let gt = fraction(gs, gl, (gr + gl))
978 -             let gu = (toBigInt(gr) * toBigInt(gs))
979 -             let gv = ((toBigInt(bJ(gq)) + toBigInt(gn)) * (toBigInt(bJ(gp)) - toBigInt(gt)))
980 -             let gw = if ((gv >= gu))
980 +             let gu = (bJ(gt) - value(eV.payments[0]).amount)
981 +             let gv = bJ(gs)
982 +             let gw = fraction(gv, go, (gu + go))
983 +             let gx = (toBigInt(gu) * toBigInt(gv))
984 +             let gy = ((toBigInt(bJ(gt)) + toBigInt(gq)) * (toBigInt(bJ(gs)) - toBigInt(gw)))
985 +             let gz = if ((gy >= gx))
981 986                  then true
982 987                  else throw("new K is fewer error")
983 -             if ((gw == gw))
988 +             if ((gz == gz))
984 989                  then {
985 -                     let gA = if ((gt >= gx))
990 +                     let gD = if ((gw >= gA))
986 991                          then true
987 992                          else throw("Exchange result is fewer coins than expected")
988 -                     if ((gA == gA))
993 +                     if ((gD == gD))
989 994                          then {
990 -                             let gB = cD(gq)
991 -                             if ((gB == gB))
995 +                             let gE = cD(gt)
996 +                             if ((gE == gE))
992 997                                  then {
993 -                                     let gC = cK(gp, gt)
994 -                                     if ((gC == gC))
995 -                                         then $Tuple2(((gC ++ gB) ++ [ScriptTransfer(addressFromStringValue(gy), gt, bd(gp))]), gt)
998 +                                     let gF = cK(gs, gw)
999 +                                     if ((gF == gF))
1000 +                                         then $Tuple2(((gF ++ gE) ++ [ScriptTransfer(addressFromStringValue(gB), gw, bd(gs))]), gw)
996 1001                                          else throw("Strict value is not equal to itself.")
997 1002                                      }
998 1003                                  else throw("Strict value is not equal to itself.")
1006 1011  
1007 1012  
1008 1013  
1009 - @Callable(eS)
1010 - func setManager (gD) = {
1011 -     let gE = gj(eS)
1012 -     if ((gE == gE))
1014 + @Callable(eV)
1015 + func setManager (gG) = {
1016 +     let gH = gm(eV)
1017 +     if ((gH == gH))
1013 1018          then {
1014 -             let gF = fromBase58String(gD)
1015 -             if ((gF == gF))
1016 -                 then [StringEntry(V(), gD)]
1019 +             let gI = fromBase58String(gG)
1020 +             if ((gI == gI))
1021 +                 then [StringEntry(V(), gG)]
1017 1022                  else throw("Strict value is not equal to itself.")
1018 1023              }
1019 1024          else throw("Strict value is not equal to itself.")
1021 1026  
1022 1027  
1023 1028  
1024 - @Callable(eS)
1029 + @Callable(eV)
1025 1030  func confirmManager () = {
1026 -     let gG = gg()
1027 -     let gH = if (isDefined(gG))
1031 +     let gJ = gj()
1032 +     let gK = if (isDefined(gJ))
1028 1033          then true
1029 1034          else throw("No pending manager")
1030 -     if ((gH == gH))
1035 +     if ((gK == gK))
1031 1036          then {
1032 -             let gI = if ((eS.callerPublicKey == value(gG)))
1037 +             let gL = if ((eV.callerPublicKey == value(gJ)))
1033 1038                  then true
1034 1039                  else throw("You are not pending manager")
1035 -             if ((gI == gI))
1036 -                 then [StringEntry(U(), toBase58String(value(gG))), DeleteEntry(V())]
1040 +             if ((gL == gL))
1041 +                 then [StringEntry(U(), toBase58String(value(gJ))), DeleteEntry(V())]
1037 1042                  else throw("Strict value is not equal to itself.")
1038 1043              }
1039 1044          else throw("Strict value is not equal to itself.")
1041 1046  
1042 1047  
1043 1048  
1044 - @Callable(eS)
1045 - func put (dG,gJ) = if ((0 > dG))
1049 + @Callable(eV)
1050 + func put (dJ,gM) = if ((0 > dJ))
1046 1051      then throw("Invalid slippageTolerance passed")
1047 1052      else {
1048 -         let eY = eV(eS, dG, true)
1049 -         let ei = eY._2
1050 -         let dl = eY._7
1051 -         let dE = eY._9
1052 -         let ej = eY._10
1053 -         let ek = eY._11
1054 -         let gK = eY._12
1055 -         let gL = eY._13
1056 -         let eW = toBigInt(value(eS.payments[0]).amount)
1057 -         let eX = toBigInt(value(eS.payments[1]).amount)
1058 -         let ez = es(eW, eX, toBigInt(0))
1059 -         if ((ez == ez))
1053 +         let fb = eY(eV, dJ, true)
1054 +         let el = fb._2
1055 +         let dq = fb._7
1056 +         let dH = fb._9
1057 +         let em = fb._10
1058 +         let en = fb._11
1059 +         let gN = fb._12
1060 +         let gO = fb._13
1061 +         let eZ = toBigInt(value(eV.payments[0]).amount)
1062 +         let fa = toBigInt(value(eV.payments[1]).amount)
1063 +         let eC = ev(eZ, fa, toBigInt(0))
1064 +         if ((eC == eC))
1060 1065              then {
1061 -                 let fa = invoke(aT, "emit", [ei], nil)
1062 -                 if ((fa == fa))
1066 +                 let fd = invoke(aT, "emit", [el], nil)
1067 +                 if ((fd == fd))
1063 1068                      then {
1064 -                         let fb = {
1065 -                             let bT = fa
1069 +                         let fe = {
1070 +                             let bT = fd
1066 1071                              if ($isInstanceOf(bT, "Address"))
1067 1072                                  then {
1068 -                                     let fc = bT
1069 -                                     invoke(fc, "emit", [ei], nil)
1073 +                                     let ff = bT
1074 +                                     invoke(ff, "emit", [el], nil)
1070 1075                                      }
1071 1076                                  else unit
1072 1077                              }
1073 -                         if ((fb == fb))
1078 +                         if ((fe == fe))
1074 1079                              then {
1075 -                                 let gM = if ((ej > 0))
1076 -                                     then invoke(bt, "put", nil, [AttachedPayment(gK, ej)])
1080 +                                 let gP = if ((em > 0))
1081 +                                     then invoke(bt, "put", nil, [AttachedPayment(gN, em)])
1077 1082                                      else nil
1078 -                                 if ((gM == gM))
1083 +                                 if ((gP == gP))
1079 1084                                      then {
1080 -                                         let gN = if ((ek > 0))
1081 -                                             then invoke(bt, "put", nil, [AttachedPayment(gL, ek)])
1085 +                                         let gQ = if ((en > 0))
1086 +                                             then invoke(bt, "put", nil, [AttachedPayment(gO, en)])
1082 1087                                              else nil
1083 -                                         if ((gN == gN))
1088 +                                         if ((gQ == gQ))
1084 1089                                              then {
1085 -                                                 let gO = if (gJ)
1090 +                                                 let gR = if (gM)
1086 1091                                                      then {
1087 -                                                         let gP = invoke(bs, "stake", nil, [AttachedPayment(dl, ei)])
1088 -                                                         if ((gP == gP))
1092 +                                                         let gS = invoke(bs, "stake", nil, [AttachedPayment(dq, el)])
1093 +                                                         if ((gS == gS))
1089 1094                                                              then nil
1090 1095                                                              else throw("Strict value is not equal to itself.")
1091 1096                                                          }
1092 -                                                     else [ScriptTransfer(eS.caller, ei, dl)]
1093 -                                                 let gQ = eA(0, 0, 0)
1094 -                                                 if ((gQ == gQ))
1097 +                                                     else [ScriptTransfer(eV.caller, el, dq)]
1098 +                                                 let gT = eD(0, 0, 0)
1099 +                                                 if ((gT == gT))
1095 1100                                                      then {
1096 -                                                         let er = gQ._2
1097 -                                                         let gR = gQ._1
1098 -                                                         let gS = eE(ez, er)
1099 -                                                         if ((gS == gS))
1101 +                                                         let eu = gT._2
1102 +                                                         let gU = gT._1
1103 +                                                         let gV = eH(eC, eu)
1104 +                                                         if ((gV == gV))
1100 1105                                                              then {
1101 -                                                                 let gT = invoke(this, "rebalance", nil, nil)
1102 -                                                                 if ((gT == gT))
1103 -                                                                     then ((dE ++ gO) ++ gR)
1106 +                                                                 let gW = invoke(this, "rebalance", nil, nil)
1107 +                                                                 if ((gW == gW))
1108 +                                                                     then ((dH ++ gR) ++ gU)
1104 1109                                                                      else throw("Strict value is not equal to itself.")
1105 1110                                                                  }
1106 1111                                                              else throw("Strict value is not equal to itself.")
1120 1125  
1121 1126  
1122 1127  
1123 - @Callable(eS)
1124 - func putForFree (gU) = if ((0 > gU))
1128 + @Callable(eV)
1129 + func putForFree (gX) = if ((0 > gX))
1125 1130      then throw("Invalid value passed")
1126 1131      else {
1127 -         let eY = eV(eS, gU, false)
1128 -         let dE = eY._9
1129 -         let eW = toBigInt(value(eS.payments[0]).amount)
1130 -         let eX = toBigInt(value(eS.payments[1]).amount)
1131 -         let ez = es(eW, eX, toBigInt(0))
1132 -         if ((ez == ez))
1132 +         let fb = eY(eV, gX, false)
1133 +         let dH = fb._9
1134 +         let eZ = toBigInt(value(eV.payments[0]).amount)
1135 +         let fa = toBigInt(value(eV.payments[1]).amount)
1136 +         let eC = ev(eZ, fa, toBigInt(0))
1137 +         if ((eC == eC))
1133 1138              then {
1134 -                 let gV = eA(0, 0, 0)
1135 -                 let gR = gV._1
1136 -                 let er = gV._2
1137 -                 let gS = eE(ez, er)
1138 -                 if ((gS == gS))
1139 -                     then (dE ++ gR)
1139 +                 let gY = eD(0, 0, 0)
1140 +                 let gU = gY._1
1141 +                 let eu = gY._2
1142 +                 let gV = eH(eC, eu)
1143 +                 if ((gV == gV))
1144 +                     then (dH ++ gU)
1140 1145                      else throw("Strict value is not equal to itself.")
1141 1146                  }
1142 1147              else throw("Strict value is not equal to itself.")
1144 1149  
1145 1150  
1146 1151  
1147 - @Callable(eS)
1148 - func putOneTkn (gW,gX) = {
1149 -     let gY = {
1152 + @Callable(eV)
1153 + func putOneTkn (gZ,ha) = {
1154 +     let hb = {
1150 1155          let aW = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1151 1156          if ($isInstanceOf(aW, "Boolean"))
1152 1157              then aW
1153 1158              else throw(($getType(aW) + " couldn't be cast to Boolean"))
1154 1159          }
1155 -     let gZ = if (if (if (aY())
1160 +     let hc = if (if (if (aY())
1156 1161          then true
1157 1162          else (bl == l))
1158 1163          then true
1159 1164          else (bl == n))
1160 1165          then true
1161 -         else gY
1162 -     let fM = [if (if (!(gZ))
1166 +         else hb
1167 +     let fP = [if (if (!(hc))
1163 1168          then true
1164 -         else gh(eS))
1169 +         else gk(eV))
1165 1170          then true
1166 -         else aQ("put operation is blocked by admin"), if ((size(eS.payments) == 1))
1171 +         else aQ("put operation is blocked by admin"), if ((size(eV.payments) == 1))
1167 1172          then true
1168 1173          else aQ("exactly 1 payment are expected")]
1169 -     if ((fM == fM))
1174 +     if ((fP == fP))
1170 1175          then {
1171 -             let ha = eS.payments[0]
1172 -             let fh = ha.assetId
1173 -             let fg = ha.amount
1174 -             let ez = if ((fh == bn))
1175 -                 then es(toBigInt(fg), toBigInt(0), toBigInt(0))
1176 -                 else if ((fh == bo))
1177 -                     then es(toBigInt(0), toBigInt(fg), toBigInt(0))
1176 +             let hd = eV.payments[0]
1177 +             let fk = hd.assetId
1178 +             let fj = hd.amount
1179 +             let eC = if ((fk == bn))
1180 +                 then ev(toBigInt(fj), toBigInt(0), toBigInt(0))
1181 +                 else if ((fk == bo))
1182 +                     then ev(toBigInt(0), toBigInt(fj), toBigInt(0))
1178 1183                      else aQ("payment asset is not supported")
1179 -             if ((ez == ez))
1184 +             if ((eC == eC))
1180 1185                  then {
1181 -                     let ab = eS.caller
1182 -                     let ac = eS.transactionId
1183 -                     let hb = ff(fg, fh, ab, ac)
1184 -                     if ((hb == hb))
1186 +                     let ab = eV.caller
1187 +                     let ac = eV.transactionId
1188 +                     let he = fi(fj, fk, ab, ac)
1189 +                     if ((he == he))
1185 1190                          then {
1186 -                             let fl = hb._5
1187 -                             let hc = hb._4
1188 -                             let fe = hb._3
1189 -                             let el = hb._2
1190 -                             let hd = hb._1
1191 -                             let he = if (if ((gW > 0))
1192 -                                 then (gW > hd)
1191 +                             let fo = he._5
1192 +                             let hf = he._4
1193 +                             let fh = he._3
1194 +                             let eo = he._2
1195 +                             let hg = he._1
1196 +                             let hh = if (if ((gZ > 0))
1197 +                                 then (gZ > hg)
1193 1198                                  else false)
1194 -                                 then aQ(makeString(["amount to receive is less than ", toString(gW)], ""))
1195 -                                 else hd
1196 -                             let fa = eZ(he)
1197 -                             if ((fa == fa))
1199 +                                 then aQ(makeString(["amount to receive is less than ", toString(gZ)], ""))
1200 +                                 else hg
1201 +                             let fd = fc(hh)
1202 +                             if ((fd == fd))
1198 1203                                  then {
1199 -                                     let gO = if (gX)
1204 +                                     let gR = if (ha)
1200 1205                                          then {
1201 -                                             let hf = invoke(bs, "stake", nil, [AttachedPayment(bm, he)])
1202 -                                             if ((hf == hf))
1206 +                                             let hi = invoke(bs, "stake", nil, [AttachedPayment(bm, hh)])
1207 +                                             if ((hi == hi))
1203 1208                                                  then nil
1204 1209                                                  else throw("Strict value is not equal to itself.")
1205 1210                                              }
1206 -                                         else [ScriptTransfer(eS.caller, he, bm)]
1207 -                                     let hg = if ((fe > 0))
1208 -                                         then [ScriptTransfer(aU, fe, fh)]
1211 +                                         else [ScriptTransfer(eV.caller, hh, bm)]
1212 +                                     let hj = if ((fh > 0))
1213 +                                         then [ScriptTransfer(aU, fh, fk)]
1209 1214                                          else nil
1210 -                                     let hh = if ((this == aU))
1215 +                                     let hk = if ((this == aU))
1211 1216                                          then $Tuple2(0, 0)
1212 -                                         else if (fl)
1213 -                                             then $Tuple2(-(fe), 0)
1214 -                                             else $Tuple2(0, -(fe))
1215 -                                     let eB = hh._1
1216 -                                     let eC = hh._2
1217 -                                     let hi = eA(eB, eC, 0)
1218 -                                     let gR = hi._1
1219 -                                     let er = hi._2
1220 -                                     let eL = value(getString(aj))
1221 -                                     let gS = eE(ez, er)
1222 -                                     if ((gS == gS))
1217 +                                         else if (fo)
1218 +                                             then $Tuple2(-(fh), 0)
1219 +                                             else $Tuple2(0, -(fh))
1220 +                                     let eE = hk._1
1221 +                                     let eF = hk._2
1222 +                                     let hl = eD(eE, eF, 0)
1223 +                                     let gU = hl._1
1224 +                                     let eu = hl._2
1225 +                                     let eO = value(getString(aj))
1226 +                                     let gV = eH(eC, eu)
1227 +                                     if ((gV == gV))
1223 1228                                          then {
1224 -                                             let gT = invoke(this, "rebalance", nil, nil)
1225 -                                             if ((gT == gT))
1226 -                                                 then $Tuple2((((el ++ gO) ++ hg) ++ gR), he)
1229 +                                             let gW = invoke(this, "rebalance", nil, nil)
1230 +                                             if ((gW == gW))
1231 +                                                 then $Tuple2((((eo ++ gR) ++ hj) ++ gU), hh)
1227 1232                                                  else throw("Strict value is not equal to itself.")
1228 1233                                              }
1229 1234                                          else throw("Strict value is not equal to itself.")
1239 1244  
1240 1245  
1241 1246  
1242 - @Callable(eS)
1243 - func putOneTknREADONLY (fh,fg) = {
1244 -     let hj = ff(fg, bd(fh), unit, unit)
1245 -     let hd = hj._1
1246 -     let el = hj._2
1247 -     let fe = hj._3
1248 -     let hc = hj._4
1249 -     let fl = hj._5
1250 -     $Tuple2(nil, $Tuple3(hd, fe, hc))
1247 + @Callable(eV)
1248 + func putOneTknREADONLY (fk,fj) = {
1249 +     let hm = fi(fj, bd(fk), unit, unit)
1250 +     let hg = hm._1
1251 +     let eo = hm._2
1252 +     let fh = hm._3
1253 +     let hf = hm._4
1254 +     let fo = hm._5
1255 +     $Tuple2(nil, $Tuple3(hg, fh, hf))
1251 1256      }
1252 1257  
1253 1258  
1254 1259  
1255 - @Callable(eS)
1256 - func getOneTkn (hk,gW) = {
1257 -     let gY = {
1260 + @Callable(eV)
1261 + func getOneTkn (hn,gZ) = {
1262 +     let hb = {
1258 1263          let aW = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1259 1264          if ($isInstanceOf(aW, "Boolean"))
1260 1265              then aW
1261 1266              else throw(($getType(aW) + " couldn't be cast to Boolean"))
1262 1267          }
1263 -     let hl = if (if (aY())
1268 +     let ho = if (if (aY())
1264 1269          then true
1265 1270          else (bl == n))
1266 1271          then true
1267 -         else gY
1268 -     let fM = [if (if (!(hl))
1272 +         else hb
1273 +     let fP = [if (if (!(ho))
1269 1274          then true
1270 -         else gh(eS))
1275 +         else gk(eV))
1271 1276          then true
1272 -         else aQ("get operation is blocked by admin"), if ((size(eS.payments) == 1))
1277 +         else aQ("get operation is blocked by admin"), if ((size(eV.payments) == 1))
1273 1278          then true
1274 1279          else aQ("exactly 1 payment are expected")]
1275 -     if ((fM == fM))
1280 +     if ((fP == fP))
1276 1281          then {
1277 -             let fL = bd(hk)
1278 -             let ha = eS.payments[0]
1279 -             let fh = ha.assetId
1280 -             let ft = ha.amount
1281 -             let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1282 -             if ((ez == ez))
1282 +             let fO = bd(hn)
1283 +             let hd = eV.payments[0]
1284 +             let fk = hd.assetId
1285 +             let fw = hd.amount
1286 +             let eC = ev(toBigInt(0), toBigInt(0), toBigInt(0))
1287 +             if ((eC == eC))
1283 1288                  then {
1284 -                     let ab = eS.caller
1285 -                     let ac = eS.transactionId
1286 -                     let hm = fK(fL, ft, fh, ab, ac)
1287 -                     if ((hm == hm))
1289 +                     let ab = eV.caller
1290 +                     let ac = eV.transactionId
1291 +                     let hp = fN(fO, fw, fk, ab, ac)
1292 +                     if ((hp == hp))
1288 1293                          then {
1289 -                             let fN = hm._5
1290 -                             let hc = hm._4
1291 -                             let fe = hm._3
1292 -                             let el = hm._2
1293 -                             let hn = hm._1
1294 -                             let bW = if (if ((gW > 0))
1295 -                                 then (gW > hn)
1294 +                             let fQ = hp._5
1295 +                             let hf = hp._4
1296 +                             let fh = hp._3
1297 +                             let eo = hp._2
1298 +                             let hq = hp._1
1299 +                             let bW = if (if ((gZ > 0))
1300 +                                 then (gZ > hq)
1296 1301                                  else false)
1297 -                                 then aQ(makeString(["amount to receive is less than ", toString(gW)], ""))
1298 -                                 else hn
1299 -                             let ho = invoke(aT, "burn", [ft], [AttachedPayment(fh, ft)])
1300 -                             if ((ho == ho))
1302 +                                 then aQ(makeString(["amount to receive is less than ", toString(gZ)], ""))
1303 +                                 else hq
1304 +                             let hr = invoke(aT, "burn", [fw], [AttachedPayment(fk, fw)])
1305 +                             if ((hr == hr))
1301 1306                                  then {
1302 -                                     let gC = cK(hk, bW)
1303 -                                     let hp = [ScriptTransfer(ab, bW, fL)]
1304 -                                     let hg = if ((fe > 0))
1305 -                                         then [ScriptTransfer(aU, fe, fL)]
1307 +                                     let gF = cK(hn, bW)
1308 +                                     let hs = [ScriptTransfer(ab, bW, fO)]
1309 +                                     let hj = if ((fh > 0))
1310 +                                         then [ScriptTransfer(aU, fh, fO)]
1306 1311                                          else nil
1307 -                                     let hq = {
1308 -                                         let hr = if ((this == aU))
1312 +                                     let ht = {
1313 +                                         let hu = if ((this == aU))
1309 1314                                              then 0
1310 -                                             else fe
1311 -                                         if (fN)
1312 -                                             then $Tuple2(-((bW + hr)), 0)
1313 -                                             else $Tuple2(0, -((bW + hr)))
1315 +                                             else fh
1316 +                                         if (fQ)
1317 +                                             then $Tuple2(-((bW + hu)), 0)
1318 +                                             else $Tuple2(0, -((bW + hu)))
1314 1319                                          }
1315 -                                     let eB = hq._1
1316 -                                     let eC = hq._2
1317 -                                     let hs = eA(eB, eC, 0)
1318 -                                     let gR = hs._1
1319 -                                     let er = hs._2
1320 -                                     let gS = eE(ez, er)
1321 -                                     if ((gS == gS))
1322 -                                         then $Tuple2(((((el ++ gC) ++ hp) ++ hg) ++ gR), bW)
1320 +                                     let eE = ht._1
1321 +                                     let eF = ht._2
1322 +                                     let hv = eD(eE, eF, 0)
1323 +                                     let gU = hv._1
1324 +                                     let eu = hv._2
1325 +                                     let gV = eH(eC, eu)
1326 +                                     if ((gV == gV))
1327 +                                         then $Tuple2(((((eo ++ gF) ++ hs) ++ hj) ++ gU), bW)
1323 1328                                          else throw("Strict value is not equal to itself.")
1324 1329                                      }
1325 1330                                  else throw("Strict value is not equal to itself.")
1333 1338  
1334 1339  
1335 1340  
1336 - @Callable(eS)
1337 - func getOneTknREADONLY (fL,ft) = {
1338 -     let ht = fK(bd(fL), ft, bm, unit, unit)
1339 -     let hn = ht._1
1340 -     let el = ht._2
1341 -     let fe = ht._3
1342 -     let hc = ht._4
1343 -     let fN = ht._5
1344 -     $Tuple2(nil, $Tuple3(hn, fe, hc))
1341 + @Callable(eV)
1342 + func getOneTknREADONLY (fO,fw) = {
1343 +     let hw = fN(bd(fO), fw, bm, unit, unit)
1344 +     let hq = hw._1
1345 +     let eo = hw._2
1346 +     let fh = hw._3
1347 +     let hf = hw._4
1348 +     let fQ = hw._5
1349 +     $Tuple2(nil, $Tuple3(hq, fh, hf))
1345 1350      }
1346 1351  
1347 1352  
1348 1353  
1349 - @Callable(eS)
1350 - func unstakeAndGetOneTkn (hu,hk,gW) = {
1351 -     let gY = {
1354 + @Callable(eV)
1355 + func unstakeAndGetOneTkn (hx,hn,gZ) = {
1356 +     let hb = {
1352 1357          let aW = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1353 1358          if ($isInstanceOf(aW, "Boolean"))
1354 1359              then aW
1355 1360              else throw(($getType(aW) + " couldn't be cast to Boolean"))
1356 1361          }
1357 -     let hl = if (if (aY())
1362 +     let ho = if (if (aY())
1358 1363          then true
1359 1364          else (bl == n))
1360 1365          then true
1361 -         else gY
1362 -     let fM = [if (if (!(hl))
1366 +         else hb
1367 +     let fP = [if (if (!(ho))
1363 1368          then true
1364 -         else gh(eS))
1369 +         else gk(eV))
1365 1370          then true
1366 -         else aQ("get operation is blocked by admin"), if ((size(eS.payments) == 0))
1371 +         else aQ("get operation is blocked by admin"), if ((size(eV.payments) == 0))
1367 1372          then true
1368 1373          else aQ("no payments are expected")]
1369 -     if ((fM == fM))
1374 +     if ((fP == fP))
1370 1375          then {
1371 -             let fL = bd(hk)
1372 -             let ab = eS.caller
1373 -             let ac = eS.transactionId
1374 -             let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1375 -             if ((ez == ez))
1376 +             let fO = bd(hn)
1377 +             let ab = eV.caller
1378 +             let ac = eV.transactionId
1379 +             let eC = ev(toBigInt(0), toBigInt(0), toBigInt(0))
1380 +             if ((eC == eC))
1376 1381                  then {
1377 -                     let hv = invoke(bs, "unstake", [toBase58String(bm), hu], nil)
1378 -                     if ((hv == hv))
1382 +                     let hy = invoke(bs, "unstake", [toBase58String(bm), hx], nil)
1383 +                     if ((hy == hy))
1379 1384                          then {
1380 -                             let hw = fK(fL, hu, bm, ab, ac)
1381 -                             if ((hw == hw))
1385 +                             let hz = fN(fO, hx, bm, ab, ac)
1386 +                             if ((hz == hz))
1382 1387                                  then {
1383 -                                     let fN = hw._5
1384 -                                     let hc = hw._4
1385 -                                     let fe = hw._3
1386 -                                     let el = hw._2
1387 -                                     let hn = hw._1
1388 -                                     let bW = if (if ((gW > 0))
1389 -                                         then (gW > hn)
1388 +                                     let fQ = hz._5
1389 +                                     let hf = hz._4
1390 +                                     let fh = hz._3
1391 +                                     let eo = hz._2
1392 +                                     let hq = hz._1
1393 +                                     let bW = if (if ((gZ > 0))
1394 +                                         then (gZ > hq)
1390 1395                                          else false)
1391 -                                         then aQ(makeString(["amount to receive is less than ", toString(gW)], ""))
1392 -                                         else hn
1393 -                                     let ho = invoke(aT, "burn", [hu], [AttachedPayment(bm, hu)])
1394 -                                     if ((ho == ho))
1396 +                                         then aQ(makeString(["amount to receive is less than ", toString(gZ)], ""))
1397 +                                         else hq
1398 +                                     let hr = invoke(aT, "burn", [hx], [AttachedPayment(bm, hx)])
1399 +                                     if ((hr == hr))
1395 1400                                          then {
1396 -                                             let gC = cK(hk, bW)
1397 -                                             let hp = [ScriptTransfer(eS.caller, bW, fL)]
1398 -                                             let hg = if ((fe > 0))
1399 -                                                 then [ScriptTransfer(aU, fe, fL)]
1401 +                                             let gF = cK(hn, bW)
1402 +                                             let hs = [ScriptTransfer(eV.caller, bW, fO)]
1403 +                                             let hj = if ((fh > 0))
1404 +                                                 then [ScriptTransfer(aU, fh, fO)]
1400 1405                                                  else nil
1401 -                                             let hx = {
1402 -                                                 let hr = if ((this == aU))
1406 +                                             let hA = {
1407 +                                                 let hu = if ((this == aU))
1403 1408                                                      then 0
1404 -                                                     else fe
1405 -                                                 if (fN)
1406 -                                                     then $Tuple2(-((bW + hr)), 0)
1407 -                                                     else $Tuple2(0, -((bW + hr)))
1409 +                                                     else fh
1410 +                                                 if (fQ)
1411 +                                                     then $Tuple2(-((bW + hu)), 0)
1412 +                                                     else $Tuple2(0, -((bW + hu)))
1408 1413                                                  }
1409 -                                             let eB = hx._1
1410 -                                             let eC = hx._2
1411 -                                             let hy = eA(eB, eC, 0)
1412 -                                             let gR = hy._1
1413 -                                             let er = hy._2
1414 -                                             let gS = eE(ez, er)
1415 -                                             if ((gS == gS))
1416 -                                                 then $Tuple2(((((el ++ gC) ++ hp) ++ hg) ++ gR), bW)
1414 +                                             let eE = hA._1
1415 +                                             let eF = hA._2
1416 +                                             let hB = eD(eE, eF, 0)
1417 +                                             let gU = hB._1
1418 +                                             let eu = hB._2
1419 +                                             let gV = eH(eC, eu)
1420 +                                             if ((gV == gV))
1421 +                                                 then $Tuple2(((((eo ++ gF) ++ hs) ++ hj) ++ gU), bW)
1417 1422                                                  else throw("Strict value is not equal to itself.")
1418 1423                                              }
1419 1424                                          else throw("Strict value is not equal to itself.")
1429 1434  
1430 1435  
1431 1436  
1432 - @Callable(eS)
1437 + @Callable(eV)
1433 1438  func get () = {
1434 -     let dW = eR(eS)
1435 -     let hz = dW._1
1436 -     let dB = dW._2
1437 -     let eU = dW._3
1438 -     let dj = dW._4
1439 -     let dE = dW._5
1440 -     let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1441 -     if ((ez == ez))
1439 +     let dZ = eU(eV)
1440 +     let dF = dZ._1
1441 +     let dG = dZ._2
1442 +     let eX = dZ._3
1443 +     let do = dZ._4
1444 +     let dH = dZ._5
1445 +     let gF = cP(dF, dG)
1446 +     let eC = ev(toBigInt(0), toBigInt(0), toBigInt(0))
1447 +     if ((eC == eC))
1442 1448          then {
1443 -             let hA = invoke(aT, "burn", [eU], [AttachedPayment(dj, eU)])
1444 -             if ((hA == hA))
1449 +             let hC = invoke(aT, "burn", [eX], [AttachedPayment(do, eX)])
1450 +             if ((hC == hC))
1445 1451                  then {
1446 -                     let hB = eA(-(hz), -(dB), 0)
1447 -                     let gR = hB._1
1448 -                     let er = hB._2
1449 -                     let gS = eE(ez, er)
1450 -                     if ((gS == gS))
1451 -                         then (dE ++ gR)
1452 +                     let hD = eD(-(dF), -(dG), 0)
1453 +                     let gU = hD._1
1454 +                     let eu = hD._2
1455 +                     let gV = eH(eC, eu)
1456 +                     if ((gV == gV))
1457 +                         then ((gF ++ dH) ++ gU)
1452 1458                          else throw("Strict value is not equal to itself.")
1453 1459                      }
1454 1460                  else throw("Strict value is not equal to itself.")
1458 1464  
1459 1465  
1460 1466  
1461 - @Callable(eS)
1462 - func getNoLess (hC,hD) = {
1463 -     let dW = eR(eS)
1464 -     let dA = dW._1
1465 -     let dB = dW._2
1466 -     let eU = dW._3
1467 -     let dj = dW._4
1468 -     let dE = dW._5
1469 -     if ((hC > dA))
1470 -         then throw(((("noLessThenAmtAsset failed:  " + toString(dA)) + " < ") + toString(hC)))
1471 -         else if ((hD > dB))
1472 -             then throw(((("noLessThenPriceAsset failed: " + toString(dB)) + " < ") + toString(hD)))
1467 + @Callable(eV)
1468 + func getNoLess (hE,hF) = {
1469 +     let dZ = eU(eV)
1470 +     let dF = dZ._1
1471 +     let dG = dZ._2
1472 +     let eX = dZ._3
1473 +     let do = dZ._4
1474 +     let dH = dZ._5
1475 +     if ((hE > dF))
1476 +         then throw(((("noLessThenAmtAsset failed:  " + toString(dF)) + " < ") + toString(hE)))
1477 +         else if ((hF > dG))
1478 +             then throw(((("noLessThenPriceAsset failed: " + toString(dG)) + " < ") + toString(hF)))
1473 1479              else {
1474 -                 let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1475 -                 if ((ez == ez))
1480 +                 let gF = cP(dF, dG)
1481 +                 let eC = ev(toBigInt(0), toBigInt(0), toBigInt(0))
1482 +                 if ((eC == eC))
1476 1483                      then {
1477 -                         let hA = invoke(aT, "burn", [eU], [AttachedPayment(dj, eU)])
1478 -                         if ((hA == hA))
1484 +                         let hC = invoke(aT, "burn", [eX], [AttachedPayment(do, eX)])
1485 +                         if ((hC == hC))
1479 1486                              then {
1480 -                                 let hE = eA(-(dA), -(dB), 0)
1481 -                                 let gR = hE._1
1482 -                                 let er = hE._2
1483 -                                 let gS = eE(ez, er)
1484 -                                 if ((gS == gS))
1485 -                                     then (dE ++ gR)
1487 +                                 let hG = eD(-(dF), -(dG), 0)
1488 +                                 let gU = hG._1
1489 +                                 let eu = hG._2
1490 +                                 let gV = eH(eC, eu)
1491 +                                 if ((gV == gV))
1492 +                                     then ((gF ++ dH) ++ gU)
1486 1493                                      else throw("Strict value is not equal to itself.")
1487 1494                                  }
1488 1495                              else throw("Strict value is not equal to itself.")
1493 1500  
1494 1501  
1495 1502  
1496 - @Callable(eS)
1503 + @Callable(eV)
1497 1504  func unstakeAndGet (bW) = {
1498 -     let hF = if ((size(eS.payments) != 0))
1505 +     let hH = if ((size(eV.payments) != 0))
1499 1506          then throw("No payments are expected")
1500 1507          else true
1501 -     if ((hF == hF))
1508 +     if ((hH == hH))
1502 1509          then {
1503 -             let cY = ba()
1504 -             let dl = fromBase58String(cY[q])
1505 -             let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1506 -             if ((ez == ez))
1510 +             let dd = ba()
1511 +             let dq = fromBase58String(dd[q])
1512 +             let eC = ev(toBigInt(0), toBigInt(0), toBigInt(0))
1513 +             if ((eC == eC))
1507 1514                  then {
1508 -                     let hv = invoke(bs, "unstake", [toBase58String(dl), bW], nil)
1509 -                     if ((hv == hv))
1515 +                     let hy = invoke(bs, "unstake", [toBase58String(dq), bW], nil)
1516 +                     if ((hy == hy))
1510 1517                          then {
1511 -                             let dW = dh(toBase58String(eS.transactionId), toBase58String(dl), bW, eS.caller)
1512 -                             let dA = dW._1
1513 -                             let dB = dW._2
1514 -                             let do = parseIntValue(dW._9)
1515 -                             let dE = dW._10
1516 -                             let hG = if (if (aY())
1518 +                             let dZ = dm(toBase58String(eV.transactionId), toBase58String(dq), bW, eV.caller)
1519 +                             let dF = dZ._1
1520 +                             let dG = dZ._2
1521 +                             let dt = parseIntValue(dZ._9)
1522 +                             let dH = dZ._10
1523 +                             let gF = cP(dF, dG)
1524 +                             let hI = if (if (aY())
1517 1525                                  then true
1518 -                                 else (do == n))
1519 -                                 then throw(("Get operation is blocked by admin. Status = " + toString(do)))
1526 +                                 else (dt == n))
1527 +                                 then throw(("Get operation is blocked by admin. Status = " + toString(dt)))
1520 1528                                  else true
1521 -                             if ((hG == hG))
1529 +                             if ((hI == hI))
1522 1530                                  then {
1523 -                                     let hA = invoke(aT, "burn", [bW], [AttachedPayment(dl, bW)])
1524 -                                     if ((hA == hA))
1531 +                                     let hC = invoke(aT, "burn", [bW], [AttachedPayment(dq, bW)])
1532 +                                     if ((hC == hC))
1525 1533                                          then {
1526 -                                             let hH = eA(-(dA), -(dB), 0)
1527 -                                             let gR = hH._1
1528 -                                             let er = hH._2
1529 -                                             let gS = eE(ez, er)
1530 -                                             if ((gS == gS))
1531 -                                                 then (dE ++ gR)
1534 +                                             let hJ = eD(-(dF), -(dG), 0)
1535 +                                             let gU = hJ._1
1536 +                                             let eu = hJ._2
1537 +                                             let gV = eH(eC, eu)
1538 +                                             if ((gV == gV))
1539 +                                                 then ((gF ++ dH) ++ gU)
1532 1540                                                  else throw("Strict value is not equal to itself.")
1533 1541                                              }
1534 1542                                          else throw("Strict value is not equal to itself.")
1544 1552  
1545 1553  
1546 1554  
1547 - @Callable(eS)
1548 - func unstakeAndGetNoLess (hu,hI,hD) = {
1549 -     let hl = if (aY())
1555 + @Callable(eV)
1556 + func unstakeAndGetNoLess (hx,hK,hF) = {
1557 +     let ho = if (aY())
1550 1558          then true
1551 1559          else (bl == n)
1552 -     let fM = [if (!(hl))
1560 +     let fP = [if (!(ho))
1553 1561          then true
1554 -         else throw("get operation is blocked by admin"), if ((size(eS.payments) == 0))
1562 +         else throw("get operation is blocked by admin"), if ((size(eV.payments) == 0))
1555 1563          then true
1556 1564          else throw("no payments are expected")]
1557 -     if ((fM == fM))
1565 +     if ((fP == fP))
1558 1566          then {
1559 -             let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1560 -             if ((ez == ez))
1567 +             let eC = ev(toBigInt(0), toBigInt(0), toBigInt(0))
1568 +             if ((eC == eC))
1561 1569                  then {
1562 -                     let hv = invoke(bs, "unstake", [toBase58String(bm), hu], nil)
1563 -                     if ((hv == hv))
1570 +                     let hy = invoke(bs, "unstake", [toBase58String(bm), hx], nil)
1571 +                     if ((hy == hy))
1564 1572                          then {
1565 -                             let dW = dh(toBase58String(eS.transactionId), toBase58String(bm), hu, eS.caller)
1566 -                             let dA = dW._1
1567 -                             let dB = dW._2
1568 -                             let dE = dW._10
1569 -                             let hJ = [if ((dA >= hI))
1573 +                             let dZ = dm(toBase58String(eV.transactionId), toBase58String(bm), hx, eV.caller)
1574 +                             let dF = dZ._1
1575 +                             let dG = dZ._2
1576 +                             let dH = dZ._10
1577 +                             let gF = cP(dF, dG)
1578 +                             let hL = [if ((dF >= hK))
1570 1579                                  then true
1571 -                                 else throw(makeString(["amount asset amount to receive is less than ", toString(hI)], "")), if ((dB >= hD))
1580 +                                 else throw(makeString(["amount asset amount to receive is less than ", toString(hK)], "")), if ((dG >= hF))
1572 1581                                  then true
1573 -                                 else throw(makeString(["price asset amount to receive is less than ", toString(hD)], ""))]
1574 -                             if ((hJ == hJ))
1582 +                                 else throw(makeString(["price asset amount to receive is less than ", toString(hF)], ""))]
1583 +                             if ((hL == hL))
1575 1584                                  then {
1576 -                                     let hA = invoke(aT, "burn", [hu], [AttachedPayment(bm, hu)])
1577 -                                     if ((hA == hA))
1585 +                                     let hC = invoke(aT, "burn", [hx], [AttachedPayment(bm, hx)])
1586 +                                     if ((hC == hC))
1578 1587                                          then {
1579 -                                             let hK = eA(-(dA), -(dB), 0)
1580 -                                             let gR = hK._1
1581 -                                             let er = hK._2
1582 -                                             let gS = eE(ez, er)
1583 -                                             if ((gS == gS))
1584 -                                                 then (dE ++ gR)
1588 +                                             let hM = eD(-(dF), -(dG), 0)
1589 +                                             let gU = hM._1
1590 +                                             let eu = hM._2
1591 +                                             let gV = eH(eC, eu)
1592 +                                             if ((gV == gV))
1593 +                                                 then ((gF ++ dH) ++ gU)
1585 1594                                                  else throw("Strict value is not equal to itself.")
1586 1595                                              }
1587 1596                                          else throw("Strict value is not equal to itself.")
1597 1606  
1598 1607  
1599 1608  
1600 - @Callable(eS)
1601 - func activate (hL,hM) = if ((toString(eS.caller) != toString(aT)))
1609 + @Callable(eV)
1610 + func activate (hN,hO) = if ((toString(eV.caller) != toString(aT)))
1602 1611      then throw("permissions denied")
1603 -     else $Tuple2([StringEntry(ae(), hL), StringEntry(af(), hM)], "success")
1612 +     else $Tuple2([StringEntry(ae(), hN), StringEntry(af(), hO)], "success")
1604 1613  
1605 1614  
1606 1615  
1607 - @Callable(eS)
1616 + @Callable(eV)
1608 1617  func refreshKLp () = {
1609 -     let hN = valueOrElse(getInteger(ak), 0)
1610 -     let hO = if (((height - hN) >= an))
1618 +     let hP = valueOrElse(getInteger(ak), 0)
1619 +     let hQ = if (((height - hP) >= an))
1611 1620          then unit
1612 1621          else aQ(makeString([toString(an), " blocks have not passed since the previous call"], ""))
1613 -     if ((hO == hO))
1622 +     if ((hQ == hQ))
1614 1623          then {
1615 -             let eL = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
1616 -             let hP = eA(0, 0, 0)
1617 -             let hQ = hP._1
1618 -             let er = hP._2
1619 -             let eD = if ((eL != er))
1620 -                 then hQ
1624 +             let eO = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
1625 +             let hR = eD(0, 0, 0)
1626 +             let hS = hR._1
1627 +             let eu = hR._2
1628 +             let eG = if ((eO != eu))
1629 +                 then hS
1621 1630                  else aQ("nothing to refresh")
1622 -             $Tuple2(eD, toString(er))
1631 +             $Tuple2(eG, toString(eu))
1623 1632              }
1624 1633          else throw("Strict value is not equal to itself.")
1625 1634      }
1626 1635  
1627 1636  
1628 1637  
1629 - @Callable(eS)
1638 + @Callable(eV)
1630 1639  func getPoolConfigWrapperREADONLY () = $Tuple2(nil, ba())
1631 1640  
1632 1641  
1633 1642  
1634 - @Callable(eS)
1643 + @Callable(eV)
1635 1644  func getAccBalanceWrapperREADONLY (ap) = $Tuple2(nil, bJ(ap))
1636 1645  
1637 1646  
1638 1647  
1639 - @Callable(eS)
1640 - func calcPricesWrapperREADONLY (cS,cT,cX) = {
1641 -     let dg = cW(cS, cT, cX)
1642 -     $Tuple2(nil, [toString(dg[0]), toString(dg[1]), toString(dg[2])])
1648 + @Callable(eV)
1649 + func calcPricesWrapperREADONLY (cX,cY,dc) = {
1650 +     let dl = db(cX, cY, dc)
1651 +     $Tuple2(nil, [toString(dl[0]), toString(dl[1]), toString(dl[2])])
1643 1652      }
1644 1653  
1645 1654  
1646 1655  
1647 - @Callable(eS)
1656 + @Callable(eV)
1648 1657  func toX18WrapperREADONLY (E,F) = $Tuple2(nil, toString(D(E, F)))
1649 1658  
1650 1659  
1651 1660  
1652 - @Callable(eS)
1661 + @Callable(eV)
1653 1662  func fromX18WrapperREADONLY (I,J) = $Tuple2(nil, H(parseBigIntValue(I), J))
1654 1663  
1655 1664  
1656 1665  
1657 - @Callable(eS)
1666 + @Callable(eV)
1658 1667  func calcPriceBigIntWrapperREADONLY (bN,bO) = $Tuple2(nil, toString(bM(parseBigIntValue(bN), parseBigIntValue(bO))))
1659 1668  
1660 1669  
1661 1670  
1662 - @Callable(eS)
1663 - func estimatePutOperationWrapperREADONLY (di,dG,dH,dI,dJ,dK,ab,dL,dM) = $Tuple2(nil, dF(di, dG, dH, dI, dJ, dK, ab, dL, dM))
1671 + @Callable(eV)
1672 + func estimatePutOperationWrapperREADONLY (dn,dJ,dK,dL,dM,dN,ab,dO,dP) = $Tuple2(nil, dI(dn, dJ, dK, dL, dM, dN, ab, dO, dP))
1664 1673  
1665 1674  
1666 1675  
1667 - @Callable(eS)
1668 - func estimateGetOperationWrapperREADONLY (di,dj,dk,ab) = {
1669 -     let dW = dh(di, dj, dk, addressFromStringValue(ab))
1670 -     $Tuple2(nil, $Tuple10(dW._1, dW._2, dW._3, dW._4, dW._5, dW._6, dW._7, toString(dW._8), dW._9, dW._10))
1676 + @Callable(eV)
1677 + func estimateGetOperationWrapperREADONLY (dn,do,dp,ab) = {
1678 +     let dZ = dm(dn, do, dp, addressFromStringValue(ab))
1679 +     $Tuple2(nil, $Tuple10(dZ._1, dZ._2, dZ._3, dZ._4, dZ._5, dZ._6, dZ._7, toString(dZ._8), dZ._9, dZ._10))
1671 1680      }
1672 1681  
1673 1682  
1674 1683  
1675 - @Callable(eS)
1684 + @Callable(eV)
1676 1685  func statsREADONLY () = {
1677 -     let cY = ba()
1678 -     let dl = fromBase58String(cY[q])
1679 -     let hR = cY[r]
1680 -     let hS = cY[s]
1681 -     let dP = cY[v]
1682 -     let dQ = cY[w]
1683 -     let cZ = parseIntValue(cY[t])
1684 -     let da = parseIntValue(cY[u])
1685 -     let hT = valueOrErrorMessage(assetInfo(dl), (("Asset " + toBase58String(dl)) + " doesn't exist")).quantity
1686 -     let hU = bJ(hR)
1687 -     let hV = bJ(hS)
1688 -     let hW = if ((hT == 0))
1686 +     let dd = ba()
1687 +     let dq = fromBase58String(dd[q])
1688 +     let hT = dd[r]
1689 +     let hU = dd[s]
1690 +     let dS = dd[v]
1691 +     let dT = dd[w]
1692 +     let de = parseIntValue(dd[t])
1693 +     let df = parseIntValue(dd[u])
1694 +     let hV = valueOrErrorMessage(assetInfo(dq), (("Asset " + toBase58String(dq)) + " doesn't exist")).quantity
1695 +     let hW = bJ(hT)
1696 +     let hX = bJ(hU)
1697 +     let hY = if ((hV == 0))
1689 1698          then [e, e, e]
1690 -         else cW(hU, hV, hT)
1691 -     let dv = 0
1692 -     let hX = H(hW[1], b)
1693 -     let hY = H(hW[2], b)
1694 -     let hZ = value(getInteger(aT, aD(toString(this))))
1695 -     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(hU), toString(hV), toString(hT), toString(dv), toString(hX), toString(hY), toString(hZ)], j))
1699 +         else db(hW, hX, hV)
1700 +     let dA = 0
1701 +     let hZ = H(hY[1], b)
1702 +     let ia = H(hY[2], b)
1703 +     let ib = value(getInteger(aT, aD(toString(this))))
1704 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(hW), toString(hX), toString(hV), toString(dA), toString(hZ), toString(ia), toString(ib)], j))
1696 1705      }
1697 1706  
1698 1707  
1699 1708  
1700 - @Callable(eS)
1701 - func evaluatePutByAmountAssetREADONLY (dH) = {
1702 -     let cY = ba()
1703 -     let dl = fromBase58String(cY[q])
1704 -     let dN = cY[r]
1705 -     let dm = fromBase58String(dN)
1706 -     let dO = cY[s]
1707 -     let dn = fromBase58String(dO)
1708 -     let cZ = parseIntValue(cY[t])
1709 -     let da = parseIntValue(cY[u])
1710 -     let do = cY[p]
1711 -     let hT = valueOrErrorMessage(assetInfo(dl), (("Asset " + toBase58String(dl)) + " doesn't exist")).quantity
1712 -     let hU = bJ(dN)
1713 -     let hV = bJ(dO)
1714 -     let cU = D(hU, cZ)
1715 -     let cV = D(hV, da)
1716 -     let du = if ((hT == 0))
1709 + @Callable(eV)
1710 + func evaluatePutByAmountAssetREADONLY (dK) = {
1711 +     let dd = ba()
1712 +     let dq = fromBase58String(dd[q])
1713 +     let dQ = dd[r]
1714 +     let dr = fromBase58String(dQ)
1715 +     let dR = dd[s]
1716 +     let ds = fromBase58String(dR)
1717 +     let de = parseIntValue(dd[t])
1718 +     let df = parseIntValue(dd[u])
1719 +     let dt = dd[p]
1720 +     let hV = valueOrErrorMessage(assetInfo(dq), (("Asset " + toBase58String(dq)) + " doesn't exist")).quantity
1721 +     let hW = bJ(dQ)
1722 +     let hX = bJ(dR)
1723 +     let cZ = D(hW, de)
1724 +     let da = D(hX, df)
1725 +     let dz = if ((hV == 0))
1717 1726          then e
1718 -         else bM(cV, cU)
1719 -     let dT = D(dH, cZ)
1720 -     let dU = fraction(dT, du, d)
1721 -     let dJ = H(dU, da)
1722 -     let eY = dF("", 500000, dH, dm, dJ, dn, "", true, false)
1723 -     let ee = eY._1
1724 -     let ia = eY._3
1725 -     let dq = eY._4
1726 -     let ds = eY._5
1727 -     let dp = eY._6
1728 -     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(ee), toString(H(du, b)), toString(dq), toString(ds), toString(dp), do, toString(dH), toString(dJ)], j))
1727 +         else bM(da, cZ)
1728 +     let dW = D(dK, de)
1729 +     let dX = fraction(dW, dz, d)
1730 +     let dM = H(dX, df)
1731 +     let fb = dI("", 500000, dK, dr, dM, ds, "", true, false)
1732 +     let eh = fb._1
1733 +     let ic = fb._3
1734 +     let dv = fb._4
1735 +     let dx = fb._5
1736 +     let du = fb._6
1737 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(eh), toString(H(dz, b)), toString(dv), toString(dx), toString(du), dt, toString(dK), toString(dM)], j))
1729 1738      }
1730 1739  
1731 1740  
1732 1741  
1733 - @Callable(eS)
1734 - func evaluatePutByPriceAssetREADONLY (dJ) = {
1735 -     let cY = ba()
1736 -     let dl = fromBase58String(cY[q])
1737 -     let dN = cY[r]
1738 -     let dm = fromBase58String(dN)
1739 -     let dO = cY[s]
1740 -     let dn = fromBase58String(dO)
1741 -     let cZ = parseIntValue(cY[t])
1742 -     let da = parseIntValue(cY[u])
1743 -     let do = cY[p]
1744 -     let hT = valueOrErrorMessage(assetInfo(dl), (("Asset " + toBase58String(dl)) + " doesn't exist")).quantity
1745 -     let ib = bJ(dN)
1746 -     let ic = bJ(dO)
1747 -     let id = D(ib, cZ)
1748 -     let ie = D(ic, da)
1749 -     let du = if ((hT == 0))
1742 + @Callable(eV)
1743 + func evaluatePutByPriceAssetREADONLY (dM) = {
1744 +     let dd = ba()
1745 +     let dq = fromBase58String(dd[q])
1746 +     let dQ = dd[r]
1747 +     let dr = fromBase58String(dQ)
1748 +     let dR = dd[s]
1749 +     let ds = fromBase58String(dR)
1750 +     let de = parseIntValue(dd[t])
1751 +     let df = parseIntValue(dd[u])
1752 +     let dt = dd[p]
1753 +     let hV = valueOrErrorMessage(assetInfo(dq), (("Asset " + toBase58String(dq)) + " doesn't exist")).quantity
1754 +     let id = bJ(dQ)
1755 +     let ie = bJ(dR)
1756 +     let if = D(id, de)
1757 +     let ig = D(ie, df)
1758 +     let dz = if ((hV == 0))
1750 1759          then e
1751 -         else bM(ie, id)
1752 -     let dU = D(dJ, da)
1753 -     let dT = fraction(dU, d, du)
1754 -     let dH = H(dT, cZ)
1755 -     let eY = dF("", 500000, dH, dm, dJ, dn, "", true, false)
1756 -     let ee = eY._1
1757 -     let ia = eY._3
1758 -     let dq = eY._4
1759 -     let ds = eY._5
1760 -     let dp = eY._6
1761 -     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(ee), toString(H(du, b)), toString(dq), toString(ds), toString(dp), do, toString(dH), toString(dJ)], j))
1760 +         else bM(ig, if)
1761 +     let dX = D(dM, df)
1762 +     let dW = fraction(dX, d, dz)
1763 +     let dK = H(dW, de)
1764 +     let fb = dI("", 500000, dK, dr, dM, ds, "", true, false)
1765 +     let eh = fb._1
1766 +     let ic = fb._3
1767 +     let dv = fb._4
1768 +     let dx = fb._5
1769 +     let du = fb._6
1770 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(eh), toString(H(dz, b)), toString(dv), toString(dx), toString(du), dt, toString(dK), toString(dM)], j))
1762 1771      }
1763 1772  
1764 1773  
1765 1774  
1766 - @Callable(eS)
1767 - func evaluateGetREADONLY (if,ig) = {
1768 -     let dW = dh("", if, ig, this)
1769 -     let dA = dW._1
1770 -     let dB = dW._2
1771 -     let dq = dW._5
1772 -     let ds = dW._6
1773 -     let dp = dW._7
1774 -     let dv = dW._8
1775 -     let do = parseIntValue(dW._9)
1776 -     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(dA), toString(dB), toString(dq), toString(ds), toString(dp), toString(dv), toString(do)], j))
1775 + @Callable(eV)
1776 + func evaluateGetREADONLY (ih,ii) = {
1777 +     let dZ = dm("", ih, ii, this)
1778 +     let dF = dZ._1
1779 +     let dG = dZ._2
1780 +     let dv = dZ._5
1781 +     let dx = dZ._6
1782 +     let du = dZ._7
1783 +     let dA = dZ._8
1784 +     let dt = parseIntValue(dZ._9)
1785 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(dF), toString(dG), toString(dv), toString(dx), toString(du), toString(dA), toString(dt)], j))
1777 1786      }
1778 1787  
1779 1788  
1780 - @Verifier(ih)
1781 - func ii () = {
1782 -     let ij = {
1783 -         let bT = ge()
1789 + @Verifier(ij)
1790 + func ik () = {
1791 +     let il = {
1792 +         let bT = gh()
1784 1793          if ($isInstanceOf(bT, "ByteVector"))
1785 1794              then {
1786 -                 let gi = bT
1787 -                 gi
1795 +                 let gl = bT
1796 +                 gl
1788 1797                  }
1789 1798              else if ($isInstanceOf(bT, "Unit"))
1790 -                 then ih.senderPublicKey
1799 +                 then ij.senderPublicKey
1791 1800                  else throw("Match error")
1792 1801          }
1793 -     let bT = ih
1802 +     let bT = ij
1794 1803      if ($isInstanceOf(bT, "Order"))
1795 1804          then {
1796 -             let eH = bT
1797 -             let ik = aZ()
1798 -             let il = eG(eH)
1799 -             let aI = il._1
1800 -             let aJ = il._2
1801 -             let aK = sigVerify(eH.bodyBytes, eH.proofs[0], eH.senderPublicKey)
1802 -             let aL = sigVerify(eH.bodyBytes, eH.proofs[1], ik)
1805 +             let eK = bT
1806 +             let im = aZ()
1807 +             let in = eJ(eK)
1808 +             let aI = in._1
1809 +             let aJ = in._2
1810 +             let aK = sigVerify(eK.bodyBytes, eK.proofs[0], eK.senderPublicKey)
1811 +             let aL = sigVerify(eK.bodyBytes, eK.proofs[1], im)
1803 1812              if (if (if (aI)
1804 1813                  then aK
1805 1814                  else false)
1810 1819              }
1811 1820          else if ($isInstanceOf(bT, "SetScriptTransaction"))
1812 1821              then {
1813 -                 let gf = bT
1814 -                 if (sigVerify(ih.bodyBytes, ih.proofs[0], ij))
1822 +                 let gi = bT
1823 +                 if (sigVerify(ij.bodyBytes, ij.proofs[0], il))
1815 1824                      then true
1816 1825                      else {
1817 -                         let im = blake2b256(value(gf.script))
1818 -                         let in = fromBase64String(value(getString(aT, aF())))
1819 -                         let io = scriptHash(this)
1820 -                         if ((in == im))
1821 -                             then (io != im)
1826 +                         let io = blake2b256(value(gi.script))
1827 +                         let ip = fromBase64String(value(getString(aT, aF())))
1828 +                         let iq = scriptHash(this)
1829 +                         if ((ip == io))
1830 +                             then (iq != io)
1822 1831                              else false
1823 1832                          }
1824 1833                  }
1825 -             else sigVerify(ih.bodyBytes, ih.proofs[0], ij)
1834 +             else sigVerify(ij.bodyBytes, ij.proofs[0], il)
1826 1835      }
1827 1836  
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let a = 8
5 5  
6 6  let b = 100000000
7 7  
8 8  let c = toBigInt(100000000)
9 9  
10 10  let d = toBigInt(1000000000000000000)
11 11  
12 12  let e = toBigInt(0)
13 13  
14 14  let f = toBigInt(0)
15 15  
16 16  let g = toBigInt(1)
17 17  
18 18  let h = toBigInt(2)
19 19  
20 20  let i = "WAVES"
21 21  
22 22  let j = "__"
23 23  
24 24  let k = 1
25 25  
26 26  let l = 2
27 27  
28 28  let m = 3
29 29  
30 30  let n = 4
31 31  
32 32  let o = 1
33 33  
34 34  let p = 2
35 35  
36 36  let q = 3
37 37  
38 38  let r = 4
39 39  
40 40  let s = 5
41 41  
42 42  let t = 6
43 43  
44 44  let u = 7
45 45  
46 46  let v = 8
47 47  
48 48  let w = 9
49 49  
50 50  let x = 10
51 51  
52 52  let y = 1
53 53  
54 54  let z = 2
55 55  
56 56  let A = 3
57 57  
58 58  let B = 1
59 59  
60 60  let C = 7
61 61  
62 62  func D (E,F) = fraction(toBigInt(E), d, toBigInt(F))
63 63  
64 64  
65 65  func G (E,F) = fraction(E, d, F)
66 66  
67 67  
68 68  func H (I,J) = toInt(fraction(I, toBigInt(J), d))
69 69  
70 70  
71 71  func K (I,J,L) = toInt(fraction(I, toBigInt(J), d, L))
72 72  
73 73  
74 74  func M (N,O,P) = fraction(N, O, P)
75 75  
76 76  
77 77  func Q (I) = if ((0 > I))
78 78      then -(I)
79 79      else I
80 80  
81 81  
82 82  func R (I) = if ((e > I))
83 83      then -(I)
84 84      else I
85 85  
86 86  
87 87  func S () = "%s__swapContract"
88 88  
89 89  
90 90  func T () = "%s__factoryContract"
91 91  
92 92  
93 93  func U () = "%s__managerPublicKey"
94 94  
95 95  
96 96  func V () = "%s__pendingManagerPublicKey"
97 97  
98 98  
99 99  func W () = "%s%s__price__last"
100 100  
101 101  
102 102  func X (Y,Z) = makeString(["%s%s%d%d__price__history", toString(Y), toString(Z)], j)
103 103  
104 104  
105 105  func aa (ab,ac) = ((("%s%s%s__P__" + ab) + "__") + ac)
106 106  
107 107  
108 108  func ad (ab,ac) = ((("%s%s%s__G__" + ab) + "__") + ac)
109 109  
110 110  
111 111  func ae () = "%s__amountAsset"
112 112  
113 113  
114 114  func af () = "%s__priceAsset"
115 115  
116 116  
117 117  let ag = "%s__fee"
118 118  
119 119  let ah = fraction(10, b, 10000)
120 120  
121 121  let ai = valueOrElse(getInteger(this, ag), ah)
122 122  
123 123  let aj = makeString(["%s", "kLp"], j)
124 124  
125 125  let ak = makeString(["%s", "kLpRefreshedHeight"], j)
126 126  
127 127  let al = makeString(["%s", "refreshKLpDelay"], j)
128 128  
129 129  let am = 30
130 130  
131 131  let an = valueOrElse(getInteger(this, al), am)
132 132  
133 133  func ao (ap) = makeString(["%s%s", "stakedBalance", ap], j)
134 134  
135 135  
136 136  func aq (ap) = makeString(["%s%s", "shareAssetBalance", ap], j)
137 137  
138 138  
139 139  func ar (ap) = valueOrElse(getInteger(this, ao(ap)), 0)
140 140  
141 141  
142 142  func as (ap) = valueOrElse(getInteger(this, aq(ap)), 0)
143 143  
144 144  
145 145  func at () = "%s__factoryConfig"
146 146  
147 147  
148 148  func au () = "%s%s__matcher__publicKey"
149 149  
150 150  
151 151  func av (aw) = (("%s%s%s__" + aw) + "__mappings__poolContract2LpAsset")
152 152  
153 153  
154 154  func ax (ay,az) = (((("%d%d%s__" + ay) + "__") + az) + "__config")
155 155  
156 156  
157 157  func aA (aB) = ("%s%s%s__mappings__baseAsset2internalId__" + aB)
158 158  
159 159  
160 160  func aC () = "%s__shutdown"
161 161  
162 162  
163 163  func aD (aE) = ("%s%s__poolWeight__" + aE)
164 164  
165 165  
166 166  func aF () = "%s__allowedLpScriptHash"
167 167  
168 168  
169 169  let aG = "%s__feeCollectorAddress"
170 170  
171 171  func aH (aI,aJ,aK,aL) = throw((((((((("order validation failed: orderValid=" + toString(aI)) + " (") + aJ) + ")") + " senderValid=") + toString(aK)) + " matcherValid=") + toString(aL)))
172 172  
173 173  
174 174  func aM (aN,aO) = valueOrErrorMessage(getString(aN, aO), makeString(["mandatory ", toString(aN), ".", aO, " is not defined"], ""))
175 175  
176 176  
177 177  func aP (aN,aO) = valueOrErrorMessage(getInteger(aN, aO), makeString(["mandatory ", toString(aN), ".", aO, " is not defined"], ""))
178 178  
179 179  
180 180  func aQ (aR) = throw(makeString(["lp.ride:", aR], " "))
181 181  
182 182  
183 183  func aS (aR) = makeString(["lp.ride:", aR], " ")
184 184  
185 185  
186 186  let aT = addressFromStringValue(aM(this, T()))
187 187  
188 188  let aU = addressFromStringValue(aM(aT, aG))
189 189  
190 190  let aV = {
191 191      let aW = invoke(aT, "getInFeeREADONLY", [toString(this)], nil)
192 192      if ($isInstanceOf(aW, "Int"))
193 193          then aW
194 194          else throw(($getType(aW) + " couldn't be cast to Int"))
195 195      }
196 196  
197 197  let aX = {
198 198      let aW = invoke(aT, "getOutFeeREADONLY", [toString(this)], nil)
199 199      if ($isInstanceOf(aW, "Int"))
200 200          then aW
201 201          else throw(($getType(aW) + " couldn't be cast to Int"))
202 202      }
203 203  
204 204  func aY () = valueOrElse(getBoolean(aT, aC()), false)
205 205  
206 206  
207 207  func aZ () = fromBase58String(aM(aT, au()))
208 208  
209 209  
210 210  func ba () = {
211 211      let bb = aM(this, ae())
212 212      let bc = aM(this, af())
213 213      let az = aP(aT, aA(bc))
214 214      let ay = aP(aT, aA(bb))
215 215      split(aM(aT, ax(toString(ay), toString(az))), j)
216 216      }
217 217  
218 218  
219 219  func bd (be) = if ((be == i))
220 220      then unit
221 221      else fromBase58String(be)
222 222  
223 223  
224 224  func bf (be) = if ((be == unit))
225 225      then i
226 226      else toBase58String(value(be))
227 227  
228 228  
229 229  func bg (bh) = $Tuple7(addressFromStringValue(bh[o]), parseIntValue(bh[p]), fromBase58String(bh[q]), bd(bh[r]), bd(bh[s]), parseIntValue(bh[t]), parseIntValue(bh[u]))
230 230  
231 231  
232 232  let bi = bg(ba())
233 233  
234 234  let bj = bi
235 235  
236 236  let bk = bj._1
237 237  
238 238  let bl = bj._2
239 239  
240 240  let bm = bj._3
241 241  
242 242  let bn = bj._4
243 243  
244 244  let bo = bj._5
245 245  
246 246  let bp = bj._6
247 247  
248 248  let bq = bj._7
249 249  
250 250  func br () = split(aM(aT, at()), j)
251 251  
252 252  
253 253  let bs = valueOrErrorMessage(addressFromString(br()[B]), "incorrect staking address")
254 254  
255 255  let bt = valueOrErrorMessage(addressFromString(br()[C]), "incorrect staking address")
256 256  
257 257  func bu (bv,bw,bx,by,bz,bA,bB,bC,bD,bE) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bv), toString(bw), toString(bx), toString(by), toString(bz), toString(bA), toString(bB), toString(bC), toString(bD), toString(bE)], j)
258 258  
259 259  
260 260  func bF (bG,bH,bI,by,bB,bC) = makeString(["%d%d%d%d%d%d", toString(bG), toString(bH), toString(bI), toString(by), toString(bB), toString(bC)], j)
261 261  
262 262  
263 263  func bJ (ap) = {
264 264      let bK = if ((ap == "WAVES"))
265 265          then wavesBalance(this).available
266 266          else assetBalance(this, fromBase58String(ap))
267 267      let bL = ((bK + ar(ap)) - as(ap))
268 268      max([0, bL])
269 269      }
270 270  
271 271  
272 272  func bM (bN,bO) = fraction(bN, d, bO)
273 273  
274 274  
275 275  func bP (bN,bO,L) = fraction(bN, d, bO, L)
276 276  
277 277  
278 278  func bQ (bR) = {
279 279      let bS = invoke(bR, "getRate", nil, nil)
280 280      if ((bS == bS))
281 281          then {
282 282              let bT = bS
283 283              if ($isInstanceOf(bT, "Int"))
284 284                  then {
285 285                      let bU = bT
286 286                      bU
287 287                      }
288 288                  else aQ("proxy.getRate() unexpected value")
289 289              }
290 290          else throw("Strict value is not equal to itself.")
291 291      }
292 292  
293 293  
294 294  func bV (ap,bW,bX,bR) = {
295 295      let bY = ar(ap)
296 296      if ((bY == bY))
297 297          then {
298 298              let bZ = as(bX)
299 299              if ((bZ == bZ))
300 300                  then {
301 301                      let ca = bd(ap)
302 302                      if ((bW > 0))
303 303                          then {
304 304                              let cb = invoke(bR, "deposit", nil, [AttachedPayment(ca, bW)])
305 305                              if ((cb == cb))
306 306                                  then {
307 307                                      let bT = cb
308 308                                      if ($isInstanceOf(bT, "Int"))
309 309                                          then {
310 310                                              let cc = bT
311 311                                              let cd = (bY + bW)
312 312                                              let ce = (bZ + cc)
313 313  [IntegerEntry(ao(ap), cd), IntegerEntry(aq(bX), ce)]
314 314                                              }
315 315                                          else nil
316 316                                      }
317 317                                  else throw("Strict value is not equal to itself.")
318 318                              }
319 319                          else nil
320 320                      }
321 321                  else throw("Strict value is not equal to itself.")
322 322              }
323 323          else throw("Strict value is not equal to itself.")
324 324      }
325 325  
326 326  
327 327  func cf (ap,bW,bX,bR,cg,ch) = {
328 328      let bY = ar(ap)
329 329      if ((bY == bY))
330 330          then {
331 331              let bZ = as(bX)
332 332              if ((bZ == bZ))
333 333                  then {
334 334                      let ci = bQ(bR)
335 335                      if ((ci == ci))
336 336                          then {
337 337                              let cj = fraction(cg, bY, bZ)
338 338                              let ck = bd(bX)
339 339                              let cl = fraction(cg, bW, cj)
340 340                              let cm = fraction(cg, bW, ci)
341 341                              let cn = max([0, (cl - cm)])
342 342                              if ((cm > 0))
343 343                                  then {
344 344                                      let co = invoke(bR, "withdraw", nil, [AttachedPayment(ck, cm)])
345 345                                      if ((co == co))
346 346                                          then {
347 347                                              let bT = co
348 348                                              if ($isInstanceOf(bT, "Int"))
349 349                                                  then {
350 350                                                      let cp = bT
351 351                                                      let cd = (bY - cp)
352 352                                                      let ce = ((bZ - cm) - cn)
353 353  [IntegerEntry(ao(ap), cd), IntegerEntry(aq(bX), ce), ScriptTransfer(ch, cn, bd(bX))]
354 354                                                      }
355 355                                                  else nil
356 356                                              }
357 357                                          else throw("Strict value is not equal to itself.")
358 358                                      }
359 359                                  else nil
360 360                              }
361 361                          else throw("Strict value is not equal to itself.")
362 362                      }
363 363                  else throw("Strict value is not equal to itself.")
364 364              }
365 365          else throw("Strict value is not equal to itself.")
366 366      }
367 367  
368 368  
369 369  func cq (ap) = {
370 370      let bT = invoke(aT, "getPoolLeaseConfigREADONLY", [toString(this), ap], nil)
371 371      if ($isInstanceOf(bT, "(Boolean, Int, Int, String, String, Int, String)"))
372 372          then {
373 373              let cr = bT
374 374              cr
375 375              }
376 376          else aQ((("[" + ap) + "] getLeaseProxyConfig() error"))
377 377      }
378 378  
379 379  
380 380  func cs (ct,ap,bX,cu,bR,cg,ch) = {
381 381      let bY = ar(ap)
382 382      if ((bY == bY))
383 383          then {
384 384              let bZ = as(bX)
385 385              if ((bZ == bZ))
386 386                  then {
387 387                      let cv = {
388 388                          let bT = bd(ap)
389 389                          if ($isInstanceOf(bT, "ByteVector"))
390 390                              then {
391 391                                  let cw = bT
392 392                                  assetBalance(this, cw)
393 393                                  }
394 394                              else if ($isInstanceOf(bT, "Unit"))
395 395                                  then {
396 396                                      let cx = bT
397 397                                      wavesBalance(this).available
398 398                                      }
399 399                                  else throw("Match error")
400 400                          }
401 401                      if ((cv == cv))
402 402                          then {
403 403                              let cy = max([0, ((cv + bY) - cu)])
404 404                              let cz = fraction(ct, cy, 100)
405 405                              let cA = (bY - cz)
406 406                              if ((cA == 0))
407 407                                  then nil
408 408                                  else if ((0 > cA))
409 409                                      then {
410 410                                          let cB = -(cA)
411 411                                          bV(ap, cB, bX, bR)
412 412                                          }
413 413                                      else {
414 414                                          let cC = cA
415 415                                          cf(ap, cC, bX, bR, cg, ch)
416 416                                          }
417 417                              }
418 418                          else throw("Strict value is not equal to itself.")
419 419                      }
420 420                  else throw("Strict value is not equal to itself.")
421 421              }
422 422          else throw("Strict value is not equal to itself.")
423 423      }
424 424  
425 425  
426 426  func cD (ap) = {
427 427      let cE = cq(ap)
428 428      let cF = cE._1
429 429      let cG = cE._2
430 430      let cu = cE._3
431 431      let cH = cE._4
432 432      let cI = cE._5
433 433      let cg = cE._6
434 434      let cJ = cE._7
435 435      if (cF)
436 436          then cs(cG, ap, cI, cu, addressFromStringValue(cH), cg, addressFromStringValue(cJ))
437 437          else nil
438 438      }
439 439  
440 440  
441 441  func cK (ap,cL) = {
442 442      let cM = cq(ap)
443 443      let cF = cM._1
444 444      let cG = cM._2
445 445      let cu = cM._3
446 446      let cH = cM._4
447 447      let cI = cM._5
448 448      let cg = cM._6
449 449      let cJ = cM._7
450 450      if (cF)
451 451          then {
452 452              let cN = max([0, ((bJ(ap) - cL) - cu)])
453 453              if ((cN == cN))
454 454                  then {
455 455                      let cd = fraction(cG, cN, 100)
456 456                      if ((cd == cd))
457 457                          then {
458 458                              let cO = max([0, (ar(ap) - cd)])
459 459                              if ((cO == cO))
460 460                                  then cf(ap, cO, cI, addressFromStringValue(cH), cg, addressFromStringValue(cJ))
461 461                                  else throw("Strict value is not equal to itself.")
462 462                              }
463 463                          else throw("Strict value is not equal to itself.")
464 464                      }
465 465                  else throw("Strict value is not equal to itself.")
466 466              }
467 467          else nil
468 468      }
469 469  
470 470  
471 - func cP (cQ,cR,cS,cT) = {
472 -     let cU = D(cS, cQ)
473 -     let cV = D(cT, cR)
474 -     bM(cV, cU)
471 + func cP (cQ,cR) = {
472 +     let cS = cK(aM(this, ae()), cQ)
473 +     let cT = cK(aM(this, af()), cR)
474 +     (cS ++ cT)
475 475      }
476 476  
477 477  
478 - func cW (cS,cT,cX) = {
479 -     let cY = ba()
480 -     let cZ = parseIntValue(cY[t])
481 -     let da = parseIntValue(cY[u])
482 -     let db = cP(cZ, da, cS, cT)
483 -     let bO = D(cS, cZ)
484 -     let bN = D(cT, da)
485 -     let dc = D(cX, b)
486 -     let dd = bM(bO, dc)
487 -     let de = bM(bN, dc)
488 - [db, dd, de]
478 + func cU (cV,cW,cX,cY) = {
479 +     let cZ = D(cX, cV)
480 +     let da = D(cY, cW)
481 +     bM(da, cZ)
489 482      }
490 483  
491 484  
492 - func df (cS,cT,cX) = {
493 -     let dg = cW(cS, cT, cX)
494 - [H(dg[0], b), H(dg[1], b), H(dg[2], b)]
485 + func db (cX,cY,dc) = {
486 +     let dd = ba()
487 +     let de = parseIntValue(dd[t])
488 +     let df = parseIntValue(dd[u])
489 +     let dg = cU(de, df, cX, cY)
490 +     let bO = D(cX, de)
491 +     let bN = D(cY, df)
492 +     let dh = D(dc, b)
493 +     let di = bM(bO, dh)
494 +     let dj = bM(bN, dh)
495 + [dg, di, dj]
495 496      }
496 497  
497 498  
498 - func dh (di,dj,dk,ab) = {
499 -     let cY = ba()
500 -     let dl = cY[q]
501 -     let dm = cY[r]
502 -     let dn = cY[s]
503 -     let cQ = parseIntValue(cY[t])
504 -     let cR = parseIntValue(cY[u])
505 -     let do = cY[p]
506 -     let dp = valueOrErrorMessage(assetInfo(fromBase58String(dl)), (("Asset " + dl) + " doesn't exist")).quantity
507 -     if ((dl != dj))
499 + func dk (cX,cY,dc) = {
500 +     let dl = db(cX, cY, dc)
501 + [H(dl[0], b), H(dl[1], b), H(dl[2], b)]
502 +     }
503 + 
504 + 
505 + func dm (dn,do,dp,ab) = {
506 +     let dd = ba()
507 +     let dq = dd[q]
508 +     let dr = dd[r]
509 +     let ds = dd[s]
510 +     let cV = parseIntValue(dd[t])
511 +     let cW = parseIntValue(dd[u])
512 +     let dt = dd[p]
513 +     let du = valueOrErrorMessage(assetInfo(fromBase58String(dq)), (("Asset " + dq) + " doesn't exist")).quantity
514 +     if ((dq != do))
508 515          then throw("Invalid asset passed.")
509 516          else {
510 -             let dq = bJ(dm)
511 -             let dr = D(dq, cQ)
512 -             let ds = bJ(dn)
513 -             let dt = D(ds, cR)
514 -             let du = bM(dt, dr)
515 -             let dv = H(du, b)
516 -             let dw = D(dk, b)
517 -             let dx = D(dp, b)
518 -             let dy = fraction(dr, dw, dx)
519 -             let dz = fraction(dt, dw, dx)
520 -             let dA = K(dy, cQ, FLOOR)
521 -             let dB = K(dz, cR, FLOOR)
522 -             let dC = cK(dm, dA)
523 -             let dD = cK(dn, dB)
524 -             let dE = if ((di == ""))
517 +             let dv = bJ(dr)
518 +             let dw = D(dv, cV)
519 +             let dx = bJ(ds)
520 +             let dy = D(dx, cW)
521 +             let dz = bM(dy, dw)
522 +             let dA = H(dz, b)
523 +             let dB = D(dp, b)
524 +             let dC = D(du, b)
525 +             let dD = fraction(dw, dB, dC)
526 +             let dE = fraction(dy, dB, dC)
527 +             let dF = K(dD, cV, FLOOR)
528 +             let dG = K(dE, cW, FLOOR)
529 +             let dH = if ((dn == ""))
525 530                  then nil
526 -                 else ((dC ++ dD) ++ [ScriptTransfer(ab, dA, if ((dm == "WAVES"))
531 +                 else [ScriptTransfer(ab, dF, if ((dr == "WAVES"))
527 532                      then unit
528 -                     else fromBase58String(dm)), ScriptTransfer(ab, dB, if ((dn == "WAVES"))
533 +                     else fromBase58String(dr)), ScriptTransfer(ab, dG, if ((ds == "WAVES"))
529 534                      then unit
530 -                     else fromBase58String(dn)), StringEntry(ad(toString(ab), di), bF(dA, dB, dk, dv, height, lastBlock.timestamp)), IntegerEntry(W(), dv), IntegerEntry(X(height, lastBlock.timestamp), dv)])
531 -             $Tuple10(dA, dB, dm, dn, dq, ds, dp, du, do, dE)
535 +                     else fromBase58String(ds)), StringEntry(ad(toString(ab), dn), bF(dF, dG, dp, dA, height, lastBlock.timestamp)), IntegerEntry(W(), dA), IntegerEntry(X(height, lastBlock.timestamp), dA)]
536 +             $Tuple10(dF, dG, dr, ds, dv, dx, du, dz, dt, dH)
532 537              }
533 538      }
534 539  
535 540  
536 - func dF (di,dG,dH,dI,dJ,dK,ab,dL,dM) = {
537 -     let cY = ba()
538 -     let dl = fromBase58String(cY[q])
539 -     let dN = cY[r]
540 -     let dO = cY[s]
541 -     let dP = cY[v]
542 -     let dQ = cY[w]
543 -     let cZ = parseIntValue(cY[t])
544 -     let da = parseIntValue(cY[u])
545 -     let do = cY[p]
546 -     let dp = valueOrErrorMessage(assetInfo(dl), (("Asset " + toBase58String(dl)) + " doesn't exist")).quantity
547 -     let dR = toBase58String(valueOrElse(dI, fromBase58String("WAVES")))
548 -     let dS = toBase58String(valueOrElse(dK, fromBase58String("WAVES")))
549 -     if (if ((dN != dR))
541 + func dI (dn,dJ,dK,dL,dM,dN,ab,dO,dP) = {
542 +     let dd = ba()
543 +     let dq = fromBase58String(dd[q])
544 +     let dQ = dd[r]
545 +     let dR = dd[s]
546 +     let dS = dd[v]
547 +     let dT = dd[w]
548 +     let de = parseIntValue(dd[t])
549 +     let df = parseIntValue(dd[u])
550 +     let dt = dd[p]
551 +     let du = valueOrErrorMessage(assetInfo(dq), (("Asset " + toBase58String(dq)) + " doesn't exist")).quantity
552 +     let dU = toBase58String(valueOrElse(dL, fromBase58String("WAVES")))
553 +     let dV = toBase58String(valueOrElse(dN, fromBase58String("WAVES")))
554 +     if (if ((dQ != dU))
550 555          then true
551 -         else (dO != dS))
556 +         else (dR != dV))
552 557          then throw("Invalid amt or price asset passed.")
553 558          else {
554 -             let dq = if (dL)
555 -                 then bJ(dN)
556 -                 else (bJ(dN) - dH)
557 -             let ds = if (dL)
558 -                 then bJ(dO)
559 -                 else (bJ(dO) - dJ)
560 -             let dT = D(dH, cZ)
561 -             let dU = D(dJ, da)
562 -             let dV = bM(dU, dT)
563 -             let dr = D(dq, cZ)
564 -             let dt = D(ds, da)
565 -             let dW = if ((dp == 0))
559 +             let dv = if (dO)
560 +                 then bJ(dQ)
561 +                 else (bJ(dQ) - dK)
562 +             let dx = if (dO)
563 +                 then bJ(dR)
564 +                 else (bJ(dR) - dM)
565 +             let dW = D(dK, de)
566 +             let dX = D(dM, df)
567 +             let dY = bM(dX, dW)
568 +             let dw = D(dv, de)
569 +             let dy = D(dx, df)
570 +             let dZ = if ((du == 0))
566 571                  then {
567 -                     let du = e
568 -                     let dX = e
569 -                     let dc = pow((dT * dU), 0, toBigInt(5), 1, 0, DOWN)
570 -                     $Tuple5(H(dc, b), H(dT, cZ), H(dU, da), bM((dt + dU), (dr + dT)), dX)
572 +                     let dz = e
573 +                     let ea = e
574 +                     let dh = pow((dW * dX), 0, toBigInt(5), 1, 0, DOWN)
575 +                     $Tuple5(H(dh, b), H(dW, de), H(dX, df), bM((dy + dX), (dw + dW)), ea)
571 576                      }
572 577                  else {
573 -                     let du = bM(dt, dr)
574 -                     let dX = fraction(R((du - dV)), d, du)
575 -                     let dY = D(dG, b)
576 -                     if (if ((du != e))
577 -                         then (dX > dY)
578 +                     let dz = bM(dy, dw)
579 +                     let ea = fraction(R((dz - dY)), d, dz)
580 +                     let eb = D(dJ, b)
581 +                     if (if ((dz != e))
582 +                         then (ea > eb)
578 583                          else false)
579 -                         then throw(((("Price slippage " + toString(dX)) + " exceeded the passed limit of ") + toString(dY)))
584 +                         then throw(((("Price slippage " + toString(ea)) + " exceeded the passed limit of ") + toString(eb)))
580 585                          else {
581 -                             let dx = D(dp, b)
582 -                             let dZ = fraction(dT, bP(dt, dr, CEILING), d, CEILING)
583 -                             let ea = fraction(dU, d, bP(dt, dr, FLOOR), CEILING)
584 -                             let eb = if ((dZ > dU))
585 -                                 then $Tuple2(ea, dU)
586 -                                 else $Tuple2(dT, dZ)
587 -                             let ec = eb._1
588 -                             let ed = eb._2
589 -                             let dc = fraction(dx, ed, dt, FLOOR)
590 -                             $Tuple5(K(dc, b, FLOOR), K(ec, cZ, CEILING), K(ed, da, CEILING), du, dX)
586 +                             let dC = D(du, b)
587 +                             let ec = fraction(dW, bP(dy, dw, CEILING), d, CEILING)
588 +                             let ed = fraction(dX, d, bP(dy, dw, FLOOR), CEILING)
589 +                             let ee = if ((ec > dX))
590 +                                 then $Tuple2(ed, dX)
591 +                                 else $Tuple2(dW, ec)
592 +                             let ef = ee._1
593 +                             let eg = ee._2
594 +                             let dh = fraction(dC, eg, dy, FLOOR)
595 +                             $Tuple5(K(dh, b, FLOOR), K(ef, de, CEILING), K(eg, df, CEILING), dz, ea)
591 596                              }
592 597                      }
593 -             let ee = dW._1
594 -             let ef = dW._2
595 -             let eg = dW._3
596 -             let dv = H(dW._4, b)
597 -             let eh = H(dW._5, b)
598 -             if ((0 >= ee))
598 +             let eh = dZ._1
599 +             let ei = dZ._2
600 +             let ej = dZ._3
601 +             let dA = H(dZ._4, b)
602 +             let ek = H(dZ._5, b)
603 +             if ((0 >= eh))
599 604                  then throw("Invalid calculations. LP calculated is less than zero.")
600 605                  else {
601 -                     let ei = if (!(dM))
606 +                     let el = if (!(dP))
602 607                          then 0
603 -                         else ee
604 -                     let ej = (dH - ef)
605 -                     let ek = (dJ - eg)
606 -                     let el = [IntegerEntry(W(), dv), IntegerEntry(X(height, lastBlock.timestamp), dv), StringEntry(aa(ab, di), bu(ef, eg, ei, dv, dG, eh, height, lastBlock.timestamp, ej, ek))]
607 -                     $Tuple13(ee, ei, dv, dq, ds, dp, dl, do, el, ej, ek, dI, dK)
608 +                         else eh
609 +                     let em = (dK - ei)
610 +                     let en = (dM - ej)
611 +                     let eo = [IntegerEntry(W(), dA), IntegerEntry(X(height, lastBlock.timestamp), dA), StringEntry(aa(ab, dn), bu(ei, ej, el, dA, dJ, ek, height, lastBlock.timestamp, em, en))]
612 +                     $Tuple13(eh, el, dA, dv, dx, du, dq, dt, eo, em, en, dL, dN)
608 613                      }
609 614              }
610 615      }
611 616  
612 617  
613 - func em (en,eo,dp) = {
614 -     let ep = G(en, toBigInt(bp))
615 -     let eq = G(eo, toBigInt(bq))
616 -     let er = fraction(pow((ep * eq), 0, toBigInt(5), 1, 18, DOWN), g, dp)
617 -     if ((dp == f))
618 + func ep (eq,er,du) = {
619 +     let es = G(eq, toBigInt(bp))
620 +     let et = G(er, toBigInt(bq))
621 +     let eu = fraction(pow((es * et), 0, toBigInt(5), 1, 18, DOWN), g, du)
622 +     if ((du == f))
618 623          then f
619 -         else er
624 +         else eu
620 625      }
621 626  
622 627  
623 - func es (et,eu,ev) = {
624 -     let ew = (toBigInt(bJ(bf(bn))) - et)
625 -     let ex = (toBigInt(bJ(bf(bo))) - eu)
626 -     let ey = (toBigInt(value(assetInfo(bm)).quantity) - ev)
627 -     let ez = em(ew, ex, ey)
628 -     ez
628 + func ev (ew,ex,ey) = {
629 +     let ez = (toBigInt(bJ(bf(bn))) - ew)
630 +     let eA = (toBigInt(bJ(bf(bo))) - ex)
631 +     let eB = (toBigInt(value(assetInfo(bm)).quantity) - ey)
632 +     let eC = ep(ez, eA, eB)
633 +     eC
629 634      }
630 635  
631 636  
632 - func eA (eB,eC,ev) = {
633 -     let ew = (bJ(bf(bn)) + eB)
634 -     let ex = (bJ(bf(bo)) + eC)
635 -     let ey = (value(assetInfo(bm)).quantity + ev)
636 -     let er = em(toBigInt(ew), toBigInt(ex), toBigInt(ey))
637 -     let eD = [IntegerEntry(ak, height), StringEntry(aj, toString(er))]
638 -     $Tuple2(eD, er)
637 + func eD (eE,eF,ey) = {
638 +     let ez = (bJ(bf(bn)) + eE)
639 +     let eA = (bJ(bf(bo)) + eF)
640 +     let eB = (value(assetInfo(bm)).quantity + ey)
641 +     let eu = ep(toBigInt(ez), toBigInt(eA), toBigInt(eB))
642 +     let eG = [IntegerEntry(ak, height), StringEntry(aj, toString(eu))]
643 +     $Tuple2(eG, eu)
639 644      }
640 645  
641 646  
642 - func eE (eF,er) = if ((er >= eF))
647 + func eH (eI,eu) = if ((eu >= eI))
643 648      then true
644 -     else aQ(makeString(["updated KLp lower than current KLp", toString(eF), toString(er)], " "))
649 +     else aQ(makeString(["updated KLp lower than current KLp", toString(eI), toString(eu)], " "))
645 650  
646 651  
647 - func eG (eH) = {
648 -     let ew = bJ(bf(bn))
649 -     let ex = bJ(bf(bo))
650 -     let eI = eH.amount
651 -     let eJ = fraction(eH.amount, eH.price, b, FLOOR)
652 -     let eK = if ((eH.orderType == Buy))
653 -         then $Tuple2(eI, -(eJ))
654 -         else $Tuple2(-(eI), eJ)
655 -     let eB = eK._1
656 -     let eC = eK._2
652 + func eJ (eK) = {
653 +     let ez = bJ(bf(bn))
654 +     let eA = bJ(bf(bo))
655 +     let eL = eK.amount
656 +     let eM = fraction(eK.amount, eK.price, b, FLOOR)
657 +     let eN = if ((eK.orderType == Buy))
658 +         then $Tuple2(eL, -(eM))
659 +         else $Tuple2(-(eL), eM)
660 +     let eE = eN._1
661 +     let eF = eN._2
657 662      if (if (if (aY())
658 663          then true
659 664          else (bl == m))
660 665          then true
661 666          else (bl == n))
662 667          then throw("Exchange operations disabled")
663 -         else if (if ((eH.assetPair.amountAsset != bn))
668 +         else if (if ((eK.assetPair.amountAsset != bn))
664 669              then true
665 -             else (eH.assetPair.priceAsset != bo))
670 +             else (eK.assetPair.priceAsset != bo))
666 671              then throw("Wrong order assets.")
667 672              else {
668 -                 let eL = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
669 -                 let eM = eA(eB, eC, 0)
670 -                 let eN = eM._1
671 -                 let eO = eM._2
672 -                 let eP = (eO >= eL)
673 -                 let eQ = makeString(["kLp=", toString(eL), " kLpNew=", toString(eO), " amountAssetBalance=", toString(ew), " priceAssetBalance=", toString(ex), " amountAssetBalanceDelta=", toString(eB), " priceAssetBalanceDelta=", toString(eC), " height=", toString(height)], "")
674 -                 $Tuple2(eP, eQ)
673 +                 let eO = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
674 +                 let eP = eD(eE, eF, 0)
675 +                 let eQ = eP._1
676 +                 let eR = eP._2
677 +                 let eS = (eR >= eO)
678 +                 let eT = makeString(["kLp=", toString(eO), " kLpNew=", toString(eR), " amountAssetBalance=", toString(ez), " priceAssetBalance=", toString(eA), " amountAssetBalanceDelta=", toString(eE), " priceAssetBalanceDelta=", toString(eF), " height=", toString(height)], "")
679 +                 $Tuple2(eS, eT)
675 680                  }
676 681      }
677 682  
678 683  
679 - func eR (eS) = if ((size(eS.payments) != 1))
684 + func eU (eV) = if ((size(eV.payments) != 1))
680 685      then throw("exactly 1 payment is expected")
681 686      else {
682 -         let eT = value(eS.payments[0])
683 -         let dj = value(eT.assetId)
684 -         let eU = eT.amount
685 -         let dW = dh(toBase58String(eS.transactionId), toBase58String(dj), eU, eS.caller)
686 -         let dA = dW._1
687 -         let dB = dW._2
688 -         let do = parseIntValue(dW._9)
689 -         let dE = dW._10
687 +         let eW = value(eV.payments[0])
688 +         let do = value(eW.assetId)
689 +         let eX = eW.amount
690 +         let dZ = dm(toBase58String(eV.transactionId), toBase58String(do), eX, eV.caller)
691 +         let dF = dZ._1
692 +         let dG = dZ._2
693 +         let dt = parseIntValue(dZ._9)
694 +         let dH = dZ._10
690 695          if (if (aY())
691 696              then true
692 -             else (do == n))
693 -             then throw(("Get operation is blocked by admin. Status = " + toString(do)))
694 -             else $Tuple5(dA, dB, eU, dj, dE)
697 +             else (dt == n))
698 +             then throw(("Get operation is blocked by admin. Status = " + toString(dt)))
699 +             else $Tuple5(dF, dG, eX, do, dH)
695 700          }
696 701  
697 702  
698 - func eV (eS,dG,dM) = if ((size(eS.payments) != 2))
703 + func eY (eV,dJ,dP) = if ((size(eV.payments) != 2))
699 704      then throw("exactly 2 payments are expected")
700 705      else {
701 -         let eW = value(eS.payments[0])
702 -         let eX = value(eS.payments[1])
703 -         let eY = dF(toBase58String(eS.transactionId), dG, eW.amount, eW.assetId, eX.amount, eX.assetId, toString(eS.caller), false, dM)
704 -         let do = parseIntValue(eY._8)
706 +         let eZ = value(eV.payments[0])
707 +         let fa = value(eV.payments[1])
708 +         let fb = dI(toBase58String(eV.transactionId), dJ, eZ.amount, eZ.assetId, fa.amount, fa.assetId, toString(eV.caller), false, dP)
709 +         let dt = parseIntValue(fb._8)
705 710          if (if (if (aY())
706 711              then true
707 -             else (do == l))
712 +             else (dt == l))
708 713              then true
709 -             else (do == n))
710 -             then throw(("Put operation is blocked by admin. Status = " + toString(do)))
711 -             else eY
714 +             else (dt == n))
715 +             then throw(("Put operation is blocked by admin. Status = " + toString(dt)))
716 +             else fb
712 717          }
713 718  
714 719  
715 - func eZ (bW) = {
716 -     let fa = invoke(aT, "emit", [bW], nil)
717 -     if ((fa == fa))
720 + func fc (bW) = {
721 +     let fd = invoke(aT, "emit", [bW], nil)
722 +     if ((fd == fd))
718 723          then {
719 -             let fb = {
720 -                 let bT = fa
724 +             let fe = {
725 +                 let bT = fd
721 726                  if ($isInstanceOf(bT, "Address"))
722 727                      then {
723 -                         let fc = bT
724 -                         invoke(fc, "emit", [bW], nil)
728 +                         let ff = bT
729 +                         invoke(ff, "emit", [bW], nil)
725 730                          }
726 731                      else unit
727 732                  }
728 -             if ((fb == fb))
733 +             if ((fe == fe))
729 734                  then bW
730 735                  else throw("Strict value is not equal to itself.")
731 736              }
732 737          else throw("Strict value is not equal to itself.")
733 738      }
734 739  
735 740  
736 - func fd (bW,ai) = {
737 -     let fe = if ((ai == 0))
741 + func fg (bW,ai) = {
742 +     let fh = if ((ai == 0))
738 743          then 0
739 744          else fraction(bW, ai, b)
740 -     $Tuple2((bW - fe), fe)
745 +     $Tuple2((bW - fh), fh)
741 746      }
742 747  
743 748  
744 - func ff (fg,fh,ab,ac) = {
745 -     let fi = (ac == unit)
746 -     let fj = bJ(bf(bn))
747 -     let fk = bJ(bf(bo))
748 -     let fl = if ((fh == bn))
749 + func fi (fj,fk,ab,ac) = {
750 +     let fl = (ac == unit)
751 +     let fm = bJ(bf(bn))
752 +     let fn = bJ(bf(bo))
753 +     let fo = if ((fk == bn))
749 754          then true
750 -         else if ((fh == bo))
755 +         else if ((fk == bo))
751 756              then false
752 757              else aQ("invalid asset")
753 -     let fm = if (fi)
754 -         then $Tuple2(fj, fk)
755 -         else if (fl)
756 -             then $Tuple2((fj - fg), fk)
757 -             else $Tuple2(fj, (fk - fg))
758 -     let fn = fm._1
759 -     let fo = fm._2
760 758      let fp = if (fl)
761 -         then $Tuple2(fg, 0)
762 -         else $Tuple2(0, fg)
759 +         then $Tuple2(fm, fn)
760 +         else if (fo)
761 +             then $Tuple2((fm - fj), fn)
762 +             else $Tuple2(fm, (fn - fj))
763 763      let fq = fp._1
764 764      let fr = fp._2
765 -     let eI = fd(fq, aV)._1
766 -     let eJ = fd(fr, aV)._1
767 -     let fs = fd(fg, aV)
765 +     let fs = if (fo)
766 +         then $Tuple2(fj, 0)
767 +         else $Tuple2(0, fj)
768 768      let ft = fs._1
769 -     let fe = fs._2
770 -     let fu = (fn + eI)
771 -     let fv = (fo + eJ)
772 -     let fw = bM(D(fv, bq), D(fu, bp))
773 -     let fx = H(fw, b)
774 -     let fy = if (fl)
775 -         then fn
776 -         else fo
777 -     let fz = toBigInt(fy)
778 -     let fA = toBigInt(valueOrErrorMessage(assetInfo(bm), (("asset " + toBase58String(bm)) + " doesn't exist")).quantity)
779 -     let fB = if ((fA > f))
769 +     let fu = fs._2
770 +     let eL = fg(ft, aV)._1
771 +     let eM = fg(fu, aV)._1
772 +     let fv = fg(fj, aV)
773 +     let fw = fv._1
774 +     let fh = fv._2
775 +     let fx = (fq + eL)
776 +     let fy = (fr + eM)
777 +     let fz = bM(D(fy, bq), D(fx, bp))
778 +     let fA = H(fz, b)
779 +     let fB = if (fo)
780 +         then fq
781 +         else fr
782 +     let fC = toBigInt(fB)
783 +     let fD = toBigInt(valueOrErrorMessage(assetInfo(bm), (("asset " + toBase58String(bm)) + " doesn't exist")).quantity)
784 +     let fE = if ((fD > f))
780 785          then true
781 786          else aQ("initial deposit requires all coins")
782 -     if ((fB == fB))
787 +     if ((fE == fE))
783 788          then {
784 -             let fC = toBigInt(ft)
785 -             let fD = max([0, toInt(((fA * (sqrtBigInt((d + ((fC * d) / fz)), 18, 18, DOWN) - d)) / d))])
786 -             let el = if (fi)
789 +             let fF = toBigInt(fw)
790 +             let fG = max([0, toInt(((fD * (sqrtBigInt((d + ((fF * d) / fC)), 18, 18, DOWN) - d)) / d))])
791 +             let eo = if (fl)
787 792                  then nil
788 -                 else [IntegerEntry(W(), fx), IntegerEntry(X(height, lastBlock.timestamp), fx), StringEntry(aa(toString(value(ab)), toBase58String(value(ac))), bu(fq, fr, fD, fx, 0, 0, height, lastBlock.timestamp, 0, 0))]
789 -             let fE = bM(D(fo, bq), D(fn, bp))
790 -             let fF = H(fE, b)
791 -             let fG = {
792 -                 let fH = if (fl)
793 -                     then $Tuple2(fq, fn)
794 -                     else $Tuple2(fr, fo)
795 -                 let bW = fH._1
796 -                 let fI = fH._2
797 -                 let fJ = toInt(fraction(fA, toBigInt((bW / 2)), toBigInt(fI)))
798 -                 fraction((fD - fJ), b, fJ)
793 +                 else [IntegerEntry(W(), fA), IntegerEntry(X(height, lastBlock.timestamp), fA), StringEntry(aa(toString(value(ab)), toBase58String(value(ac))), bu(ft, fu, fG, fA, 0, 0, height, lastBlock.timestamp, 0, 0))]
794 +             let fH = bM(D(fr, bq), D(fq, bp))
795 +             let fI = H(fH, b)
796 +             let fJ = {
797 +                 let fK = if (fo)
798 +                     then $Tuple2(ft, fq)
799 +                     else $Tuple2(fu, fr)
800 +                 let bW = fK._1
801 +                 let fL = fK._2
802 +                 let fM = toInt(fraction(fD, toBigInt((bW / 2)), toBigInt(fL)))
803 +                 fraction((fG - fM), b, fM)
799 804                  }
800 -             $Tuple5(fD, el, fe, fG, fl)
805 +             $Tuple5(fG, eo, fh, fJ, fo)
801 806              }
802 807          else throw("Strict value is not equal to itself.")
803 808      }
804 809  
805 810  
806 - func fK (fL,ft,fh,ab,ac) = {
807 -     let fi = (ac == unit)
808 -     let cY = ba()
809 -     let cZ = parseIntValue(cY[t])
810 -     let da = parseIntValue(cY[u])
811 -     let fM = [if ((fh == bm))
811 + func fN (fO,fw,fk,ab,ac) = {
812 +     let fl = (ac == unit)
813 +     let dd = ba()
814 +     let de = parseIntValue(dd[t])
815 +     let df = parseIntValue(dd[u])
816 +     let fP = [if ((fk == bm))
812 817          then true
813 818          else aQ("invalid lp asset")]
814 -     if ((fM == fM))
819 +     if ((fP == fP))
815 820          then {
816 -             let fN = if ((fL == bn))
821 +             let fQ = if ((fO == bn))
817 822                  then true
818 -                 else if ((fL == bo))
823 +                 else if ((fO == bo))
819 824                      then false
820 825                      else aQ("invalid asset")
821 -             let fO = if (fN)
826 +             let fR = if (fQ)
822 827                  then toBigInt(bJ(bf(bn)))
823 828                  else toBigInt(bJ(bf(bo)))
824 -             let fP = if (fN)
825 -                 then cZ
826 -                 else da
827 -             let fQ = bJ(bf(bn))
828 -             let fR = bJ(bf(bo))
829 -             let fS = if (fN)
830 -                 then fQ
831 -                 else fR
832 -             let fT = toBigInt(fS)
833 -             let fA = toBigInt(valueOrErrorMessage(assetInfo(bm), (("asset " + toBase58String(bm)) + " doesn't exist")).quantity)
834 -             let fU = toBigInt(ft)
835 -             let fV = max([0, toInt(((fO * (d - pow((d - ((fU * d) / fA)), 18, h, 0, 18, DOWN))) / d))])
836 -             let fW = fd(fV, aX)
837 -             let fX = fW._1
838 -             let fe = fW._2
839 -             let fY = if (fN)
840 -                 then $Tuple4(fX, 0, (fQ - fV), fR)
841 -                 else $Tuple4(0, fX, fQ, (fR - fV))
842 -             let fZ = fY._1
843 -             let ga = fY._2
844 -             let gb = fY._3
845 -             let gc = fY._4
846 -             let fw = bM(D(gc, bq), D(gb, bp))
847 -             let fx = H(fw, b)
848 -             let el = if (fi)
829 +             let fS = if (fQ)
830 +                 then de
831 +                 else df
832 +             let fT = bJ(bf(bn))
833 +             let fU = bJ(bf(bo))
834 +             let fV = if (fQ)
835 +                 then fT
836 +                 else fU
837 +             let fW = toBigInt(fV)
838 +             let fD = toBigInt(valueOrErrorMessage(assetInfo(bm), (("asset " + toBase58String(bm)) + " doesn't exist")).quantity)
839 +             let fX = toBigInt(fw)
840 +             let fY = max([0, toInt(((fR * (d - pow((d - ((fX * d) / fD)), 18, h, 0, 18, DOWN))) / d))])
841 +             let fZ = fg(fY, aX)
842 +             let ga = fZ._1
843 +             let fh = fZ._2
844 +             let gb = if (fQ)
845 +                 then $Tuple4(ga, 0, (fT - fY), fU)
846 +                 else $Tuple4(0, ga, fT, (fU - fY))
847 +             let gc = gb._1
848 +             let gd = gb._2
849 +             let ge = gb._3
850 +             let gf = gb._4
851 +             let fz = bM(D(gf, bq), D(ge, bp))
852 +             let fA = H(fz, b)
853 +             let eo = if (fl)
849 854                  then nil
850 -                 else [StringEntry(ad(toString(value(ab)), toBase58String(value(ac))), bF(fZ, ga, ft, fx, height, lastBlock.timestamp)), IntegerEntry(W(), fx), IntegerEntry(X(height, lastBlock.timestamp), fx)]
851 -             let fE = bM(D(fR, bq), D(fQ, bp))
852 -             let fF = H(fE, b)
853 -             let fG = {
854 -                 let gd = (toInt(fraction(fO, fU, fA)) * 2)
855 -                 fraction((fX - gd), b, gd)
855 +                 else [StringEntry(ad(toString(value(ab)), toBase58String(value(ac))), bF(gc, gd, fw, fA, height, lastBlock.timestamp)), IntegerEntry(W(), fA), IntegerEntry(X(height, lastBlock.timestamp), fA)]
856 +             let fH = bM(D(fU, bq), D(fT, bp))
857 +             let fI = H(fH, b)
858 +             let fJ = {
859 +                 let gg = (toInt(fraction(fR, fX, fD)) * 2)
860 +                 fraction((ga - gg), b, gg)
856 861                  }
857 -             $Tuple5(fX, el, fe, fG, fN)
862 +             $Tuple5(ga, eo, fh, fJ, fQ)
858 863              }
859 864          else throw("Strict value is not equal to itself.")
860 865      }
861 866  
862 867  
863 - func ge () = {
868 + func gh () = {
864 869      let bT = getString(U())
865 870      if ($isInstanceOf(bT, "String"))
866 871          then {
867 -             let gf = bT
868 -             fromBase58String(gf)
872 +             let gi = bT
873 +             fromBase58String(gi)
869 874              }
870 875          else if ($isInstanceOf(bT, "Unit"))
871 876              then unit
872 877              else throw("Match error")
873 878      }
874 879  
875 880  
876 - func gg () = {
881 + func gj () = {
877 882      let bT = getString(V())
878 883      if ($isInstanceOf(bT, "String"))
879 884          then {
880 -             let gf = bT
881 -             fromBase58String(gf)
885 +             let gi = bT
886 +             fromBase58String(gi)
882 887              }
883 888          else if ($isInstanceOf(bT, "Unit"))
884 889              then unit
885 890              else throw("Match error")
886 891      }
887 892  
888 893  
889 - func gh (eS) = {
890 -     let bT = ge()
894 + func gk (eV) = {
895 +     let bT = gh()
891 896      if ($isInstanceOf(bT, "ByteVector"))
892 897          then {
893 -             let gi = bT
894 -             (eS.callerPublicKey == gi)
898 +             let gl = bT
899 +             (eV.callerPublicKey == gl)
895 900              }
896 901          else if ($isInstanceOf(bT, "Unit"))
897 -             then (eS.caller == this)
902 +             then (eV.caller == this)
898 903              else throw("Match error")
899 904      }
900 905  
901 906  
902 - func gj (eS) = {
903 -     let gk = throw("Permission denied")
904 -     let bT = ge()
907 + func gm (eV) = {
908 +     let gn = throw("Permission denied")
909 +     let bT = gh()
905 910      if ($isInstanceOf(bT, "ByteVector"))
906 911          then {
907 -             let gi = bT
908 -             if ((eS.callerPublicKey == gi))
912 +             let gl = bT
913 +             if ((eV.callerPublicKey == gl))
909 914                  then true
910 -                 else gk
915 +                 else gn
911 916              }
912 917          else if ($isInstanceOf(bT, "Unit"))
913 -             then if ((eS.caller == this))
918 +             then if ((eV.caller == this))
914 919                  then true
915 -                 else gk
920 +                 else gn
916 921              else throw("Match error")
917 922      }
918 923  
919 924  
920 - @Callable(eS)
925 + @Callable(eV)
921 926  func rebalance () = (cD(aM(this, ae())) ++ cD(aM(this, af())))
922 927  
923 928  
924 929  
925 - @Callable(eS)
926 - func calculateAmountOutForSwapREADONLY (gl,gm,gn) = {
927 -     let go = if ((gm == false))
930 + @Callable(eV)
931 + func calculateAmountOutForSwapREADONLY (go,gp,gq) = {
932 +     let gr = if ((gp == false))
928 933          then {
929 -             let gp = aM(this, af())
930 -             let gq = aM(this, ae())
931 -             $Tuple2(gp, gq)
934 +             let gs = aM(this, af())
935 +             let gt = aM(this, ae())
936 +             $Tuple2(gs, gt)
932 937              }
933 938          else {
934 -             let gp = aM(this, ae())
935 -             let gq = aM(this, af())
936 -             $Tuple2(gp, gq)
939 +             let gs = aM(this, ae())
940 +             let gt = aM(this, af())
941 +             $Tuple2(gs, gt)
937 942              }
938 -     let gp = go._1
939 -     let gq = go._2
940 -     let gr = bJ(gq)
941 -     let gs = bJ(gp)
942 -     let gt = fraction(gs, gl, (gr + gl))
943 -     let gu = (toBigInt(gr) * toBigInt(gs))
944 -     let gv = (((toBigInt(bJ(gq)) + toBigInt(gl)) + toBigInt(gn)) * (toBigInt(bJ(gp)) - toBigInt(gt)))
945 -     let gw = if ((gv >= gu))
943 +     let gs = gr._1
944 +     let gt = gr._2
945 +     let gu = bJ(gt)
946 +     let gv = bJ(gs)
947 +     let gw = fraction(gv, go, (gu + go))
948 +     let gx = (toBigInt(gu) * toBigInt(gv))
949 +     let gy = (((toBigInt(bJ(gt)) + toBigInt(go)) + toBigInt(gq)) * (toBigInt(bJ(gs)) - toBigInt(gw)))
950 +     let gz = if ((gy >= gx))
946 951          then true
947 952          else throw("new K is fewer error")
948 -     if ((gw == gw))
949 -         then $Tuple2(nil, gt)
953 +     if ((gz == gz))
954 +         then $Tuple2(nil, gw)
950 955          else throw("Strict value is not equal to itself.")
951 956      }
952 957  
953 958  
954 959  
955 - @Callable(eS)
956 - func calculateAmountOutForSwapAndSendTokens (gl,gm,gx,gy,gn) = {
957 -     let gz = {
960 + @Callable(eV)
961 + func calculateAmountOutForSwapAndSendTokens (go,gp,gA,gB,gq) = {
962 +     let gC = {
958 963          let aW = invoke(aT, "getSwapContractREADONLY", nil, nil)
959 964          if ($isInstanceOf(aW, "String"))
960 965              then aW
961 966              else throw(($getType(aW) + " couldn't be cast to String"))
962 967          }
963 -     let fM = [if ((value(eS.payments[0]).amount >= gl))
968 +     let fP = [if ((value(eV.payments[0]).amount >= go))
964 969          then true
965 -         else aQ("Wrong amount"), if ((eS.caller == addressFromStringValue(gz)))
970 +         else aQ("Wrong amount"), if ((eV.caller == addressFromStringValue(gC)))
966 971          then true
967 972          else aQ("Permission denied")]
968 -     if ((fM == fM))
973 +     if ((fP == fP))
969 974          then {
970 -             let eT = value(eS.payments[0])
971 -             let gq = bf(eT.assetId)
972 -             let gp = if ((gm == false))
975 +             let eW = value(eV.payments[0])
976 +             let gt = bf(eW.assetId)
977 +             let gs = if ((gp == false))
973 978                  then aM(this, af())
974 979                  else aM(this, ae())
975 -             let gr = (bJ(gq) - value(eS.payments[0]).amount)
976 -             let gs = bJ(gp)
977 -             let gt = fraction(gs, gl, (gr + gl))
978 -             let gu = (toBigInt(gr) * toBigInt(gs))
979 -             let gv = ((toBigInt(bJ(gq)) + toBigInt(gn)) * (toBigInt(bJ(gp)) - toBigInt(gt)))
980 -             let gw = if ((gv >= gu))
980 +             let gu = (bJ(gt) - value(eV.payments[0]).amount)
981 +             let gv = bJ(gs)
982 +             let gw = fraction(gv, go, (gu + go))
983 +             let gx = (toBigInt(gu) * toBigInt(gv))
984 +             let gy = ((toBigInt(bJ(gt)) + toBigInt(gq)) * (toBigInt(bJ(gs)) - toBigInt(gw)))
985 +             let gz = if ((gy >= gx))
981 986                  then true
982 987                  else throw("new K is fewer error")
983 -             if ((gw == gw))
988 +             if ((gz == gz))
984 989                  then {
985 -                     let gA = if ((gt >= gx))
990 +                     let gD = if ((gw >= gA))
986 991                          then true
987 992                          else throw("Exchange result is fewer coins than expected")
988 -                     if ((gA == gA))
993 +                     if ((gD == gD))
989 994                          then {
990 -                             let gB = cD(gq)
991 -                             if ((gB == gB))
995 +                             let gE = cD(gt)
996 +                             if ((gE == gE))
992 997                                  then {
993 -                                     let gC = cK(gp, gt)
994 -                                     if ((gC == gC))
995 -                                         then $Tuple2(((gC ++ gB) ++ [ScriptTransfer(addressFromStringValue(gy), gt, bd(gp))]), gt)
998 +                                     let gF = cK(gs, gw)
999 +                                     if ((gF == gF))
1000 +                                         then $Tuple2(((gF ++ gE) ++ [ScriptTransfer(addressFromStringValue(gB), gw, bd(gs))]), gw)
996 1001                                          else throw("Strict value is not equal to itself.")
997 1002                                      }
998 1003                                  else throw("Strict value is not equal to itself.")
999 1004                              }
1000 1005                          else throw("Strict value is not equal to itself.")
1001 1006                      }
1002 1007                  else throw("Strict value is not equal to itself.")
1003 1008              }
1004 1009          else throw("Strict value is not equal to itself.")
1005 1010      }
1006 1011  
1007 1012  
1008 1013  
1009 - @Callable(eS)
1010 - func setManager (gD) = {
1011 -     let gE = gj(eS)
1012 -     if ((gE == gE))
1014 + @Callable(eV)
1015 + func setManager (gG) = {
1016 +     let gH = gm(eV)
1017 +     if ((gH == gH))
1013 1018          then {
1014 -             let gF = fromBase58String(gD)
1015 -             if ((gF == gF))
1016 -                 then [StringEntry(V(), gD)]
1019 +             let gI = fromBase58String(gG)
1020 +             if ((gI == gI))
1021 +                 then [StringEntry(V(), gG)]
1017 1022                  else throw("Strict value is not equal to itself.")
1018 1023              }
1019 1024          else throw("Strict value is not equal to itself.")
1020 1025      }
1021 1026  
1022 1027  
1023 1028  
1024 - @Callable(eS)
1029 + @Callable(eV)
1025 1030  func confirmManager () = {
1026 -     let gG = gg()
1027 -     let gH = if (isDefined(gG))
1031 +     let gJ = gj()
1032 +     let gK = if (isDefined(gJ))
1028 1033          then true
1029 1034          else throw("No pending manager")
1030 -     if ((gH == gH))
1035 +     if ((gK == gK))
1031 1036          then {
1032 -             let gI = if ((eS.callerPublicKey == value(gG)))
1037 +             let gL = if ((eV.callerPublicKey == value(gJ)))
1033 1038                  then true
1034 1039                  else throw("You are not pending manager")
1035 -             if ((gI == gI))
1036 -                 then [StringEntry(U(), toBase58String(value(gG))), DeleteEntry(V())]
1040 +             if ((gL == gL))
1041 +                 then [StringEntry(U(), toBase58String(value(gJ))), DeleteEntry(V())]
1037 1042                  else throw("Strict value is not equal to itself.")
1038 1043              }
1039 1044          else throw("Strict value is not equal to itself.")
1040 1045      }
1041 1046  
1042 1047  
1043 1048  
1044 - @Callable(eS)
1045 - func put (dG,gJ) = if ((0 > dG))
1049 + @Callable(eV)
1050 + func put (dJ,gM) = if ((0 > dJ))
1046 1051      then throw("Invalid slippageTolerance passed")
1047 1052      else {
1048 -         let eY = eV(eS, dG, true)
1049 -         let ei = eY._2
1050 -         let dl = eY._7
1051 -         let dE = eY._9
1052 -         let ej = eY._10
1053 -         let ek = eY._11
1054 -         let gK = eY._12
1055 -         let gL = eY._13
1056 -         let eW = toBigInt(value(eS.payments[0]).amount)
1057 -         let eX = toBigInt(value(eS.payments[1]).amount)
1058 -         let ez = es(eW, eX, toBigInt(0))
1059 -         if ((ez == ez))
1053 +         let fb = eY(eV, dJ, true)
1054 +         let el = fb._2
1055 +         let dq = fb._7
1056 +         let dH = fb._9
1057 +         let em = fb._10
1058 +         let en = fb._11
1059 +         let gN = fb._12
1060 +         let gO = fb._13
1061 +         let eZ = toBigInt(value(eV.payments[0]).amount)
1062 +         let fa = toBigInt(value(eV.payments[1]).amount)
1063 +         let eC = ev(eZ, fa, toBigInt(0))
1064 +         if ((eC == eC))
1060 1065              then {
1061 -                 let fa = invoke(aT, "emit", [ei], nil)
1062 -                 if ((fa == fa))
1066 +                 let fd = invoke(aT, "emit", [el], nil)
1067 +                 if ((fd == fd))
1063 1068                      then {
1064 -                         let fb = {
1065 -                             let bT = fa
1069 +                         let fe = {
1070 +                             let bT = fd
1066 1071                              if ($isInstanceOf(bT, "Address"))
1067 1072                                  then {
1068 -                                     let fc = bT
1069 -                                     invoke(fc, "emit", [ei], nil)
1073 +                                     let ff = bT
1074 +                                     invoke(ff, "emit", [el], nil)
1070 1075                                      }
1071 1076                                  else unit
1072 1077                              }
1073 -                         if ((fb == fb))
1078 +                         if ((fe == fe))
1074 1079                              then {
1075 -                                 let gM = if ((ej > 0))
1076 -                                     then invoke(bt, "put", nil, [AttachedPayment(gK, ej)])
1080 +                                 let gP = if ((em > 0))
1081 +                                     then invoke(bt, "put", nil, [AttachedPayment(gN, em)])
1077 1082                                      else nil
1078 -                                 if ((gM == gM))
1083 +                                 if ((gP == gP))
1079 1084                                      then {
1080 -                                         let gN = if ((ek > 0))
1081 -                                             then invoke(bt, "put", nil, [AttachedPayment(gL, ek)])
1085 +                                         let gQ = if ((en > 0))
1086 +                                             then invoke(bt, "put", nil, [AttachedPayment(gO, en)])
1082 1087                                              else nil
1083 -                                         if ((gN == gN))
1088 +                                         if ((gQ == gQ))
1084 1089                                              then {
1085 -                                                 let gO = if (gJ)
1090 +                                                 let gR = if (gM)
1086 1091                                                      then {
1087 -                                                         let gP = invoke(bs, "stake", nil, [AttachedPayment(dl, ei)])
1088 -                                                         if ((gP == gP))
1092 +                                                         let gS = invoke(bs, "stake", nil, [AttachedPayment(dq, el)])
1093 +                                                         if ((gS == gS))
1089 1094                                                              then nil
1090 1095                                                              else throw("Strict value is not equal to itself.")
1091 1096                                                          }
1092 -                                                     else [ScriptTransfer(eS.caller, ei, dl)]
1093 -                                                 let gQ = eA(0, 0, 0)
1094 -                                                 if ((gQ == gQ))
1097 +                                                     else [ScriptTransfer(eV.caller, el, dq)]
1098 +                                                 let gT = eD(0, 0, 0)
1099 +                                                 if ((gT == gT))
1095 1100                                                      then {
1096 -                                                         let er = gQ._2
1097 -                                                         let gR = gQ._1
1098 -                                                         let gS = eE(ez, er)
1099 -                                                         if ((gS == gS))
1101 +                                                         let eu = gT._2
1102 +                                                         let gU = gT._1
1103 +                                                         let gV = eH(eC, eu)
1104 +                                                         if ((gV == gV))
1100 1105                                                              then {
1101 -                                                                 let gT = invoke(this, "rebalance", nil, nil)
1102 -                                                                 if ((gT == gT))
1103 -                                                                     then ((dE ++ gO) ++ gR)
1106 +                                                                 let gW = invoke(this, "rebalance", nil, nil)
1107 +                                                                 if ((gW == gW))
1108 +                                                                     then ((dH ++ gR) ++ gU)
1104 1109                                                                      else throw("Strict value is not equal to itself.")
1105 1110                                                                  }
1106 1111                                                              else throw("Strict value is not equal to itself.")
1107 1112                                                          }
1108 1113                                                      else throw("Strict value is not equal to itself.")
1109 1114                                                  }
1110 1115                                              else throw("Strict value is not equal to itself.")
1111 1116                                          }
1112 1117                                      else throw("Strict value is not equal to itself.")
1113 1118                                  }
1114 1119                              else throw("Strict value is not equal to itself.")
1115 1120                          }
1116 1121                      else throw("Strict value is not equal to itself.")
1117 1122                  }
1118 1123              else throw("Strict value is not equal to itself.")
1119 1124          }
1120 1125  
1121 1126  
1122 1127  
1123 - @Callable(eS)
1124 - func putForFree (gU) = if ((0 > gU))
1128 + @Callable(eV)
1129 + func putForFree (gX) = if ((0 > gX))
1125 1130      then throw("Invalid value passed")
1126 1131      else {
1127 -         let eY = eV(eS, gU, false)
1128 -         let dE = eY._9
1129 -         let eW = toBigInt(value(eS.payments[0]).amount)
1130 -         let eX = toBigInt(value(eS.payments[1]).amount)
1131 -         let ez = es(eW, eX, toBigInt(0))
1132 -         if ((ez == ez))
1132 +         let fb = eY(eV, gX, false)
1133 +         let dH = fb._9
1134 +         let eZ = toBigInt(value(eV.payments[0]).amount)
1135 +         let fa = toBigInt(value(eV.payments[1]).amount)
1136 +         let eC = ev(eZ, fa, toBigInt(0))
1137 +         if ((eC == eC))
1133 1138              then {
1134 -                 let gV = eA(0, 0, 0)
1135 -                 let gR = gV._1
1136 -                 let er = gV._2
1137 -                 let gS = eE(ez, er)
1138 -                 if ((gS == gS))
1139 -                     then (dE ++ gR)
1139 +                 let gY = eD(0, 0, 0)
1140 +                 let gU = gY._1
1141 +                 let eu = gY._2
1142 +                 let gV = eH(eC, eu)
1143 +                 if ((gV == gV))
1144 +                     then (dH ++ gU)
1140 1145                      else throw("Strict value is not equal to itself.")
1141 1146                  }
1142 1147              else throw("Strict value is not equal to itself.")
1143 1148          }
1144 1149  
1145 1150  
1146 1151  
1147 - @Callable(eS)
1148 - func putOneTkn (gW,gX) = {
1149 -     let gY = {
1152 + @Callable(eV)
1153 + func putOneTkn (gZ,ha) = {
1154 +     let hb = {
1150 1155          let aW = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1151 1156          if ($isInstanceOf(aW, "Boolean"))
1152 1157              then aW
1153 1158              else throw(($getType(aW) + " couldn't be cast to Boolean"))
1154 1159          }
1155 -     let gZ = if (if (if (aY())
1160 +     let hc = if (if (if (aY())
1156 1161          then true
1157 1162          else (bl == l))
1158 1163          then true
1159 1164          else (bl == n))
1160 1165          then true
1161 -         else gY
1162 -     let fM = [if (if (!(gZ))
1166 +         else hb
1167 +     let fP = [if (if (!(hc))
1163 1168          then true
1164 -         else gh(eS))
1169 +         else gk(eV))
1165 1170          then true
1166 -         else aQ("put operation is blocked by admin"), if ((size(eS.payments) == 1))
1171 +         else aQ("put operation is blocked by admin"), if ((size(eV.payments) == 1))
1167 1172          then true
1168 1173          else aQ("exactly 1 payment are expected")]
1169 -     if ((fM == fM))
1174 +     if ((fP == fP))
1170 1175          then {
1171 -             let ha = eS.payments[0]
1172 -             let fh = ha.assetId
1173 -             let fg = ha.amount
1174 -             let ez = if ((fh == bn))
1175 -                 then es(toBigInt(fg), toBigInt(0), toBigInt(0))
1176 -                 else if ((fh == bo))
1177 -                     then es(toBigInt(0), toBigInt(fg), toBigInt(0))
1176 +             let hd = eV.payments[0]
1177 +             let fk = hd.assetId
1178 +             let fj = hd.amount
1179 +             let eC = if ((fk == bn))
1180 +                 then ev(toBigInt(fj), toBigInt(0), toBigInt(0))
1181 +                 else if ((fk == bo))
1182 +                     then ev(toBigInt(0), toBigInt(fj), toBigInt(0))
1178 1183                      else aQ("payment asset is not supported")
1179 -             if ((ez == ez))
1184 +             if ((eC == eC))
1180 1185                  then {
1181 -                     let ab = eS.caller
1182 -                     let ac = eS.transactionId
1183 -                     let hb = ff(fg, fh, ab, ac)
1184 -                     if ((hb == hb))
1186 +                     let ab = eV.caller
1187 +                     let ac = eV.transactionId
1188 +                     let he = fi(fj, fk, ab, ac)
1189 +                     if ((he == he))
1185 1190                          then {
1186 -                             let fl = hb._5
1187 -                             let hc = hb._4
1188 -                             let fe = hb._3
1189 -                             let el = hb._2
1190 -                             let hd = hb._1
1191 -                             let he = if (if ((gW > 0))
1192 -                                 then (gW > hd)
1191 +                             let fo = he._5
1192 +                             let hf = he._4
1193 +                             let fh = he._3
1194 +                             let eo = he._2
1195 +                             let hg = he._1
1196 +                             let hh = if (if ((gZ > 0))
1197 +                                 then (gZ > hg)
1193 1198                                  else false)
1194 -                                 then aQ(makeString(["amount to receive is less than ", toString(gW)], ""))
1195 -                                 else hd
1196 -                             let fa = eZ(he)
1197 -                             if ((fa == fa))
1199 +                                 then aQ(makeString(["amount to receive is less than ", toString(gZ)], ""))
1200 +                                 else hg
1201 +                             let fd = fc(hh)
1202 +                             if ((fd == fd))
1198 1203                                  then {
1199 -                                     let gO = if (gX)
1204 +                                     let gR = if (ha)
1200 1205                                          then {
1201 -                                             let hf = invoke(bs, "stake", nil, [AttachedPayment(bm, he)])
1202 -                                             if ((hf == hf))
1206 +                                             let hi = invoke(bs, "stake", nil, [AttachedPayment(bm, hh)])
1207 +                                             if ((hi == hi))
1203 1208                                                  then nil
1204 1209                                                  else throw("Strict value is not equal to itself.")
1205 1210                                              }
1206 -                                         else [ScriptTransfer(eS.caller, he, bm)]
1207 -                                     let hg = if ((fe > 0))
1208 -                                         then [ScriptTransfer(aU, fe, fh)]
1211 +                                         else [ScriptTransfer(eV.caller, hh, bm)]
1212 +                                     let hj = if ((fh > 0))
1213 +                                         then [ScriptTransfer(aU, fh, fk)]
1209 1214                                          else nil
1210 -                                     let hh = if ((this == aU))
1215 +                                     let hk = if ((this == aU))
1211 1216                                          then $Tuple2(0, 0)
1212 -                                         else if (fl)
1213 -                                             then $Tuple2(-(fe), 0)
1214 -                                             else $Tuple2(0, -(fe))
1215 -                                     let eB = hh._1
1216 -                                     let eC = hh._2
1217 -                                     let hi = eA(eB, eC, 0)
1218 -                                     let gR = hi._1
1219 -                                     let er = hi._2
1220 -                                     let eL = value(getString(aj))
1221 -                                     let gS = eE(ez, er)
1222 -                                     if ((gS == gS))
1217 +                                         else if (fo)
1218 +                                             then $Tuple2(-(fh), 0)
1219 +                                             else $Tuple2(0, -(fh))
1220 +                                     let eE = hk._1
1221 +                                     let eF = hk._2
1222 +                                     let hl = eD(eE, eF, 0)
1223 +                                     let gU = hl._1
1224 +                                     let eu = hl._2
1225 +                                     let eO = value(getString(aj))
1226 +                                     let gV = eH(eC, eu)
1227 +                                     if ((gV == gV))
1223 1228                                          then {
1224 -                                             let gT = invoke(this, "rebalance", nil, nil)
1225 -                                             if ((gT == gT))
1226 -                                                 then $Tuple2((((el ++ gO) ++ hg) ++ gR), he)
1229 +                                             let gW = invoke(this, "rebalance", nil, nil)
1230 +                                             if ((gW == gW))
1231 +                                                 then $Tuple2((((eo ++ gR) ++ hj) ++ gU), hh)
1227 1232                                                  else throw("Strict value is not equal to itself.")
1228 1233                                              }
1229 1234                                          else throw("Strict value is not equal to itself.")
1230 1235                                      }
1231 1236                                  else throw("Strict value is not equal to itself.")
1232 1237                              }
1233 1238                          else throw("Strict value is not equal to itself.")
1234 1239                      }
1235 1240                  else throw("Strict value is not equal to itself.")
1236 1241              }
1237 1242          else throw("Strict value is not equal to itself.")
1238 1243      }
1239 1244  
1240 1245  
1241 1246  
1242 - @Callable(eS)
1243 - func putOneTknREADONLY (fh,fg) = {
1244 -     let hj = ff(fg, bd(fh), unit, unit)
1245 -     let hd = hj._1
1246 -     let el = hj._2
1247 -     let fe = hj._3
1248 -     let hc = hj._4
1249 -     let fl = hj._5
1250 -     $Tuple2(nil, $Tuple3(hd, fe, hc))
1247 + @Callable(eV)
1248 + func putOneTknREADONLY (fk,fj) = {
1249 +     let hm = fi(fj, bd(fk), unit, unit)
1250 +     let hg = hm._1
1251 +     let eo = hm._2
1252 +     let fh = hm._3
1253 +     let hf = hm._4
1254 +     let fo = hm._5
1255 +     $Tuple2(nil, $Tuple3(hg, fh, hf))
1251 1256      }
1252 1257  
1253 1258  
1254 1259  
1255 - @Callable(eS)
1256 - func getOneTkn (hk,gW) = {
1257 -     let gY = {
1260 + @Callable(eV)
1261 + func getOneTkn (hn,gZ) = {
1262 +     let hb = {
1258 1263          let aW = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1259 1264          if ($isInstanceOf(aW, "Boolean"))
1260 1265              then aW
1261 1266              else throw(($getType(aW) + " couldn't be cast to Boolean"))
1262 1267          }
1263 -     let hl = if (if (aY())
1268 +     let ho = if (if (aY())
1264 1269          then true
1265 1270          else (bl == n))
1266 1271          then true
1267 -         else gY
1268 -     let fM = [if (if (!(hl))
1272 +         else hb
1273 +     let fP = [if (if (!(ho))
1269 1274          then true
1270 -         else gh(eS))
1275 +         else gk(eV))
1271 1276          then true
1272 -         else aQ("get operation is blocked by admin"), if ((size(eS.payments) == 1))
1277 +         else aQ("get operation is blocked by admin"), if ((size(eV.payments) == 1))
1273 1278          then true
1274 1279          else aQ("exactly 1 payment are expected")]
1275 -     if ((fM == fM))
1280 +     if ((fP == fP))
1276 1281          then {
1277 -             let fL = bd(hk)
1278 -             let ha = eS.payments[0]
1279 -             let fh = ha.assetId
1280 -             let ft = ha.amount
1281 -             let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1282 -             if ((ez == ez))
1282 +             let fO = bd(hn)
1283 +             let hd = eV.payments[0]
1284 +             let fk = hd.assetId
1285 +             let fw = hd.amount
1286 +             let eC = ev(toBigInt(0), toBigInt(0), toBigInt(0))
1287 +             if ((eC == eC))
1283 1288                  then {
1284 -                     let ab = eS.caller
1285 -                     let ac = eS.transactionId
1286 -                     let hm = fK(fL, ft, fh, ab, ac)
1287 -                     if ((hm == hm))
1289 +                     let ab = eV.caller
1290 +                     let ac = eV.transactionId
1291 +                     let hp = fN(fO, fw, fk, ab, ac)
1292 +                     if ((hp == hp))
1288 1293                          then {
1289 -                             let fN = hm._5
1290 -                             let hc = hm._4
1291 -                             let fe = hm._3
1292 -                             let el = hm._2
1293 -                             let hn = hm._1
1294 -                             let bW = if (if ((gW > 0))
1295 -                                 then (gW > hn)
1294 +                             let fQ = hp._5
1295 +                             let hf = hp._4
1296 +                             let fh = hp._3
1297 +                             let eo = hp._2
1298 +                             let hq = hp._1
1299 +                             let bW = if (if ((gZ > 0))
1300 +                                 then (gZ > hq)
1296 1301                                  else false)
1297 -                                 then aQ(makeString(["amount to receive is less than ", toString(gW)], ""))
1298 -                                 else hn
1299 -                             let ho = invoke(aT, "burn", [ft], [AttachedPayment(fh, ft)])
1300 -                             if ((ho == ho))
1302 +                                 then aQ(makeString(["amount to receive is less than ", toString(gZ)], ""))
1303 +                                 else hq
1304 +                             let hr = invoke(aT, "burn", [fw], [AttachedPayment(fk, fw)])
1305 +                             if ((hr == hr))
1301 1306                                  then {
1302 -                                     let gC = cK(hk, bW)
1303 -                                     let hp = [ScriptTransfer(ab, bW, fL)]
1304 -                                     let hg = if ((fe > 0))
1305 -                                         then [ScriptTransfer(aU, fe, fL)]
1307 +                                     let gF = cK(hn, bW)
1308 +                                     let hs = [ScriptTransfer(ab, bW, fO)]
1309 +                                     let hj = if ((fh > 0))
1310 +                                         then [ScriptTransfer(aU, fh, fO)]
1306 1311                                          else nil
1307 -                                     let hq = {
1308 -                                         let hr = if ((this == aU))
1312 +                                     let ht = {
1313 +                                         let hu = if ((this == aU))
1309 1314                                              then 0
1310 -                                             else fe
1311 -                                         if (fN)
1312 -                                             then $Tuple2(-((bW + hr)), 0)
1313 -                                             else $Tuple2(0, -((bW + hr)))
1315 +                                             else fh
1316 +                                         if (fQ)
1317 +                                             then $Tuple2(-((bW + hu)), 0)
1318 +                                             else $Tuple2(0, -((bW + hu)))
1314 1319                                          }
1315 -                                     let eB = hq._1
1316 -                                     let eC = hq._2
1317 -                                     let hs = eA(eB, eC, 0)
1318 -                                     let gR = hs._1
1319 -                                     let er = hs._2
1320 -                                     let gS = eE(ez, er)
1321 -                                     if ((gS == gS))
1322 -                                         then $Tuple2(((((el ++ gC) ++ hp) ++ hg) ++ gR), bW)
1320 +                                     let eE = ht._1
1321 +                                     let eF = ht._2
1322 +                                     let hv = eD(eE, eF, 0)
1323 +                                     let gU = hv._1
1324 +                                     let eu = hv._2
1325 +                                     let gV = eH(eC, eu)
1326 +                                     if ((gV == gV))
1327 +                                         then $Tuple2(((((eo ++ gF) ++ hs) ++ hj) ++ gU), bW)
1323 1328                                          else throw("Strict value is not equal to itself.")
1324 1329                                      }
1325 1330                                  else throw("Strict value is not equal to itself.")
1326 1331                              }
1327 1332                          else throw("Strict value is not equal to itself.")
1328 1333                      }
1329 1334                  else throw("Strict value is not equal to itself.")
1330 1335              }
1331 1336          else throw("Strict value is not equal to itself.")
1332 1337      }
1333 1338  
1334 1339  
1335 1340  
1336 - @Callable(eS)
1337 - func getOneTknREADONLY (fL,ft) = {
1338 -     let ht = fK(bd(fL), ft, bm, unit, unit)
1339 -     let hn = ht._1
1340 -     let el = ht._2
1341 -     let fe = ht._3
1342 -     let hc = ht._4
1343 -     let fN = ht._5
1344 -     $Tuple2(nil, $Tuple3(hn, fe, hc))
1341 + @Callable(eV)
1342 + func getOneTknREADONLY (fO,fw) = {
1343 +     let hw = fN(bd(fO), fw, bm, unit, unit)
1344 +     let hq = hw._1
1345 +     let eo = hw._2
1346 +     let fh = hw._3
1347 +     let hf = hw._4
1348 +     let fQ = hw._5
1349 +     $Tuple2(nil, $Tuple3(hq, fh, hf))
1345 1350      }
1346 1351  
1347 1352  
1348 1353  
1349 - @Callable(eS)
1350 - func unstakeAndGetOneTkn (hu,hk,gW) = {
1351 -     let gY = {
1354 + @Callable(eV)
1355 + func unstakeAndGetOneTkn (hx,hn,gZ) = {
1356 +     let hb = {
1352 1357          let aW = invoke(aT, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1353 1358          if ($isInstanceOf(aW, "Boolean"))
1354 1359              then aW
1355 1360              else throw(($getType(aW) + " couldn't be cast to Boolean"))
1356 1361          }
1357 -     let hl = if (if (aY())
1362 +     let ho = if (if (aY())
1358 1363          then true
1359 1364          else (bl == n))
1360 1365          then true
1361 -         else gY
1362 -     let fM = [if (if (!(hl))
1366 +         else hb
1367 +     let fP = [if (if (!(ho))
1363 1368          then true
1364 -         else gh(eS))
1369 +         else gk(eV))
1365 1370          then true
1366 -         else aQ("get operation is blocked by admin"), if ((size(eS.payments) == 0))
1371 +         else aQ("get operation is blocked by admin"), if ((size(eV.payments) == 0))
1367 1372          then true
1368 1373          else aQ("no payments are expected")]
1369 -     if ((fM == fM))
1374 +     if ((fP == fP))
1370 1375          then {
1371 -             let fL = bd(hk)
1372 -             let ab = eS.caller
1373 -             let ac = eS.transactionId
1374 -             let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1375 -             if ((ez == ez))
1376 +             let fO = bd(hn)
1377 +             let ab = eV.caller
1378 +             let ac = eV.transactionId
1379 +             let eC = ev(toBigInt(0), toBigInt(0), toBigInt(0))
1380 +             if ((eC == eC))
1376 1381                  then {
1377 -                     let hv = invoke(bs, "unstake", [toBase58String(bm), hu], nil)
1378 -                     if ((hv == hv))
1382 +                     let hy = invoke(bs, "unstake", [toBase58String(bm), hx], nil)
1383 +                     if ((hy == hy))
1379 1384                          then {
1380 -                             let hw = fK(fL, hu, bm, ab, ac)
1381 -                             if ((hw == hw))
1385 +                             let hz = fN(fO, hx, bm, ab, ac)
1386 +                             if ((hz == hz))
1382 1387                                  then {
1383 -                                     let fN = hw._5
1384 -                                     let hc = hw._4
1385 -                                     let fe = hw._3
1386 -                                     let el = hw._2
1387 -                                     let hn = hw._1
1388 -                                     let bW = if (if ((gW > 0))
1389 -                                         then (gW > hn)
1388 +                                     let fQ = hz._5
1389 +                                     let hf = hz._4
1390 +                                     let fh = hz._3
1391 +                                     let eo = hz._2
1392 +                                     let hq = hz._1
1393 +                                     let bW = if (if ((gZ > 0))
1394 +                                         then (gZ > hq)
1390 1395                                          else false)
1391 -                                         then aQ(makeString(["amount to receive is less than ", toString(gW)], ""))
1392 -                                         else hn
1393 -                                     let ho = invoke(aT, "burn", [hu], [AttachedPayment(bm, hu)])
1394 -                                     if ((ho == ho))
1396 +                                         then aQ(makeString(["amount to receive is less than ", toString(gZ)], ""))
1397 +                                         else hq
1398 +                                     let hr = invoke(aT, "burn", [hx], [AttachedPayment(bm, hx)])
1399 +                                     if ((hr == hr))
1395 1400                                          then {
1396 -                                             let gC = cK(hk, bW)
1397 -                                             let hp = [ScriptTransfer(eS.caller, bW, fL)]
1398 -                                             let hg = if ((fe > 0))
1399 -                                                 then [ScriptTransfer(aU, fe, fL)]
1401 +                                             let gF = cK(hn, bW)
1402 +                                             let hs = [ScriptTransfer(eV.caller, bW, fO)]
1403 +                                             let hj = if ((fh > 0))
1404 +                                                 then [ScriptTransfer(aU, fh, fO)]
1400 1405                                                  else nil
1401 -                                             let hx = {
1402 -                                                 let hr = if ((this == aU))
1406 +                                             let hA = {
1407 +                                                 let hu = if ((this == aU))
1403 1408                                                      then 0
1404 -                                                     else fe
1405 -                                                 if (fN)
1406 -                                                     then $Tuple2(-((bW + hr)), 0)
1407 -                                                     else $Tuple2(0, -((bW + hr)))
1409 +                                                     else fh
1410 +                                                 if (fQ)
1411 +                                                     then $Tuple2(-((bW + hu)), 0)
1412 +                                                     else $Tuple2(0, -((bW + hu)))
1408 1413                                                  }
1409 -                                             let eB = hx._1
1410 -                                             let eC = hx._2
1411 -                                             let hy = eA(eB, eC, 0)
1412 -                                             let gR = hy._1
1413 -                                             let er = hy._2
1414 -                                             let gS = eE(ez, er)
1415 -                                             if ((gS == gS))
1416 -                                                 then $Tuple2(((((el ++ gC) ++ hp) ++ hg) ++ gR), bW)
1414 +                                             let eE = hA._1
1415 +                                             let eF = hA._2
1416 +                                             let hB = eD(eE, eF, 0)
1417 +                                             let gU = hB._1
1418 +                                             let eu = hB._2
1419 +                                             let gV = eH(eC, eu)
1420 +                                             if ((gV == gV))
1421 +                                                 then $Tuple2(((((eo ++ gF) ++ hs) ++ hj) ++ gU), bW)
1417 1422                                                  else throw("Strict value is not equal to itself.")
1418 1423                                              }
1419 1424                                          else throw("Strict value is not equal to itself.")
1420 1425                                      }
1421 1426                                  else throw("Strict value is not equal to itself.")
1422 1427                              }
1423 1428                          else throw("Strict value is not equal to itself.")
1424 1429                      }
1425 1430                  else throw("Strict value is not equal to itself.")
1426 1431              }
1427 1432          else throw("Strict value is not equal to itself.")
1428 1433      }
1429 1434  
1430 1435  
1431 1436  
1432 - @Callable(eS)
1437 + @Callable(eV)
1433 1438  func get () = {
1434 -     let dW = eR(eS)
1435 -     let hz = dW._1
1436 -     let dB = dW._2
1437 -     let eU = dW._3
1438 -     let dj = dW._4
1439 -     let dE = dW._5
1440 -     let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1441 -     if ((ez == ez))
1439 +     let dZ = eU(eV)
1440 +     let dF = dZ._1
1441 +     let dG = dZ._2
1442 +     let eX = dZ._3
1443 +     let do = dZ._4
1444 +     let dH = dZ._5
1445 +     let gF = cP(dF, dG)
1446 +     let eC = ev(toBigInt(0), toBigInt(0), toBigInt(0))
1447 +     if ((eC == eC))
1442 1448          then {
1443 -             let hA = invoke(aT, "burn", [eU], [AttachedPayment(dj, eU)])
1444 -             if ((hA == hA))
1449 +             let hC = invoke(aT, "burn", [eX], [AttachedPayment(do, eX)])
1450 +             if ((hC == hC))
1445 1451                  then {
1446 -                     let hB = eA(-(hz), -(dB), 0)
1447 -                     let gR = hB._1
1448 -                     let er = hB._2
1449 -                     let gS = eE(ez, er)
1450 -                     if ((gS == gS))
1451 -                         then (dE ++ gR)
1452 +                     let hD = eD(-(dF), -(dG), 0)
1453 +                     let gU = hD._1
1454 +                     let eu = hD._2
1455 +                     let gV = eH(eC, eu)
1456 +                     if ((gV == gV))
1457 +                         then ((gF ++ dH) ++ gU)
1452 1458                          else throw("Strict value is not equal to itself.")
1453 1459                      }
1454 1460                  else throw("Strict value is not equal to itself.")
1455 1461              }
1456 1462          else throw("Strict value is not equal to itself.")
1457 1463      }
1458 1464  
1459 1465  
1460 1466  
1461 - @Callable(eS)
1462 - func getNoLess (hC,hD) = {
1463 -     let dW = eR(eS)
1464 -     let dA = dW._1
1465 -     let dB = dW._2
1466 -     let eU = dW._3
1467 -     let dj = dW._4
1468 -     let dE = dW._5
1469 -     if ((hC > dA))
1470 -         then throw(((("noLessThenAmtAsset failed:  " + toString(dA)) + " < ") + toString(hC)))
1471 -         else if ((hD > dB))
1472 -             then throw(((("noLessThenPriceAsset failed: " + toString(dB)) + " < ") + toString(hD)))
1467 + @Callable(eV)
1468 + func getNoLess (hE,hF) = {
1469 +     let dZ = eU(eV)
1470 +     let dF = dZ._1
1471 +     let dG = dZ._2
1472 +     let eX = dZ._3
1473 +     let do = dZ._4
1474 +     let dH = dZ._5
1475 +     if ((hE > dF))
1476 +         then throw(((("noLessThenAmtAsset failed:  " + toString(dF)) + " < ") + toString(hE)))
1477 +         else if ((hF > dG))
1478 +             then throw(((("noLessThenPriceAsset failed: " + toString(dG)) + " < ") + toString(hF)))
1473 1479              else {
1474 -                 let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1475 -                 if ((ez == ez))
1480 +                 let gF = cP(dF, dG)
1481 +                 let eC = ev(toBigInt(0), toBigInt(0), toBigInt(0))
1482 +                 if ((eC == eC))
1476 1483                      then {
1477 -                         let hA = invoke(aT, "burn", [eU], [AttachedPayment(dj, eU)])
1478 -                         if ((hA == hA))
1484 +                         let hC = invoke(aT, "burn", [eX], [AttachedPayment(do, eX)])
1485 +                         if ((hC == hC))
1479 1486                              then {
1480 -                                 let hE = eA(-(dA), -(dB), 0)
1481 -                                 let gR = hE._1
1482 -                                 let er = hE._2
1483 -                                 let gS = eE(ez, er)
1484 -                                 if ((gS == gS))
1485 -                                     then (dE ++ gR)
1487 +                                 let hG = eD(-(dF), -(dG), 0)
1488 +                                 let gU = hG._1
1489 +                                 let eu = hG._2
1490 +                                 let gV = eH(eC, eu)
1491 +                                 if ((gV == gV))
1492 +                                     then ((gF ++ dH) ++ gU)
1486 1493                                      else throw("Strict value is not equal to itself.")
1487 1494                                  }
1488 1495                              else throw("Strict value is not equal to itself.")
1489 1496                          }
1490 1497                      else throw("Strict value is not equal to itself.")
1491 1498                  }
1492 1499      }
1493 1500  
1494 1501  
1495 1502  
1496 - @Callable(eS)
1503 + @Callable(eV)
1497 1504  func unstakeAndGet (bW) = {
1498 -     let hF = if ((size(eS.payments) != 0))
1505 +     let hH = if ((size(eV.payments) != 0))
1499 1506          then throw("No payments are expected")
1500 1507          else true
1501 -     if ((hF == hF))
1508 +     if ((hH == hH))
1502 1509          then {
1503 -             let cY = ba()
1504 -             let dl = fromBase58String(cY[q])
1505 -             let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1506 -             if ((ez == ez))
1510 +             let dd = ba()
1511 +             let dq = fromBase58String(dd[q])
1512 +             let eC = ev(toBigInt(0), toBigInt(0), toBigInt(0))
1513 +             if ((eC == eC))
1507 1514                  then {
1508 -                     let hv = invoke(bs, "unstake", [toBase58String(dl), bW], nil)
1509 -                     if ((hv == hv))
1515 +                     let hy = invoke(bs, "unstake", [toBase58String(dq), bW], nil)
1516 +                     if ((hy == hy))
1510 1517                          then {
1511 -                             let dW = dh(toBase58String(eS.transactionId), toBase58String(dl), bW, eS.caller)
1512 -                             let dA = dW._1
1513 -                             let dB = dW._2
1514 -                             let do = parseIntValue(dW._9)
1515 -                             let dE = dW._10
1516 -                             let hG = if (if (aY())
1518 +                             let dZ = dm(toBase58String(eV.transactionId), toBase58String(dq), bW, eV.caller)
1519 +                             let dF = dZ._1
1520 +                             let dG = dZ._2
1521 +                             let dt = parseIntValue(dZ._9)
1522 +                             let dH = dZ._10
1523 +                             let gF = cP(dF, dG)
1524 +                             let hI = if (if (aY())
1517 1525                                  then true
1518 -                                 else (do == n))
1519 -                                 then throw(("Get operation is blocked by admin. Status = " + toString(do)))
1526 +                                 else (dt == n))
1527 +                                 then throw(("Get operation is blocked by admin. Status = " + toString(dt)))
1520 1528                                  else true
1521 -                             if ((hG == hG))
1529 +                             if ((hI == hI))
1522 1530                                  then {
1523 -                                     let hA = invoke(aT, "burn", [bW], [AttachedPayment(dl, bW)])
1524 -                                     if ((hA == hA))
1531 +                                     let hC = invoke(aT, "burn", [bW], [AttachedPayment(dq, bW)])
1532 +                                     if ((hC == hC))
1525 1533                                          then {
1526 -                                             let hH = eA(-(dA), -(dB), 0)
1527 -                                             let gR = hH._1
1528 -                                             let er = hH._2
1529 -                                             let gS = eE(ez, er)
1530 -                                             if ((gS == gS))
1531 -                                                 then (dE ++ gR)
1534 +                                             let hJ = eD(-(dF), -(dG), 0)
1535 +                                             let gU = hJ._1
1536 +                                             let eu = hJ._2
1537 +                                             let gV = eH(eC, eu)
1538 +                                             if ((gV == gV))
1539 +                                                 then ((gF ++ dH) ++ gU)
1532 1540                                                  else throw("Strict value is not equal to itself.")
1533 1541                                              }
1534 1542                                          else throw("Strict value is not equal to itself.")
1535 1543                                      }
1536 1544                                  else throw("Strict value is not equal to itself.")
1537 1545                              }
1538 1546                          else throw("Strict value is not equal to itself.")
1539 1547                      }
1540 1548                  else throw("Strict value is not equal to itself.")
1541 1549              }
1542 1550          else throw("Strict value is not equal to itself.")
1543 1551      }
1544 1552  
1545 1553  
1546 1554  
1547 - @Callable(eS)
1548 - func unstakeAndGetNoLess (hu,hI,hD) = {
1549 -     let hl = if (aY())
1555 + @Callable(eV)
1556 + func unstakeAndGetNoLess (hx,hK,hF) = {
1557 +     let ho = if (aY())
1550 1558          then true
1551 1559          else (bl == n)
1552 -     let fM = [if (!(hl))
1560 +     let fP = [if (!(ho))
1553 1561          then true
1554 -         else throw("get operation is blocked by admin"), if ((size(eS.payments) == 0))
1562 +         else throw("get operation is blocked by admin"), if ((size(eV.payments) == 0))
1555 1563          then true
1556 1564          else throw("no payments are expected")]
1557 -     if ((fM == fM))
1565 +     if ((fP == fP))
1558 1566          then {
1559 -             let ez = es(toBigInt(0), toBigInt(0), toBigInt(0))
1560 -             if ((ez == ez))
1567 +             let eC = ev(toBigInt(0), toBigInt(0), toBigInt(0))
1568 +             if ((eC == eC))
1561 1569                  then {
1562 -                     let hv = invoke(bs, "unstake", [toBase58String(bm), hu], nil)
1563 -                     if ((hv == hv))
1570 +                     let hy = invoke(bs, "unstake", [toBase58String(bm), hx], nil)
1571 +                     if ((hy == hy))
1564 1572                          then {
1565 -                             let dW = dh(toBase58String(eS.transactionId), toBase58String(bm), hu, eS.caller)
1566 -                             let dA = dW._1
1567 -                             let dB = dW._2
1568 -                             let dE = dW._10
1569 -                             let hJ = [if ((dA >= hI))
1573 +                             let dZ = dm(toBase58String(eV.transactionId), toBase58String(bm), hx, eV.caller)
1574 +                             let dF = dZ._1
1575 +                             let dG = dZ._2
1576 +                             let dH = dZ._10
1577 +                             let gF = cP(dF, dG)
1578 +                             let hL = [if ((dF >= hK))
1570 1579                                  then true
1571 -                                 else throw(makeString(["amount asset amount to receive is less than ", toString(hI)], "")), if ((dB >= hD))
1580 +                                 else throw(makeString(["amount asset amount to receive is less than ", toString(hK)], "")), if ((dG >= hF))
1572 1581                                  then true
1573 -                                 else throw(makeString(["price asset amount to receive is less than ", toString(hD)], ""))]
1574 -                             if ((hJ == hJ))
1582 +                                 else throw(makeString(["price asset amount to receive is less than ", toString(hF)], ""))]
1583 +                             if ((hL == hL))
1575 1584                                  then {
1576 -                                     let hA = invoke(aT, "burn", [hu], [AttachedPayment(bm, hu)])
1577 -                                     if ((hA == hA))
1585 +                                     let hC = invoke(aT, "burn", [hx], [AttachedPayment(bm, hx)])
1586 +                                     if ((hC == hC))
1578 1587                                          then {
1579 -                                             let hK = eA(-(dA), -(dB), 0)
1580 -                                             let gR = hK._1
1581 -                                             let er = hK._2
1582 -                                             let gS = eE(ez, er)
1583 -                                             if ((gS == gS))
1584 -                                                 then (dE ++ gR)
1588 +                                             let hM = eD(-(dF), -(dG), 0)
1589 +                                             let gU = hM._1
1590 +                                             let eu = hM._2
1591 +                                             let gV = eH(eC, eu)
1592 +                                             if ((gV == gV))
1593 +                                                 then ((gF ++ dH) ++ gU)
1585 1594                                                  else throw("Strict value is not equal to itself.")
1586 1595                                              }
1587 1596                                          else throw("Strict value is not equal to itself.")
1588 1597                                      }
1589 1598                                  else throw("Strict value is not equal to itself.")
1590 1599                              }
1591 1600                          else throw("Strict value is not equal to itself.")
1592 1601                      }
1593 1602                  else throw("Strict value is not equal to itself.")
1594 1603              }
1595 1604          else throw("Strict value is not equal to itself.")
1596 1605      }
1597 1606  
1598 1607  
1599 1608  
1600 - @Callable(eS)
1601 - func activate (hL,hM) = if ((toString(eS.caller) != toString(aT)))
1609 + @Callable(eV)
1610 + func activate (hN,hO) = if ((toString(eV.caller) != toString(aT)))
1602 1611      then throw("permissions denied")
1603 -     else $Tuple2([StringEntry(ae(), hL), StringEntry(af(), hM)], "success")
1612 +     else $Tuple2([StringEntry(ae(), hN), StringEntry(af(), hO)], "success")
1604 1613  
1605 1614  
1606 1615  
1607 - @Callable(eS)
1616 + @Callable(eV)
1608 1617  func refreshKLp () = {
1609 -     let hN = valueOrElse(getInteger(ak), 0)
1610 -     let hO = if (((height - hN) >= an))
1618 +     let hP = valueOrElse(getInteger(ak), 0)
1619 +     let hQ = if (((height - hP) >= an))
1611 1620          then unit
1612 1621          else aQ(makeString([toString(an), " blocks have not passed since the previous call"], ""))
1613 -     if ((hO == hO))
1622 +     if ((hQ == hQ))
1614 1623          then {
1615 -             let eL = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
1616 -             let hP = eA(0, 0, 0)
1617 -             let hQ = hP._1
1618 -             let er = hP._2
1619 -             let eD = if ((eL != er))
1620 -                 then hQ
1624 +             let eO = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
1625 +             let hR = eD(0, 0, 0)
1626 +             let hS = hR._1
1627 +             let eu = hR._2
1628 +             let eG = if ((eO != eu))
1629 +                 then hS
1621 1630                  else aQ("nothing to refresh")
1622 -             $Tuple2(eD, toString(er))
1631 +             $Tuple2(eG, toString(eu))
1623 1632              }
1624 1633          else throw("Strict value is not equal to itself.")
1625 1634      }
1626 1635  
1627 1636  
1628 1637  
1629 - @Callable(eS)
1638 + @Callable(eV)
1630 1639  func getPoolConfigWrapperREADONLY () = $Tuple2(nil, ba())
1631 1640  
1632 1641  
1633 1642  
1634 - @Callable(eS)
1643 + @Callable(eV)
1635 1644  func getAccBalanceWrapperREADONLY (ap) = $Tuple2(nil, bJ(ap))
1636 1645  
1637 1646  
1638 1647  
1639 - @Callable(eS)
1640 - func calcPricesWrapperREADONLY (cS,cT,cX) = {
1641 -     let dg = cW(cS, cT, cX)
1642 -     $Tuple2(nil, [toString(dg[0]), toString(dg[1]), toString(dg[2])])
1648 + @Callable(eV)
1649 + func calcPricesWrapperREADONLY (cX,cY,dc) = {
1650 +     let dl = db(cX, cY, dc)
1651 +     $Tuple2(nil, [toString(dl[0]), toString(dl[1]), toString(dl[2])])
1643 1652      }
1644 1653  
1645 1654  
1646 1655  
1647 - @Callable(eS)
1656 + @Callable(eV)
1648 1657  func toX18WrapperREADONLY (E,F) = $Tuple2(nil, toString(D(E, F)))
1649 1658  
1650 1659  
1651 1660  
1652 - @Callable(eS)
1661 + @Callable(eV)
1653 1662  func fromX18WrapperREADONLY (I,J) = $Tuple2(nil, H(parseBigIntValue(I), J))
1654 1663  
1655 1664  
1656 1665  
1657 - @Callable(eS)
1666 + @Callable(eV)
1658 1667  func calcPriceBigIntWrapperREADONLY (bN,bO) = $Tuple2(nil, toString(bM(parseBigIntValue(bN), parseBigIntValue(bO))))
1659 1668  
1660 1669  
1661 1670  
1662 - @Callable(eS)
1663 - func estimatePutOperationWrapperREADONLY (di,dG,dH,dI,dJ,dK,ab,dL,dM) = $Tuple2(nil, dF(di, dG, dH, dI, dJ, dK, ab, dL, dM))
1671 + @Callable(eV)
1672 + func estimatePutOperationWrapperREADONLY (dn,dJ,dK,dL,dM,dN,ab,dO,dP) = $Tuple2(nil, dI(dn, dJ, dK, dL, dM, dN, ab, dO, dP))
1664 1673  
1665 1674  
1666 1675  
1667 - @Callable(eS)
1668 - func estimateGetOperationWrapperREADONLY (di,dj,dk,ab) = {
1669 -     let dW = dh(di, dj, dk, addressFromStringValue(ab))
1670 -     $Tuple2(nil, $Tuple10(dW._1, dW._2, dW._3, dW._4, dW._5, dW._6, dW._7, toString(dW._8), dW._9, dW._10))
1676 + @Callable(eV)
1677 + func estimateGetOperationWrapperREADONLY (dn,do,dp,ab) = {
1678 +     let dZ = dm(dn, do, dp, addressFromStringValue(ab))
1679 +     $Tuple2(nil, $Tuple10(dZ._1, dZ._2, dZ._3, dZ._4, dZ._5, dZ._6, dZ._7, toString(dZ._8), dZ._9, dZ._10))
1671 1680      }
1672 1681  
1673 1682  
1674 1683  
1675 - @Callable(eS)
1684 + @Callable(eV)
1676 1685  func statsREADONLY () = {
1677 -     let cY = ba()
1678 -     let dl = fromBase58String(cY[q])
1679 -     let hR = cY[r]
1680 -     let hS = cY[s]
1681 -     let dP = cY[v]
1682 -     let dQ = cY[w]
1683 -     let cZ = parseIntValue(cY[t])
1684 -     let da = parseIntValue(cY[u])
1685 -     let hT = valueOrErrorMessage(assetInfo(dl), (("Asset " + toBase58String(dl)) + " doesn't exist")).quantity
1686 -     let hU = bJ(hR)
1687 -     let hV = bJ(hS)
1688 -     let hW = if ((hT == 0))
1686 +     let dd = ba()
1687 +     let dq = fromBase58String(dd[q])
1688 +     let hT = dd[r]
1689 +     let hU = dd[s]
1690 +     let dS = dd[v]
1691 +     let dT = dd[w]
1692 +     let de = parseIntValue(dd[t])
1693 +     let df = parseIntValue(dd[u])
1694 +     let hV = valueOrErrorMessage(assetInfo(dq), (("Asset " + toBase58String(dq)) + " doesn't exist")).quantity
1695 +     let hW = bJ(hT)
1696 +     let hX = bJ(hU)
1697 +     let hY = if ((hV == 0))
1689 1698          then [e, e, e]
1690 -         else cW(hU, hV, hT)
1691 -     let dv = 0
1692 -     let hX = H(hW[1], b)
1693 -     let hY = H(hW[2], b)
1694 -     let hZ = value(getInteger(aT, aD(toString(this))))
1695 -     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(hU), toString(hV), toString(hT), toString(dv), toString(hX), toString(hY), toString(hZ)], j))
1699 +         else db(hW, hX, hV)
1700 +     let dA = 0
1701 +     let hZ = H(hY[1], b)
1702 +     let ia = H(hY[2], b)
1703 +     let ib = value(getInteger(aT, aD(toString(this))))
1704 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(hW), toString(hX), toString(hV), toString(dA), toString(hZ), toString(ia), toString(ib)], j))
1696 1705      }
1697 1706  
1698 1707  
1699 1708  
1700 - @Callable(eS)
1701 - func evaluatePutByAmountAssetREADONLY (dH) = {
1702 -     let cY = ba()
1703 -     let dl = fromBase58String(cY[q])
1704 -     let dN = cY[r]
1705 -     let dm = fromBase58String(dN)
1706 -     let dO = cY[s]
1707 -     let dn = fromBase58String(dO)
1708 -     let cZ = parseIntValue(cY[t])
1709 -     let da = parseIntValue(cY[u])
1710 -     let do = cY[p]
1711 -     let hT = valueOrErrorMessage(assetInfo(dl), (("Asset " + toBase58String(dl)) + " doesn't exist")).quantity
1712 -     let hU = bJ(dN)
1713 -     let hV = bJ(dO)
1714 -     let cU = D(hU, cZ)
1715 -     let cV = D(hV, da)
1716 -     let du = if ((hT == 0))
1709 + @Callable(eV)
1710 + func evaluatePutByAmountAssetREADONLY (dK) = {
1711 +     let dd = ba()
1712 +     let dq = fromBase58String(dd[q])
1713 +     let dQ = dd[r]
1714 +     let dr = fromBase58String(dQ)
1715 +     let dR = dd[s]
1716 +     let ds = fromBase58String(dR)
1717 +     let de = parseIntValue(dd[t])
1718 +     let df = parseIntValue(dd[u])
1719 +     let dt = dd[p]
1720 +     let hV = valueOrErrorMessage(assetInfo(dq), (("Asset " + toBase58String(dq)) + " doesn't exist")).quantity
1721 +     let hW = bJ(dQ)
1722 +     let hX = bJ(dR)
1723 +     let cZ = D(hW, de)
1724 +     let da = D(hX, df)
1725 +     let dz = if ((hV == 0))
1717 1726          then e
1718 -         else bM(cV, cU)
1719 -     let dT = D(dH, cZ)
1720 -     let dU = fraction(dT, du, d)
1721 -     let dJ = H(dU, da)
1722 -     let eY = dF("", 500000, dH, dm, dJ, dn, "", true, false)
1723 -     let ee = eY._1
1724 -     let ia = eY._3
1725 -     let dq = eY._4
1726 -     let ds = eY._5
1727 -     let dp = eY._6
1728 -     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(ee), toString(H(du, b)), toString(dq), toString(ds), toString(dp), do, toString(dH), toString(dJ)], j))
1727 +         else bM(da, cZ)
1728 +     let dW = D(dK, de)
1729 +     let dX = fraction(dW, dz, d)
1730 +     let dM = H(dX, df)
1731 +     let fb = dI("", 500000, dK, dr, dM, ds, "", true, false)
1732 +     let eh = fb._1
1733 +     let ic = fb._3
1734 +     let dv = fb._4
1735 +     let dx = fb._5
1736 +     let du = fb._6
1737 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(eh), toString(H(dz, b)), toString(dv), toString(dx), toString(du), dt, toString(dK), toString(dM)], j))
1729 1738      }
1730 1739  
1731 1740  
1732 1741  
1733 - @Callable(eS)
1734 - func evaluatePutByPriceAssetREADONLY (dJ) = {
1735 -     let cY = ba()
1736 -     let dl = fromBase58String(cY[q])
1737 -     let dN = cY[r]
1738 -     let dm = fromBase58String(dN)
1739 -     let dO = cY[s]
1740 -     let dn = fromBase58String(dO)
1741 -     let cZ = parseIntValue(cY[t])
1742 -     let da = parseIntValue(cY[u])
1743 -     let do = cY[p]
1744 -     let hT = valueOrErrorMessage(assetInfo(dl), (("Asset " + toBase58String(dl)) + " doesn't exist")).quantity
1745 -     let ib = bJ(dN)
1746 -     let ic = bJ(dO)
1747 -     let id = D(ib, cZ)
1748 -     let ie = D(ic, da)
1749 -     let du = if ((hT == 0))
1742 + @Callable(eV)
1743 + func evaluatePutByPriceAssetREADONLY (dM) = {
1744 +     let dd = ba()
1745 +     let dq = fromBase58String(dd[q])
1746 +     let dQ = dd[r]
1747 +     let dr = fromBase58String(dQ)
1748 +     let dR = dd[s]
1749 +     let ds = fromBase58String(dR)
1750 +     let de = parseIntValue(dd[t])
1751 +     let df = parseIntValue(dd[u])
1752 +     let dt = dd[p]
1753 +     let hV = valueOrErrorMessage(assetInfo(dq), (("Asset " + toBase58String(dq)) + " doesn't exist")).quantity
1754 +     let id = bJ(dQ)
1755 +     let ie = bJ(dR)
1756 +     let if = D(id, de)
1757 +     let ig = D(ie, df)
1758 +     let dz = if ((hV == 0))
1750 1759          then e
1751 -         else bM(ie, id)
1752 -     let dU = D(dJ, da)
1753 -     let dT = fraction(dU, d, du)
1754 -     let dH = H(dT, cZ)
1755 -     let eY = dF("", 500000, dH, dm, dJ, dn, "", true, false)
1756 -     let ee = eY._1
1757 -     let ia = eY._3
1758 -     let dq = eY._4
1759 -     let ds = eY._5
1760 -     let dp = eY._6
1761 -     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(ee), toString(H(du, b)), toString(dq), toString(ds), toString(dp), do, toString(dH), toString(dJ)], j))
1760 +         else bM(ig, if)
1761 +     let dX = D(dM, df)
1762 +     let dW = fraction(dX, d, dz)
1763 +     let dK = H(dW, de)
1764 +     let fb = dI("", 500000, dK, dr, dM, ds, "", true, false)
1765 +     let eh = fb._1
1766 +     let ic = fb._3
1767 +     let dv = fb._4
1768 +     let dx = fb._5
1769 +     let du = fb._6
1770 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(eh), toString(H(dz, b)), toString(dv), toString(dx), toString(du), dt, toString(dK), toString(dM)], j))
1762 1771      }
1763 1772  
1764 1773  
1765 1774  
1766 - @Callable(eS)
1767 - func evaluateGetREADONLY (if,ig) = {
1768 -     let dW = dh("", if, ig, this)
1769 -     let dA = dW._1
1770 -     let dB = dW._2
1771 -     let dq = dW._5
1772 -     let ds = dW._6
1773 -     let dp = dW._7
1774 -     let dv = dW._8
1775 -     let do = parseIntValue(dW._9)
1776 -     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(dA), toString(dB), toString(dq), toString(ds), toString(dp), toString(dv), toString(do)], j))
1775 + @Callable(eV)
1776 + func evaluateGetREADONLY (ih,ii) = {
1777 +     let dZ = dm("", ih, ii, this)
1778 +     let dF = dZ._1
1779 +     let dG = dZ._2
1780 +     let dv = dZ._5
1781 +     let dx = dZ._6
1782 +     let du = dZ._7
1783 +     let dA = dZ._8
1784 +     let dt = parseIntValue(dZ._9)
1785 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(dF), toString(dG), toString(dv), toString(dx), toString(du), toString(dA), toString(dt)], j))
1777 1786      }
1778 1787  
1779 1788  
1780 - @Verifier(ih)
1781 - func ii () = {
1782 -     let ij = {
1783 -         let bT = ge()
1789 + @Verifier(ij)
1790 + func ik () = {
1791 +     let il = {
1792 +         let bT = gh()
1784 1793          if ($isInstanceOf(bT, "ByteVector"))
1785 1794              then {
1786 -                 let gi = bT
1787 -                 gi
1795 +                 let gl = bT
1796 +                 gl
1788 1797                  }
1789 1798              else if ($isInstanceOf(bT, "Unit"))
1790 -                 then ih.senderPublicKey
1799 +                 then ij.senderPublicKey
1791 1800                  else throw("Match error")
1792 1801          }
1793 -     let bT = ih
1802 +     let bT = ij
1794 1803      if ($isInstanceOf(bT, "Order"))
1795 1804          then {
1796 -             let eH = bT
1797 -             let ik = aZ()
1798 -             let il = eG(eH)
1799 -             let aI = il._1
1800 -             let aJ = il._2
1801 -             let aK = sigVerify(eH.bodyBytes, eH.proofs[0], eH.senderPublicKey)
1802 -             let aL = sigVerify(eH.bodyBytes, eH.proofs[1], ik)
1805 +             let eK = bT
1806 +             let im = aZ()
1807 +             let in = eJ(eK)
1808 +             let aI = in._1
1809 +             let aJ = in._2
1810 +             let aK = sigVerify(eK.bodyBytes, eK.proofs[0], eK.senderPublicKey)
1811 +             let aL = sigVerify(eK.bodyBytes, eK.proofs[1], im)
1803 1812              if (if (if (aI)
1804 1813                  then aK
1805 1814                  else false)
1806 1815                  then aL
1807 1816                  else false)
1808 1817                  then true
1809 1818                  else aH(aI, aJ, aK, aL)
1810 1819              }
1811 1820          else if ($isInstanceOf(bT, "SetScriptTransaction"))
1812 1821              then {
1813 -                 let gf = bT
1814 -                 if (sigVerify(ih.bodyBytes, ih.proofs[0], ij))
1822 +                 let gi = bT
1823 +                 if (sigVerify(ij.bodyBytes, ij.proofs[0], il))
1815 1824                      then true
1816 1825                      else {
1817 -                         let im = blake2b256(value(gf.script))
1818 -                         let in = fromBase64String(value(getString(aT, aF())))
1819 -                         let io = scriptHash(this)
1820 -                         if ((in == im))
1821 -                             then (io != im)
1826 +                         let io = blake2b256(value(gi.script))
1827 +                         let ip = fromBase64String(value(getString(aT, aF())))
1828 +                         let iq = scriptHash(this)
1829 +                         if ((ip == io))
1830 +                             then (iq != io)
1822 1831                              else false
1823 1832                          }
1824 1833                  }
1825 -             else sigVerify(ih.bodyBytes, ih.proofs[0], ij)
1834 +             else sigVerify(ij.bodyBytes, ij.proofs[0], il)
1826 1835      }
1827 1836

Old	New		Differences
468	468		}
469	469
470	470
471		-	func cP (cQ,cR~~,cS,cT~~) = {
472		-	let cU = D(cS, cQ)
473		-	let cV = D(cT, cR)
474		-	bM(~~cV, cU~~)
	471	+	func cP (cQ,cR) = {
	472	+	let cS = cK(aM(this, ae()), cQ)
	473	+	let cT = cK(aM(this, af()), cR)
	474	+	(cS ++ cT)
475	475		}
476	476
477	477
478		-	func cW (cS,cT,cX) = {
479		-	let cY = ba()
480		-	let cZ = parseIntValue(cY[t])
481		-	let da = parseIntValue(cY[u])
482		-	let db = cP(cZ, da, cS, cT)
483		-	let bO = D(cS, cZ)
484		-	let bN = D(cT, da)
485		-	let dc = D(cX, b)
486		-	let dd = bM(bO, dc)
487		-	let de = bM(bN, dc)
488		-	[db, dd, de]
	478	+	func cU (cV,cW,cX,cY) = {
	479	+	let cZ = D(cX, cV)
	480	+	let da = D(cY, cW)
	481	+	bM(da, cZ)
489	482		}
490	483
491	484
492		-	func df (cS,cT,cX) = {
493		-	let dg = cW(cS, cT, cX)
494		-	[H(dg[0], b), H(dg[1], b), H(dg[2], b)]
	485	+	func db (cX,cY,dc) = {
	486	+	let dd = ba()
	487	+	let de = parseIntValue(dd[t])
	488	+	let df = parseIntValue(dd[u])
	489	+	let dg = cU(de, df, cX, cY)
	490	+	let bO = D(cX, de)
	491	+	let bN = D(cY, df)
	492	+	let dh = D(dc, b)
	493	+	let di = bM(bO, dh)
	494	+	let dj = bM(bN, dh)
	495	+	[dg, di, dj]
495	496		}
496	497
497	498
498		-	func dh (di,dj,dk,ab) = {
499		-	let cY = ba()
500		-	let dl = cY[q]
501		-	let dm = cY[r]
502		-	let dn = cY[s]
503		-	let cQ = parseIntValue(cY[t])
504		-	let cR = parseIntValue(cY[u])
505		-	let do = cY[p]
506		-	let dp = valueOrErrorMessage(assetInfo(fromBase58String(dl)), (("Asset " + dl) + " doesn't exist")).quantity
507		-	if ((dl != dj))
	499	+	func dk (cX,cY,dc) = {
	500	+	let dl = db(cX, cY, dc)
	501	+	[H(dl[0], b), H(dl[1], b), H(dl[2], b)]
	502	+	}
	503	+
	504	+
	505	+	func dm (dn,do,dp,ab) = {
	506	+	let dd = ba()
	507	+	let dq = dd[q]
	508	+	let dr = dd[r]
	509	+	let ds = dd[s]
	510	+	let cV = parseIntValue(dd[t])
	511	+	let cW = parseIntValue(dd[u])
	512	+	let dt = dd[p]
	513	+	let du = valueOrErrorMessage(assetInfo(fromBase58String(dq)), (("Asset " + dq) + " doesn't exist")).quantity
	514	+	if ((dq != do))
508	515		then throw("Invalid asset passed.")
509	516		else {
510		-	let dq = bJ(dm)
511		-	let dr = D(dq, cQ)
512		-	let ds = bJ(dn)
513		-	let dt = D(ds, cR)
514		-	let du = bM(dt, dr)
515		-	let dv = H(du, b)
516		-	let dw = D(dk, b)
517		-	let dx = D(dp, b)
518		-	let dy = fraction(dr, dw, dx)
519		-	let dz = fraction(dt, dw, dx)
520		-	let dA = K(dy, cQ, FLOOR)
521		-	let dB = K(dz, cR, FLOOR)
522		-	let dC = cK(dm, dA)
523		-	let dD = cK(dn, dB)
524		-	let dE = if ((di == ""))
	517	+	let dv = bJ(dr)
	518	+	let dw = D(dv, cV)
	519	+	let dx = bJ(ds)
	520	+	let dy = D(dx, cW)
	521	+	let dz = bM(dy, dw)
	522	+	let dA = H(dz, b)
	523	+	let dB = D(dp, b)
	524	+	let dC = D(du, b)
	525	+	let dD = fraction(dw, dB, dC)
	526	+	let dE = fraction(dy, dB, dC)
	527	+	let dF = K(dD, cV, FLOOR)
	528	+	let dG = K(dE, cW, FLOOR)
	529	+	let dH = if ((dn == ""))
525	530		then nil
526		-	else ~~((dC ++ dD) ++~~ [ScriptTransfer(ab, dA, if ((dm == "WAVES"))
	531	+	else [ScriptTransfer(ab, dF, if ((dr == "WAVES"))
527	532		then unit
528		-	else fromBase58String(dm)), ScriptTransfer(ab, dB, if ((dn == "WAVES"))
	533	+	else fromBase58String(dr)), ScriptTransfer(ab, dG, if ((ds == "WAVES"))
529	534		then unit
530		-	else fromBase58String(dn)), StringEntry(ad(toString(ab), di), bF(dA, dB, dk, dv, height, lastBlock.timestamp)), IntegerEntry(W(), dv), IntegerEntry(X(height, lastBlock.timestamp), dv)])
531		-	$Tuple10(dA, dB, ~~dm, dn, dq~~, ds, dp, du, do, dE)
	535	+	else fromBase58String(ds)), StringEntry(ad(toString(ab), dn), bF(dF, dG, dp, dA, height, lastBlock.timestamp)), IntegerEntry(W(), dA), IntegerEntry(X(height, lastBlock.timestamp), dA)]
	536	+	$Tuple10(dF, dG, dr, ds, dv, dx, du, dz, dt, dH)
532	537		}
533	538		}
534	539
535	540
536		-	func dF (~~di,dG,dH,dI~~,dJ,dK,~~ab,~~dL,dM) = {
537		-	let cY = ba()
538		-	let dl = fromBase58String(cY[q])
539		-	let dN = cY[r]
540		-	let dO = cY[s]
541		-	let dP = cY[v]
542		-	let dQ = cY[w]
543		-	let cZ = parseIntValue(cY[t])
544		-	let da = parseIntValue(cY[u])
545		-	let do = cY[p]
546		-	let dp = valueOrErrorMessage(assetInfo(dl), (("Asset " + toBase58String(dl)) + " doesn't exist")).quantity
547		-	let dR = toBase58String(valueOrElse(dI, fromBase58String("WAVES")))
548		-	let dS = toBase58String(valueOrElse(dK, fromBase58String("WAVES")))
549		-	if (if ((dN != dR))
	541	+	func dI (dn,dJ,dK,dL,dM,dN,ab,dO,dP) = {
	542	+	let dd = ba()
	543	+	let dq = fromBase58String(dd[q])
	544	+	let dQ = dd[r]
	545	+	let dR = dd[s]
	546	+	let dS = dd[v]
	547	+	let dT = dd[w]
	548	+	let de = parseIntValue(dd[t])
	549	+	let df = parseIntValue(dd[u])
	550	+	let dt = dd[p]
	551	+	let du = valueOrErrorMessage(assetInfo(dq), (("Asset " + toBase58String(dq)) + " doesn't exist")).quantity
	552	+	let dU = toBase58String(valueOrElse(dL, fromBase58String("WAVES")))
	553	+	let dV = toBase58String(valueOrElse(dN, fromBase58String("WAVES")))
	554	+	if (if ((dQ != dU))
550	555		then true
551		-	else (dO != dS))
	556	+	else (dR != dV))
552	557		then throw("Invalid amt or price asset passed.")
553	558		else {
554		-	let dq = if (dL)
555		-	then bJ(dN)
556		-	else (bJ(dN) - dH)
557		-	let ds = if (dL)
558		-	then bJ(dO)
559		-	else (bJ(dO) - dJ)
560		-	let dT = D(dH, cZ)
561		-	let dU = D(dJ, da)
562		-	let dV = bM(dU, dT)
563		-	let dr = D(dq, cZ)
564		-	let dt = D(ds, da)
565		-	let dW = if ((dp == 0))
	559	+	let dv = if (dO)
	560	+	then bJ(dQ)
	561	+	else (bJ(dQ) - dK)
	562	+	let dx = if (dO)
	563	+	then bJ(dR)
	564	+	else (bJ(dR) - dM)
	565	+	let dW = D(dK, de)
	566	+	let dX = D(dM, df)
	567	+	let dY = bM(dX, dW)
	568	+	let dw = D(dv, de)
	569	+	let dy = D(dx, df)
	570	+	let dZ = if ((du == 0))
566	571		then {
567		-	let du = e
568		-	let dX = e
569		-	let dc = pow((dT * dU), 0, toBigInt(5), 1, 0, DOWN)
570		-	$Tuple5(H(dc, b), H(dT, cZ), H(dU, da), bM((dt + dU), (dr + dT)), dX)
	572	+	let dz = e
	573	+	let ea = e
	574	+	let dh = pow((dW * dX), 0, toBigInt(5), 1, 0, DOWN)
	575	+	$Tuple5(H(dh, b), H(dW, de), H(dX, df), bM((dy + dX), (dw + dW)), ea)
571	576		}
572	577		else {
573		-	let du = bM(dt, dr)
574		-	let dX = fraction(R((~~du - dV~~)), d, du)
575		-	let dY = D(dG, b)
576		-	if (if ((du != e))
577		-	then (dX > dY)
	578	+	let dz = bM(dy, dw)
	579	+	let ea = fraction(R((dz - dY)), d, dz)
	580	+	let eb = D(dJ, b)
	581	+	if (if ((dz != e))
	582	+	then (ea > eb)
578	583		else false)
579		-	then throw(((("Price slippage " + toString(dX)) + " exceeded the passed limit of ") + toString(dY)))
	584	+	then throw(((("Price slippage " + toString(ea)) + " exceeded the passed limit of ") + toString(eb)))
580	585		else {
581		-	let dx = D(dp, b)
582		-	let dZ = fraction(dT, bP(dt, dr, CEILING), d, CEILING)
583		-	let ea = fraction(dU, d, bP(dt, dr, FLOOR), CEILING)
584		-	let eb = if ((dZ > dU))
585		-	then $Tuple2(ea, dU)
586		-	else $Tuple2(dT, dZ)
587		-	let ec = eb._1
588		-	let ed = eb._2
589		-	let dc = fraction(dx, ed, dt, FLOOR)
590		-	$Tuple5(K(dc, b, FLOOR), K(ec, cZ, CEILING), K(ed, da, CEILING), du, dX)
	586	+	let dC = D(du, b)
	587	+	let ec = fraction(dW, bP(dy, dw, CEILING), d, CEILING)
	588	+	let ed = fraction(dX, d, bP(dy, dw, FLOOR), CEILING)
	589	+	let ee = if ((ec > dX))
	590	+	then $Tuple2(ed, dX)
	591	+	else $Tuple2(dW, ec)
	592	+	let ef = ee._1
	593	+	let eg = ee._2
	594	+	let dh = fraction(dC, eg, dy, FLOOR)
	595	+	$Tuple5(K(dh, b, FLOOR), K(ef, de, CEILING), K(eg, df, CEILING), dz, ea)
591	596		}
592	597		}
593		-	let ee = dW._1
594		-	let ef = dW._2
595		-	let eg = dW._3
596		-	let dv = H(dW._4, b)
597		-	let eh = H(dW._5, b)
598		-	if ((0 >= ee))
	598	+	let eh = dZ._1
	599	+	let ei = dZ._2
	600	+	let ej = dZ._3
	601	+	let dA = H(dZ._4, b)
	602	+	let ek = H(dZ._5, b)
	603	+	if ((0 >= eh))
599	604		then throw("Invalid calculations. LP calculated is less than zero.")
600	605		else {
601		-	let ei = if (!(dM))
	606	+	let el = if (!(dP))
602	607		then 0
603		-	else ee
604		-	let ej = (~~dH - ef~~)
605		-	let ek = (~~dJ - eg~~)
606		-	let el = [IntegerEntry(W(), dv), IntegerEntry(X(height, lastBlock.timestamp), dv), StringEntry(aa(ab, di), bu(~~ef, eg,~~ ei, dv, dG, eh, height, lastBlock.timestamp, ej, ek))]
607		-	$Tuple13(ee, ei, dv, dq, ds, dp, dl, do, el, ~~ej, ek, dI, dK~~)
	608	+	else eh
	609	+	let em = (dK - ei)
	610	+	let en = (dM - ej)
	611	+	let eo = [IntegerEntry(W(), dA), IntegerEntry(X(height, lastBlock.timestamp), dA), StringEntry(aa(ab, dn), bu(ei, ej, el, dA, dJ, ek, height, lastBlock.timestamp, em, en))]
	612	+	$Tuple13(eh, el, dA, dv, dx, du, dq, dt, eo, em, en, dL, dN)
608	613		}
609	614		}
610	615		}
611	616
612	617
613		-	func em (en,eo,dp) = {
614		-	let ep = G(en, toBigInt(bp))
615		-	let eq = G(eo, toBigInt(bq))
616		-	let er = fraction(pow((ep * eq), 0, toBigInt(5), 1, 18, DOWN), g, dp)
617		-	if ((dp == f))
	618	+	func ep (eq,er,du) = {
	619	+	let es = G(eq, toBigInt(bp))
	620	+	let et = G(er, toBigInt(bq))
	621	+	let eu = fraction(pow((es * et), 0, toBigInt(5), 1, 18, DOWN), g, du)
	622	+	if ((du == f))
618	623		then f
619		-	else er
	624	+	else eu
620	625		}
621	626
622	627
623		-	func es (et,eu,ev) = {
624		-	let ew = (toBigInt(bJ(bf(bn))) - et)
625		-	let ex = (toBigInt(bJ(bf(bo))) - eu)
626		-	let ey = (toBigInt(value(assetInfo(bm)).quantity) - ev)
627		-	let ez = em(ew, ex, ey)
628		-	ez
	628	+	func ev (ew,ex,ey) = {
	629	+	let ez = (toBigInt(bJ(bf(bn))) - ew)
	630	+	let eA = (toBigInt(bJ(bf(bo))) - ex)
	631	+	let eB = (toBigInt(value(assetInfo(bm)).quantity) - ey)
	632	+	let eC = ep(ez, eA, eB)
	633	+	eC
629	634		}
630	635
631	636
632		-	func eA (eB,eC,ev) = {
633		-	let ew = (bJ(bf(bn)) + eB)
634		-	let ex = (bJ(bf(bo)) + eC)
635		-	let ey = (value(assetInfo(bm)).quantity + ev)
636		-	let er = em(toBigInt(ew), toBigInt(ex), toBigInt(ey))
637		-	let eD = [IntegerEntry(ak, height), StringEntry(aj, toString(er))]
638		-	$Tuple2(eD, er)
	637	+	func eD (eE,eF,ey) = {
	638	+	let ez = (bJ(bf(bn)) + eE)
	639	+	let eA = (bJ(bf(bo)) + eF)
	640	+	let eB = (value(assetInfo(bm)).quantity + ey)
	641	+	let eu = ep(toBigInt(ez), toBigInt(eA), toBigInt(eB))
	642	+	let eG = [IntegerEntry(ak, height), StringEntry(aj, toString(eu))]
	643	+	$Tuple2(eG, eu)
639	644		}
640	645
641	646
642		-	func eE (eF,er) = if ((er >= eF))
	647	+	func eH (eI,eu) = if ((eu >= eI))
643	648		then true
644		-	else aQ(makeString(["updated KLp lower than current KLp", toString(eF), toString(er)], " "))
	649	+	else aQ(makeString(["updated KLp lower than current KLp", toString(eI), toString(eu)], " "))
645	650
646	651
647		-	func eG (eH) = {
648		-	let ew = bJ(bf(bn))
649		-	let ex = bJ(bf(bo))
650		-	let eI = eH.amount
651		-	let eJ = fraction(eH.amount, eH.price, b, FLOOR)
652		-	let eK = if ((eH.orderType == Buy))
653		-	then $Tuple2(eI, -(eJ))
654		-	else $Tuple2(-(eI), eJ)
655		-	let eB = eK._1
656		-	let eC = eK._2
	652	+	func eJ (eK) = {
	653	+	let ez = bJ(bf(bn))
	654	+	let eA = bJ(bf(bo))
	655	+	let eL = eK.amount
	656	+	let eM = fraction(eK.amount, eK.price, b, FLOOR)
	657	+	let eN = if ((eK.orderType == Buy))
	658	+	then $Tuple2(eL, -(eM))
	659	+	else $Tuple2(-(eL), eM)
	660	+	let eE = eN._1
	661	+	let eF = eN._2
657	662		if (if (if (aY())
658	663		then true
659	664		else (bl == m))
660	665		then true
661	666		else (bl == n))
662	667		then throw("Exchange operations disabled")
663		-	else if (if ((eH.assetPair.amountAsset != bn))
	668	+	else if (if ((eK.assetPair.amountAsset != bn))
664	669		then true
665		-	else (eH.assetPair.priceAsset != bo))
	670	+	else (eK.assetPair.priceAsset != bo))
666	671		then throw("Wrong order assets.")
667	672		else {
668		-	let eL = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
669		-	let eM = eA(eB, eC, 0)
670		-	let eN = eM._1
671		-	let eO = eM._2
672		-	let eP = (eO >= eL)
673		-	let eQ = makeString(["kLp=", toString(eL), " kLpNew=", toString(eO), " amountAssetBalance=", toString(ew), " priceAssetBalance=", toString(ex), " amountAssetBalanceDelta=", toString(eB), " priceAssetBalanceDelta=", toString(eC), " height=", toString(height)], "")
674		-	$Tuple2(eP, eQ)
	673	+	let eO = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, aj), "0")), aS("invalid kLp"))
	674	+	let eP = eD(eE, eF, 0)
	675	+	let eQ = eP._1
	676	+	let eR = eP._2
	677	+	let eS = (eR >= eO)
	678	+	let eT = makeString(["kLp=", toString(eO), " kLpNew=", toString(eR), " amountAssetBalance=", toString(ez), " priceAssetBalance=", toString(eA), " amountAssetBalanceDelta=", toString(eE), " priceAssetBalanceDelta=", toString(eF), " height=", toString(height)], "")
	679	+	$Tuple2(eS, eT)
675	680		}
676	681		}
677	682
678	683
679		-	func eR (eS) = if ((size(eS.payments) != 1))
	684	+	func eU (eV) = if ((size(eV.payments) != 1))
680	685		then throw("exactly 1 payment is expected")
681	686		else {
682		-	let eT = value(eS.payments[0])
683		-	let dj = value(eT.assetId)
684		-	let eU = eT.amount
685		-	let dW = dh(toBase58String(eS.transactionId), toBase58String(dj), eU, eS.caller)
686		-	let dA = dW._1
687		-	let dB = dW._2
688		-	let do = parseIntValue(dW._9)
689		-	let dE = dW._10
	687	+	let eW = value(eV.payments[0])
	688	+	let do = value(eW.assetId)
	689	+	let eX = eW.amount
	690	+	let dZ = dm(toBase58String(eV.transactionId), toBase58String(do), eX, eV.caller)
	691	+	let dF = dZ._1
	692	+	let dG = dZ._2
	693	+	let dt = parseIntValue(dZ._9)
	694	+	let dH = dZ._10
690	695		if (if (aY())
691	696		then true
692		-	else (do == n))
693		-	then throw(("Get operation is blocked by admin. Status = " + toString(do)))
694		-	else $Tuple5(dA, dB, eU, dj, dE)
	697	+	else (dt == n))
	698	+	then throw(("Get operation is blocked by admin. Status = " + toString(dt)))
	699	+	else $Tuple5(dF, dG, eX, do, dH)
695	700		}
696	701
697	702
698		-	func eV (eS,dG,dM) = if ((size(eS.payments) != 2))
	703	+	func eY (eV,dJ,dP) = if ((size(eV.payments) != 2))
699	704		then throw("exactly 2 payments are expected")
700	705		else {
701		-	let eW = value(eS.payments[0])
702		-	let eX = value(eS.payments[1])
703		-	let eY = dF(toBase58String(eS.transactionId), dG, eW.amount, eW.assetId, eX.amount, eX.assetId, toString(eS.caller), false, dM)
704		-	let do = parseIntValue(eY._8)
	706	+	let eZ = value(eV.payments[0])
	707	+	let fa = value(eV.payments[1])
	708	+	let fb = dI(toBase58String(eV.transactionId), dJ, eZ.amount, eZ.assetId, fa.amount, fa.assetId, toString(eV.caller), false, dP)
	709	+	let dt = parseIntValue(fb._8)
705	710		if (if (if (aY())
706	711		then true
707		-	else (do == l))
	712	+	else (dt == l))
708	713		then true
709		-	else (do == n))
710		-	then throw(("Put operation is blocked by admin. Status = " + toString(do)))
711		-	else eY
	714	+	else (dt == n))
	715	+	then throw(("Put operation is blocked by admin. Status = " + toString(dt)))
	716	+	else fb
712	717		}
713	718
714	719
715		-	func eZ (bW) = {
716		-	let fa = invoke(aT, "emit", [bW], nil)
717		-	if ((fa == fa))
	720	+	func fc (bW) = {
	721	+	let fd = invoke(aT, "emit", [bW], nil)
	722	+	if ((fd == fd))
718	723		then {
719		-	let fb = {
720		-	let bT = fa
	724	+	let fe = {
	725	+	let bT = fd
721	726		if ($isInstanceOf(bT, "Address"))
722	727		then {
723		-	let fc = bT
724		-	invoke(fc, "emit", [bW], nil)
	728	+	let ff = bT
	729	+	invoke(ff, "emit", [bW], nil)
725	730		}
726	731		else unit
727	732		}
728		-	if ((fb == fb))
	733	+	if ((fe == fe))
729	734		then bW
730	735		else throw("Strict value is not equal to itself.")
731	736		}

733	738		}
734	739
735	740
736		-	func fd (bW,ai) = {
737		-	let fe = if ((ai == 0))
	741	+	func fg (bW,ai) = {
	742	+	let fh = if ((ai == 0))
738	743		then 0
739	744		else fraction(bW, ai, b)
740		-	$Tuple2((bW - fe), fe)
	745	+	$Tuple2((bW - fh), fh)
741	746		}
742	747
743	748
744		-	func ff (fg,fh,ab,ac) = {
745		-	let fi = (ac == unit)
746		-	let fj = bJ(bf(bn))
747		-	let fk = bJ(bf(bo))
748		-	let fl = if ((fh == bn))
	749	+	func fi (fj,fk,ab,ac) = {
	750	+	let fl = (ac == unit)
	751	+	let fm = bJ(bf(bn))
	752	+	let fn = bJ(bf(bo))
	753	+	let fo = if ((fk == bn))
749	754		then true
750		-	else if ((fh == bo))
	755	+	else if ((fk == bo))
751	756		then false
752	757		else aQ("invalid asset")
753		-	let fm = if (fi)
754		-	then $Tuple2(fj, fk)
755		-	else if (fl)
756		-	then $Tuple2((fj - fg), fk)
757		-	else $Tuple2(fj, (fk - fg))
758		-	let fn = fm._1
759		-	let fo = fm._2
760	758		let fp = if (fl)
761		-	then $Tuple2(fg, 0)
762		-	else $Tuple2(0, fg)
	759	+	then $Tuple2(fm, fn)
	760	+	else if (fo)
	761	+	then $Tuple2((fm - fj), fn)
	762	+	else $Tuple2(fm, (fn - fj))
763	763		let fq = fp._1
764	764		let fr = fp._2
765		-	let eI = fd(~~fq, aV~~)~~._1~~
766		-	~~let eJ = fd~~(fr, aV)~~._1~~
767		-	~~let fs = fd~~(fg, aV)
	765	+	let fs = if (fo)
	766	+	then $Tuple2(fj, 0)
	767	+	else $Tuple2(0, fj)
768	768		let ft = fs._1
769		-	let fe = fs._2
770		-	let fu = (fn + eI)
771		-	let fv = (fo + eJ)

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let a = 8
5	5
6	6		let b = 100000000
7	7
8	8		let c = toBigInt(100000000)
9	9
10	10		let d = toBigInt(1000000000000000000)
11	11
12	12		let e = toBigInt(0)
13	13
14	14		let f = toBigInt(0)
15	15
16	16		let g = toBigInt(1)
17	17
18	18		let h = toBigInt(2)
19	19
20	20		let i = "WAVES"
21	21
22	22		let j = "__"
23	23
24	24		let k = 1
25	25
26	26		let l = 2
27	27
28	28		let m = 3
29	29
30	30		let n = 4
31	31
32	32		let o = 1
33	33
34	34		let p = 2
35	35
36	36		let q = 3
37	37
38	38		let r = 4
39	39
40	40		let s = 5
41	41
42	42		let t = 6
43	43
44	44		let u = 7
45	45
46	46		let v = 8
47	47
48	48		let w = 9
49	49
50	50		let x = 10
51	51
52	52		let y = 1
53	53
54	54		let z = 2
55	55
56	56		let A = 3
57	57
58	58		let B = 1
59	59
60	60		let C = 7
61	61
62	62		func D (E,F) = fraction(toBigInt(E), d, toBigInt(F))
63	63
64	64
65	65		func G (E,F) = fraction(E, d, F)
66	66
67	67
68	68		func H (I,J) = toInt(fraction(I, toBigInt(J), d))
69	69
70	70
71	71		func K (I,J,L) = toInt(fraction(I, toBigInt(J), d, L))
72	72
73	73
74	74		func M (N,O,P) = fraction(N, O, P)
75	75
76	76
77	77		func Q (I) = if ((0 > I))
78	78		then -(I)
79	79		else I
80	80
81	81
82	82		func R (I) = if ((e > I))
83	83		then -(I)
84	84		else I
85	85
86	86
87	87		func S () = "%s__swapContract"
88	88
89	89
90	90		func T () = "%s__factoryContract"
91	91
92	92
93	93		func U () = "%s__managerPublicKey"
94	94
95	95
96	96		func V () = "%s__pendingManagerPublicKey"
97	97
98	98
99	99		func W () = "%s%s__price__last"
100	100
101	101
102	102		func X (Y,Z) = makeString(["%s%s%d%d__price__history", toString(Y), toString(Z)], j)
103	103
104	104
105	105		func aa (ab,ac) = ((("%s%s%s__P__" + ab) + "__") + ac)
106	106
107	107
108	108		func ad (ab,ac) = ((("%s%s%s__G__" + ab) + "__") + ac)
109	109
110	110
111	111		func ae () = "%s__amountAsset"
112	112
113	113
114	114		func af () = "%s__priceAsset"
115	115
116	116
117	117		let ag = "%s__fee"
118	118
119	119		let ah = fraction(10, b, 10000)
120	120
121	121		let ai = valueOrElse(getInteger(this, ag), ah)
122	122
123	123		let aj = makeString(["%s", "kLp"], j)
124	124
125	125		let ak = makeString(["%s", "kLpRefreshedHeight"], j)
126	126
127	127		let al = makeString(["%s", "refreshKLpDelay"], j)
128	128
129	129		let am = 30
130	130
131	131		let an = valueOrElse(getInteger(this, al), am)
132	132
133	133		func ao (ap) = makeString(["%s%s", "stakedBalance", ap], j)
134	134
135	135
136	136		func aq (ap) = makeString(["%s%s", "shareAssetBalance", ap], j)
137	137
138	138
139	139		func ar (ap) = valueOrElse(getInteger(this, ao(ap)), 0)
140	140
141	141
142	142		func as (ap) = valueOrElse(getInteger(this, aq(ap)), 0)
143	143
144	144
145	145		func at () = "%s__factoryConfig"
146	146
147	147
148	148		func au () = "%s%s__matcher__publicKey"
149	149
150	150
151	151		func av (aw) = (("%s%s%s__" + aw) + "__mappings__poolContract2LpAsset")
152	152
153	153
154	154		func ax (ay,az) = (((("%d%d%s__" + ay) + "__") + az) + "__config")
155	155
156	156
157	157		func aA (aB) = ("%s%s%s__mappings__baseAsset2internalId__" + aB)
158	158
159	159
160	160		func aC () = "%s__shutdown"
161	161
162	162
163	163		func aD (aE) = ("%s%s__poolWeight__" + aE)
164	164
165	165
166	166		func aF () = "%s__allowedLpScriptHash"
167	167
168	168
169	169		let aG = "%s__feeCollectorAddress"
170	170
171	171		func aH (aI,aJ,aK,aL) = throw((((((((("order validation failed: orderValid=" + toString(aI)) + " (") + aJ) + ")") + " senderValid=") + toString(aK)) + " matcherValid=") + toString(aL)))
172	172
173	173
174	174		func aM (aN,aO) = valueOrErrorMessage(getString(aN, aO), makeString(["mandatory ", toString(aN), ".", aO, " is not defined"], ""))
175	175
176	176
177	177		func aP (aN,aO) = valueOrErrorMessage(getInteger(aN, aO), makeString(["mandatory ", toString(aN), ".", aO, " is not defined"], ""))
178	178
179	179
180	180		func aQ (aR) = throw(makeString(["lp.ride:", aR], " "))
181	181
182	182
183	183		func aS (aR) = makeString(["lp.ride:", aR], " ")
184	184
185	185
186	186		let aT = addressFromStringValue(aM(this, T()))
187	187
188	188		let aU = addressFromStringValue(aM(aT, aG))
189	189
190	190		let aV = {
191	191		let aW = invoke(aT, "getInFeeREADONLY", [toString(this)], nil)
192	192		if ($isInstanceOf(aW, "Int"))
193	193		then aW
194	194		else throw(($getType(aW) + " couldn't be cast to Int"))
195	195		}
196	196
197	197		let aX = {
198	198		let aW = invoke(aT, "getOutFeeREADONLY", [toString(this)], nil)
199	199		if ($isInstanceOf(aW, "Int"))
200	200		then aW
201	201		else throw(($getType(aW) + " couldn't be cast to Int"))
202	202		}
203	203
204	204		func aY () = valueOrElse(getBoolean(aT, aC()), false)
205	205
206	206
207	207		func aZ () = fromBase58String(aM(aT, au()))
208	208
209	209
210	210		func ba () = {
211	211		let bb = aM(this, ae())
212	212		let bc = aM(this, af())
213	213		let az = aP(aT, aA(bc))
214	214		let ay = aP(aT, aA(bb))
215	215		split(aM(aT, ax(toString(ay), toString(az))), j)
216	216		}
217	217
218	218
219	219		func bd (be) = if ((be == i))
220	220		then unit
221	221		else fromBase58String(be)
222	222
223	223
224	224		func bf (be) = if ((be == unit))
225	225		then i
226	226		else toBase58String(value(be))
227	227
228	228
229	229		func bg (bh) = $Tuple7(addressFromStringValue(bh[o]), parseIntValue(bh[p]), fromBase58String(bh[q]), bd(bh[r]), bd(bh[s]), parseIntValue(bh[t]), parseIntValue(bh[u]))
230	230
231	231
232	232		let bi = bg(ba())
233	233
234	234		let bj = bi
235	235
236	236		let bk = bj._1
237	237
238	238		let bl = bj._2
239	239
240	240		let bm = bj._3
241	241
242	242		let bn = bj._4
243	243
244	244		let bo = bj._5
245	245
246	246		let bp = bj._6
247	247
248	248		let bq = bj._7
249	249
250	250		func br () = split(aM(aT, at()), j)
251	251
252	252
253	253		let bs = valueOrErrorMessage(addressFromString(br()[B]), "incorrect staking address")
254	254
255	255		let bt = valueOrErrorMessage(addressFromString(br()[C]), "incorrect staking address")
256	256
257	257		func bu (bv,bw,bx,by,bz,bA,bB,bC,bD,bE) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(bv), toString(bw), toString(bx), toString(by), toString(bz), toString(bA), toString(bB), toString(bC), toString(bD), toString(bE)], j)
258	258
259	259
260	260		func bF (bG,bH,bI,by,bB,bC) = makeString(["%d%d%d%d%d%d", toString(bG), toString(bH), toString(bI), toString(by), toString(bB), toString(bC)], j)
261	261
262	262
263	263		func bJ (ap) = {
264	264		let bK = if ((ap == "WAVES"))
265	265		then wavesBalance(this).available
266	266		else assetBalance(this, fromBase58String(ap))
267	267		let bL = ((bK + ar(ap)) - as(ap))
268	268		max([0, bL])
269	269		}
270	270
271	271
272	272		func bM (bN,bO) = fraction(bN, d, bO)
273	273
274	274
275	275		func bP (bN,bO,L) = fraction(bN, d, bO, L)
276	276
277	277
278	278		func bQ (bR) = {
279	279		let bS = invoke(bR, "getRate", nil, nil)
280	280		if ((bS == bS))
281	281		then {
282	282		let bT = bS
283	283		if ($isInstanceOf(bT, "Int"))
284	284		then {
285	285		let bU = bT
286	286		bU
287	287		}
288	288		else aQ("proxy.getRate() unexpected value")
289	289		}
290	290		else throw("Strict value is not equal to itself.")
291	291		}
292	292
293	293
294	294		func bV (ap,bW,bX,bR) = {
295	295		let bY = ar(ap)
296	296		if ((bY == bY))
297	297		then {
298	298		let bZ = as(bX)
299	299		if ((bZ == bZ))
300	300		then {
301	301		let ca = bd(ap)
302	302		if ((bW > 0))
303	303		then {
304	304		let cb = invoke(bR, "deposit", nil, [AttachedPayment(ca, bW)])
305	305		if ((cb == cb))
306	306		then {
307	307		let bT = cb
308	308		if ($isInstanceOf(bT, "Int"))
309	309		then {
310	310		let cc = bT
311	311		let cd = (bY + bW)
312	312		let ce = (bZ + cc)
313	313		[IntegerEntry(ao(ap), cd), IntegerEntry(aq(bX), ce)]
314	314		}
315	315		else nil
316	316		}
317	317		else throw("Strict value is not equal to itself.")
318	318		}
319	319		else nil
320	320		}
321	321		else throw("Strict value is not equal to itself.")
322	322		}
323	323		else throw("Strict value is not equal to itself.")
324	324		}
325	325
326	326
327	327		func cf (ap,bW,bX,bR,cg,ch) = {
328	328		let bY = ar(ap)
329	329		if ((bY == bY))
330	330		then {
331	331		let bZ = as(bX)
332	332		if ((bZ == bZ))
333	333		then {
334	334		let ci = bQ(bR)
335	335		if ((ci == ci))
336	336		then {
337	337		let cj = fraction(cg, bY, bZ)
338	338		let ck = bd(bX)
339	339		let cl = fraction(cg, bW, cj)
340	340		let cm = fraction(cg, bW, ci)
341	341		let cn = max([0, (cl - cm)])
342	342		if ((cm > 0))
343	343		then {
344	344		let co = invoke(bR, "withdraw", nil, [AttachedPayment(ck, cm)])
345	345		if ((co == co))
346	346		then {
347	347		let bT = co
348	348		if ($isInstanceOf(bT, "Int"))
349	349		then {
350	350		let cp = bT
351	351		let cd = (bY - cp)
352	352		let ce = ((bZ - cm) - cn)
353	353		[IntegerEntry(ao(ap), cd), IntegerEntry(aq(bX), ce), ScriptTransfer(ch, cn, bd(bX))]
354	354		}
355	355		else nil
356	356		}
357	357		else throw("Strict value is not equal to itself.")
358	358		}
359	359		else nil
360	360		}
361	361		else throw("Strict value is not equal to itself.")
362	362		}
363	363		else throw("Strict value is not equal to itself.")
364	364		}
365	365		else throw("Strict value is not equal to itself.")
366	366		}
367	367
368	368
369	369		func cq (ap) = {
370	370		let bT = invoke(aT, "getPoolLeaseConfigREADONLY", [toString(this), ap], nil)
371	371		if ($isInstanceOf(bT, "(Boolean, Int, Int, String, String, Int, String)"))
372	372		then {
373	373		let cr = bT
374	374		cr
375	375		}
376	376		else aQ((("[" + ap) + "] getLeaseProxyConfig() error"))
377	377		}
378	378
379	379
380	380		func cs (ct,ap,bX,cu,bR,cg,ch) = {
381	381		let bY = ar(ap)
382	382		if ((bY == bY))
383	383		then {
384	384		let bZ = as(bX)
385	385		if ((bZ == bZ))
386	386		then {
387	387		let cv = {
388	388		let bT = bd(ap)
389	389		if ($isInstanceOf(bT, "ByteVector"))
390	390		then {
391	391		let cw = bT
392	392		assetBalance(this, cw)
393	393		}
394	394		else if ($isInstanceOf(bT, "Unit"))
395	395		then {
396	396		let cx = bT
397	397		wavesBalance(this).available
398	398		}
399	399		else throw("Match error")
400	400		}
401	401		if ((cv == cv))
402	402		then {
403	403		let cy = max([0, ((cv + bY) - cu)])
404	404		let cz = fraction(ct, cy, 100)
405	405		let cA = (bY - cz)
406	406		if ((cA == 0))
407	407		then nil
408	408		else if ((0 > cA))
409	409		then {
410	410		let cB = -(cA)
411	411		bV(ap, cB, bX, bR)
412	412		}
413	413		else {
414	414		let cC = cA
415	415		cf(ap, cC, bX, bR, cg, ch)
416	416		}
417	417		}
418	418		else throw("Strict value is not equal to itself.")
419	419		}
420	420		else throw("Strict value is not equal to itself.")
421	421		}
422	422		else throw("Strict value is not equal to itself.")
423	423		}
424	424
425	425
426	426		func cD (ap) = {
427	427		let cE = cq(ap)
428	428		let cF = cE._1
429	429		let cG = cE._2
430	430		let cu = cE._3
431	431		let cH = cE._4
432	432		let cI = cE._5
433	433		let cg = cE._6
434	434		let cJ = cE._7
435	435		if (cF)
436	436		then cs(cG, ap, cI, cu, addressFromStringValue(cH), cg, addressFromStringValue(cJ))
437	437		else nil
438	438		}
439	439
440	440
441	441		func cK (ap,cL) = {
442	442		let cM = cq(ap)
443	443		let cF = cM._1
444	444		let cG = cM._2
445	445		let cu = cM._3
446	446		let cH = cM._4
447	447		let cI = cM._5
448	448		let cg = cM._6
449	449		let cJ = cM._7
450	450		if (cF)
451	451		then {
452	452		let cN = max([0, ((bJ(ap) - cL) - cu)])
453	453		if ((cN == cN))
454	454		then {
455	455		let cd = fraction(cG, cN, 100)
456	456		if ((cd == cd))
457	457		then {
458	458		let cO = max([0, (ar(ap) - cd)])
459	459		if ((cO == cO))
460	460		then cf(ap, cO, cI, addressFromStringValue(cH), cg, addressFromStringValue(cJ))
461	461		else throw("Strict value is not equal to itself.")
462	462		}
463	463		else throw("Strict value is not equal to itself.")
464	464		}
465	465		else throw("Strict value is not equal to itself.")
466	466		}
467	467		else nil
468	468		}
469	469
470	470
471		-	func cP (cQ,cR~~,cS,cT~~) = {
472		-	let cU = D(cS, cQ)
473		-	let cV = D(cT, cR)
474		-	bM(~~cV, cU~~)
	471	+	func cP (cQ,cR) = {
	472	+	let cS = cK(aM(this, ae()), cQ)
	473	+	let cT = cK(aM(this, af()), cR)
	474	+	(cS ++ cT)
475	475		}
476	476
477	477
478		-	func cW (cS,cT,cX) = {
479		-	let cY = ba()
480		-	let cZ = parseIntValue(cY[t])
481		-	let da = parseIntValue(cY[u])
482		-	let db = cP(cZ, da, cS, cT)
483		-	let bO = D(cS, cZ)
484		-	let bN = D(cT, da)
485		-	let dc = D(cX, b)
486		-	let dd = bM(bO, dc)
487		-	let de = bM(bN, dc)
488		-	[db, dd, de]
	478	+	func cU (cV,cW,cX,cY) = {
	479	+	let cZ = D(cX, cV)
	480	+	let da = D(cY, cW)
	481	+	bM(da, cZ)
489	482		}
490	483
491	484
492		-	func df (cS,cT,cX) = {

github/deemru/w8io/873ac7e 
1170.60 ms ◑