w8 · tx · 8kk···j1j

tx · 8kkD6eEkMENyEuKTuhqWkJZcuLEEkDdThFiMS5PT1j1j

3P7Job1QorQJYPzEnmBnGaCqtpcB4ohiz5p:  -0.03000000 Waves

2022.12.29 16:27 [3447136] smart account 3P7Job1QorQJYPzEnmBnGaCqtpcB4ohiz5p > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8kkD6eEkMENyEuKTuhqWkJZcuLEEkDdThFiMS5PT1j1j",
    "fee": 3000000,
    "feeAssetId": null,
    "timestamp": 1672320545379,
    "version": 1,
    "sender": "3P7Job1QorQJYPzEnmBnGaCqtpcB4ohiz5p",
    "senderPublicKey": "9hjWnJ9WvGatiYbxGGQMEnifVHCK6ZmwUbzH8EXcuPYv",
    "proofs": [
        "4thvWLMSJq2NJWVkBELJjwQZ4uFhzK27myTzXp3qzwPzxk7GoaQ5FDH7MhUHV7AjLpv9autHYXmWynwvzm1KTvXP"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3447136,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: A11yc5TjvDq3vzdyfsLa3NZ2b2qNvncictQsbkErze1R
Next: 7r4DY88WrcyvbhuRAXewzaYEaqdn79FMU43fXsKDbqau

Diff: 
Old New Differences
86 86  let block_timestamp = HEIGHT
87 87  
88 88  func allowed (caller) = (owner == caller)
89 + 
90 + 
91 + func serialized () = {
92 +     let serialize = invoke(this, "serialize", nil, nil)
93 +     if ((serialize == serialize))
94 +         then true
95 +         else throw("Strict value is not equal to itself.")
96 +     }
89 97  
90 98  
91 99  func assert (a) = if (a)
303 311                              else $Tuple2(D, false)
304 312                      }
305 313  
306 -             let $t061556217 = {
314 +             let $t062486310 = {
307 315                  let $l = list16
308 316                  let $s = size($l)
309 317                  let $acc0 = $Tuple2(S, false)
317 325  
318 326                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
319 327                  }
320 -             let D = $t061556217._1
321 -             let finished = $t061556217._2
328 +             let D = $t062486310._1
329 +             let finished = $t062486310._2
322 330              if ((finished == false))
323 331                  then throw(("D_proc() not finished with " + toString(D)))
324 332                  else toInt(D)
341 349                  let D_big = toBigInt(D)
342 350                  let Ann_big = toBigInt((amp * N_COINS))
343 351                  func S_c (acc,index) =                 {
344 -                     let $t068106829 = acc
345 -                     let S_ = $t068106829._1
346 -                     let c = $t068106829._2
352 +                     let $t069036922 = acc
353 +                     let S_ = $t069036922._1
354 +                     let c = $t069036922._2
347 355                      let x_ = if ((index == i))
348 356                          then toBigInt(fraction(x, TOKEN_RATE, rates[index]))
349 357                          else xp[index]
352 360                          else $Tuple2(S_, c)
353 361                      }
354 362  
355 -                 let $t071057169 = {
363 +                 let $t071987262 = {
356 364                      let $l = index_N_COINS
357 365                      let $s = size($l)
358 366                      let $acc0 = $Tuple2(big0, D_big)
366 374  
367 375                      $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
368 376                      }
369 -                 let S_ = $t071057169._1
370 -                 let c_ = $t071057169._2
377 +                 let S_ = $t071987262._1
378 +                 let c_ = $t071987262._2
371 379                  let c = fraction(c_, D_big, fraction(Ann_big, N_COINS_big, big1))
372 380                  let bD = ((S_ + fraction(D_big, big1, Ann_big)) - D_big)
373 381                  func y_proc (acc,unused) =                 if ((acc._2 == true))
384 392                                  else $Tuple2(y, false)
385 393                          }
386 394  
387 -                 let $t077497815 = {
395 +                 let $t078427908 = {
388 396                      let $l = list16
389 397                      let $s = size($l)
390 398                      let $acc0 = $Tuple2(D_big, false)
398 406  
399 407                      $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
400 408                      }
401 -                 let y = $t077497815._1
402 -                 let finished = $t077497815._2
409 +                 let y = $t078427908._1
410 +                 let finished = $t078427908._2
403 411                  if ((finished == false))
404 412                      then throw(("y_proc() not finished with " + toString(y)))
405 413                      else $Tuple2(fraction(toInt(y), rates[j], TOKEN_RATE), D)
414 422              let D_big = toBigInt(D)
415 423              let Ann_big = toBigInt((amp * N_COINS))
416 424              func S_c (acc,index) =             {
417 -                 let $t083208339 = acc
418 -                 let S_ = $t083208339._1
419 -                 let c = $t083208339._2
425 +                 let $t084138432 = acc
426 +                 let S_ = $t084138432._1
427 +                 let c = $t084138432._2
420 428                  let x_ = if ((index == i))
421 429                      then big0
422 430                      else xp[index]
425 433                      else $Tuple2(S_, c)
426 434                  }
427 435  
428 -             let $t085698633 = {
436 +             let $t086628726 = {
429 437                  let $l = index_N_COINS
430 438                  let $s = size($l)
431 439                  let $acc0 = $Tuple2(big0, D_big)
439 447  
440 448                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
441 449                  }
442 -             let S_ = $t085698633._1
443 -             let c_ = $t085698633._2
450 +             let S_ = $t086628726._1
451 +             let c_ = $t086628726._2
444 452              let c = fraction(c_, D_big, fraction(Ann_big, N_COINS_big, big1))
445 453              let bD = ((S_ + fraction(D_big, big1, Ann_big)) - D_big)
446 454              func y_proc (acc,unused) =             if ((acc._2 == true))
457 465                              else $Tuple2(y, false)
458 466                      }
459 467  
460 -             let $t092139279 = {
468 +             let $t093069372 = {
461 469                  let $l = list16
462 470                  let $s = size($l)
463 471                  let $acc0 = $Tuple2(D_big, false)
471 479  
472 480                  $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
473 481                  }
474 -             let y = $t092139279._1
475 -             let finished = $t092139279._2
482 +             let y = $t093069372._1
483 +             let finished = $t093069372._2
476 484              if ((finished == false))
477 485                  then throw(("y_proc() not finished with " + toString(y)))
478 486                  else fraction(toInt(y), rates[i], TOKEN_RATE)
618 626      if (assert((D1 > D0)))
619 627          then throw("D1 > D0")
620 628          else {
621 -             let $t01295914909 = if ((token_quantity > 0))
629 +             let $t01305215002 = if ((token_quantity > 0))
622 630                  then {
623 631                      func fee_balances (old,new) =                     {
624 632                          func fold (acc,index) =                         {
651 659                          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
652 660                          }
653 661  
654 -                     let $t01443314515 = fee_balances(balances, new_balances)
655 -                     let finals = $t01443314515._1
656 -                     let no_fees = $t01443314515._2
657 -                     let actions = $t01443314515._3
658 -                     let fee_sum = $t01443314515._4
662 +                     let $t01452614608 = fee_balances(balances, new_balances)
663 +                     let finals = $t01452614608._1
664 +                     let no_fees = $t01452614608._2
665 +                     let actions = $t01452614608._3
666 +                     let fee_sum = $t01452614608._4
659 667                      $Tuple3(finals, get_D(big_list(no_fees), amp), (actions ++ log_data(D0, if ((fee == 0))
660 668                          then 0
661 669                          else fraction(fee_sum, FEE_DENOMINATOR, fee))))
662 670                      }
663 671                  else $Tuple3(new_balances, D1, nil)
664 -             let final_balances = $t01295914909._1
665 -             let D2 = $t01295914909._2
666 -             let fees_actions = $t01295914909._3
672 +             let final_balances = $t01305215002._1
673 +             let D2 = $t01305215002._2
674 +             let fees_actions = $t01305215002._3
667 675              let mint_amount = if ((token_quantity == 0))
668 676                  then D1
669 677                  else fraction(token_quantity, (D2 - D0), D0)
711 719  
712 720                                  func fold (acc,coin) =                                 $Tuple3((acc._1 + 1), (acc._2 :+ 0), (acc._3 :+ pow(10, 0, decimals(coin), 0, 0, DOWN)))
713 721  
714 -                                 let $t01617016265 = {
722 +                                 let $t01626316358 = {
715 723                                      let $l = coins_list
716 724                                      let $s = size($l)
717 725                                      let $acc0 = $Tuple3(0, nil, nil)
725 733  
726 734                                      $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
727 735                                      }
728 -                                 let _N_COINS = $t01617016265._1
729 -                                 let zeros = $t01617016265._2
730 -                                 let _rates = $t01617016265._3
736 +                                 let _N_COINS = $t01626316358._1
737 +                                 let zeros = $t01626316358._2
738 +                                 let _rates = $t01626316358._3
731 739                                  let issueToken = Issue(_pool_token, ("LP token for " + _coins), 0, TOKEN_DECIMALS, true)
732 740                                  let tokenId = toBase58String(calculateAssetId(issueToken))
733 741  [StringEntry("coins", _coins), StringEntry("rates", makeString(list_itos(_rates), ",")), StringEntry("balances", makeString(list_itos(zeros), ",")), IntegerEntry("N_COINS", _N_COINS), IntegerEntry("initial_A", _A), IntegerEntry("future_A", _A), IntegerEntry("fee", _fee), IntegerEntry("admin_fee", _admin_fee), StringEntry("owner", checkAddress(_owner)), IntegerEntry("kill_deadline", (height + KILL_DEADLINE_DT)), StringEntry("token", tokenId), BooleanEntry("is_killed", false), BooleanEntry("is_auto_fees", true), issueToken]
738 746  
739 747  
740 748  @Callable(msg)
741 - func add_liquidity (min_mint_amount) = if (!(allowed(msg.caller)))
742 -     then throw("!allowed")
749 + func add_liquidity (min_mint_amount) = if (!(serialized()))
750 +     then throw()
743 751      else if (assert(!(is_killed)))
744 752          then throw("is killed")
745 753          else {
792 800                  else false)
793 801                  then throw("initial deposit requires all coins")
794 802                  else {
795 -                     let $t01820918295 = _calc_token_amount(new_balances)
796 -                     let final_balances = $t01820918295._1
797 -                     let mint_amount = $t01820918295._2
798 -                     let fees_actions = $t01820918295._3
803 +                     let $t01828118367 = _calc_token_amount(new_balances)
804 +                     let final_balances = $t01828118367._1
805 +                     let mint_amount = $t01828118367._2
806 +                     let fees_actions = $t01828118367._3
799 807                      if (assert((mint_amount >= min_mint_amount)))
800 808                          then throw("slippage screwed you")
801 809                          else ([StringEntry("balances", makeString(list_itos(final_balances), ",")), Reissue(token, mint_amount, true), ScriptTransfer(msg.caller, mint_amount, token)] ++ fees_actions)
809 817      let xp_i = balances[i]
810 818      let xp_j = balances[j]
811 819      let x = (xp_i + dx)
812 -     let $t01875518808 = get_y(i, j, x, big_list(balances))
813 -     let y = $t01875518808._1
814 -     let D = $t01875518808._2
820 +     let $t01882718880 = get_y(i, j, x, big_list(balances))
821 +     let y = $t01882718880._1
822 +     let D = $t01882718880._2
815 823      let _dy = ((xp_j - y) - 1)
816 824      let dy_fee = fraction(_dy, fee, FEE_DENOMINATOR)
817 825      let dy = (_dy - dy_fee)
834 842                  let xp_i = balances[i]
835 843                  let xp_j = balances[j]
836 844                  let x = (xp_i + dx)
837 -                 let $t01937719430 = get_y(i, j, x, big_list(balances))
838 -                 let y = $t01937719430._1
839 -                 let D = $t01937719430._2
845 +                 let $t01944919502 = get_y(i, j, x, big_list(balances))
846 +                 let y = $t01944919502._1
847 +                 let D = $t01944919502._2
840 848                  let _dy = ((xp_j - y) - 1)
841 849                  let dy_fee = fraction(_dy, fee, FEE_DENOMINATOR)
842 850                  let dy = (_dy - dy_fee)
878 886  
879 887  
880 888  @Callable(msg)
881 - func remove_liquidity (_min_amounts) = if ((size(msg.payments) != 1))
882 -     then throw("size( payments ) != 1")
883 -     else {
884 -         let payment = msg.payments[0]
885 -         if ((payment.assetId != token))
886 -             then throw("unknown token")
887 -             else {
888 -                 let min_amounts = if ((_min_amounts == "0"))
889 -                     then nil
890 -                     else list_stoi(split(_min_amounts, ","))
891 -                 if (if ((_min_amounts != "0"))
892 -                     then (size(min_amounts) != N_COINS)
893 -                     else false)
894 -                     then throw("min_amounts.size() != N_COINS")
895 -                     else {
896 -                         let amount = payment.amount
897 -                         let caller = msg.caller
898 -                         func fold (acc,index) =                         {
899 -                             let balance = balances[index]
900 -                             let amount_out = fraction(balance, amount, token_quantity)
901 -                             if (if ((_min_amounts != "0"))
902 -                                 then (min_amounts[index] > amount_out)
903 -                                 else false)
904 -                                 then throw("withdrawal resulted in fewer coins than expected")
905 -                                 else $Tuple2((acc._1 :+ ScriptTransfer(caller, amount_out, fromBase58String(coins[index]))), (acc._2 :+ (balance - amount_out)))
889 + func remove_liquidity (_min_amounts) = if (!(serialized()))
890 +     then throw()
891 +     else if ((size(msg.payments) != 1))
892 +         then throw("size( payments ) != 1")
893 +         else {
894 +             let payment = msg.payments[0]
895 +             if ((payment.assetId != token))
896 +                 then throw("unknown token")
897 +                 else {
898 +                     let min_amounts = if ((_min_amounts == "0"))
899 +                         then nil
900 +                         else list_stoi(split(_min_amounts, ","))
901 +                     if (if ((_min_amounts != "0"))
902 +                         then (size(min_amounts) != N_COINS)
903 +                         else false)
904 +                         then throw("min_amounts.size() != N_COINS")
905 +                         else {
906 +                             let amount = payment.amount
907 +                             let caller = msg.caller
908 +                             func fold (acc,index) =                             {
909 +                                 let balance = balances[index]
910 +                                 let amount_out = fraction(balance, amount, token_quantity)
911 +                                 if (if ((_min_amounts != "0"))
912 +                                     then (min_amounts[index] > amount_out)
913 +                                     else false)
914 +                                     then throw("withdrawal resulted in fewer coins than expected")
915 +                                     else $Tuple2((acc._1 :+ ScriptTransfer(caller, amount_out, fromBase58String(coins[index]))), (acc._2 :+ (balance - amount_out)))
916 +                                 }
917 + 
918 +                             let $t02172921808 = {
919 +                                 let $l = index_N_COINS
920 +                                 let $s = size($l)
921 +                                 let $acc0 = $Tuple2(nil, nil)
922 +                                 func $f0_1 ($a,$i) =                                 if (($i >= $s))
923 +                                     then $a
924 +                                     else fold($a, $l[$i])
925 + 
926 +                                 func $f0_2 ($a,$i) =                                 if (($i >= $s))
927 +                                     then $a
928 +                                     else throw("List size exceeds 10")
929 + 
930 +                                 $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
931 +                                 }
932 +                             let transfers = $t02172921808._1
933 +                             let final_balances = $t02172921808._2
934 +                             (transfers ++ [StringEntry("balances", makeString(list_itos(final_balances), ",")), Burn(token, amount)])
906 935                              }
907 - 
908 -                         let $t02161521694 = {
909 -                             let $l = index_N_COINS
910 -                             let $s = size($l)
911 -                             let $acc0 = $Tuple2(nil, nil)
912 -                             func $f0_1 ($a,$i) =                             if (($i >= $s))
913 -                                 then $a
914 -                                 else fold($a, $l[$i])
915 - 
916 -                             func $f0_2 ($a,$i) =                             if (($i >= $s))
917 -                                 then $a
918 -                                 else throw("List size exceeds 10")
919 - 
920 -                             $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
921 -                             }
922 -                         let transfers = $t02161521694._1
923 -                         let final_balances = $t02161521694._2
924 -                         (transfers ++ [StringEntry("balances", makeString(list_itos(final_balances), ",")), Burn(token, amount)])
925 -                         }
926 -                 }
927 -         }
936 +                     }
937 +             }
928 938  
929 939  
930 940  
946 956                      then throw("unknown token")
947 957                      else {
948 958                          let _token_amount = payment.amount
949 -                         let $t02241822485 = _calc_withdraw_one_coin(_token_amount, i)
950 -                         let dy = $t02241822485._1
951 -                         let dy_fee = $t02241822485._2
952 -                         let D = $t02241822485._3
959 +                         let $t02253222599 = _calc_withdraw_one_coin(_token_amount, i)
960 +                         let dy = $t02253222599._1
961 +                         let dy_fee = $t02253222599._2
962 +                         let D = $t02253222599._3
953 963                          if (assert((dy >= min_amount)))
954 964                              then throw("not enough coins removed")
955 965                              else {
1022 1032  
1023 1033                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1024 1034                  }
1025 -             let $t02396324049 = _calc_token_amount(new_balances)
1026 -             let final_balances = $t02396324049._1
1027 -             let mint_amount = $t02396324049._2
1028 -             let fees_actions = $t02396324049._3
1035 +             let $t02407724163 = _calc_token_amount(new_balances)
1036 +             let final_balances = $t02407724163._1
1037 +             let mint_amount = $t02407724163._2
1038 +             let fees_actions = $t02407724163._3
1029 1039              $Tuple2(nil, mint_amount)
1030 1040              }
1031 1041      }
1210 1220  
1211 1221  
1212 1222  @Callable(msg)
1223 + func serialize () = if ((msg.caller != this))
1224 +     then throw("self only")
1225 +     else {
1226 +         let id = toBase58String(msg.transactionId)
1227 +         if ((getString(this, "serialized") == id))
1228 +             then throw("already serialized")
1229 +             else [StringEntry("serialized", id)]
1230 +         }
1231 + 
1232 + 
1233 + 
1234 + @Callable(msg)
1213 1235  func set_height_address (_heightAddress) = if ((msg.caller != owner))
1214 1236      then throw("only owner")
1215 1237      else [StringEntry("heightAddress", checkAddress(_heightAddress))]
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let N_COINS = getIntegerValue(this, "N_COINS")
5 5  
6 6  let N_COINS_big = toBigInt(N_COINS)
7 7  
8 8  let N_COINS_MAX = 10
9 9  
10 10  let TOKEN_DECIMALS = 6
11 11  
12 12  let TOKEN_RATE = 1000000
13 13  
14 14  let FEE_DENOMINATOR = 10000000000
15 15  
16 16  let PRECISION = 1000000
17 17  
18 18  let DECIMALS = 6
19 19  
20 20  let MAX_ADMIN_FEE = 10000000000
21 21  
22 22  let MAX_FEE = 5000000000
23 23  
24 24  let MAX_A = 1000000
25 25  
26 26  let MAX_A_CHANGE = 10
27 27  
28 28  let ADMIN_ACTIONS_DELAY = ((3 * 86400) / 60)
29 29  
30 30  let MIN_RAMP_TIME = (86400 / 60)
31 31  
32 32  let VP_LOG_PERIOD = 86400000
33 33  
34 34  let VP_PRECISION = 1000000000000
35 35  
36 36  let coins = split(getStringValue(this, "coins"), ",")
37 37  
38 38  let fee = getIntegerValue(this, "fee")
39 39  
40 40  let N_fee_4 = ((fee * N_COINS) / (4 * (N_COINS - 1)))
41 41  
42 42  let admin_fee = getIntegerValue(this, "admin_fee")
43 43  
44 44  let is_auto_fees = getBooleanValue(this, "is_auto_fees")
45 45  
46 46  let owner = addressFromStringValue(getStringValue(this, "owner"))
47 47  
48 48  let token = fromBase58String(getStringValue(this, "token"))
49 49  
50 50  let token_quantity = value(assetInfo(token)).quantity
51 51  
52 52  let initial_A = getIntegerValue(this, "initial_A")
53 53  
54 54  let future_A = getIntegerValue(this, "future_A")
55 55  
56 56  let initial_A_time = valueOrElse(getInteger(this, "initial_A_time"), 0)
57 57  
58 58  let future_A_time = valueOrElse(getInteger(this, "future_A_time"), 0)
59 59  
60 60  let admin_actions_deadline = valueOrElse(getInteger(this, "admin_actions_deadline"), 0)
61 61  
62 62  let transfer_ownership_deadline = valueOrElse(getInteger(this, "transfer_ownership_deadline"), 0)
63 63  
64 64  let future_fee = getIntegerValue(this, "future_fee")
65 65  
66 66  let future_admin_fee = getIntegerValue(this, "future_admin_fee")
67 67  
68 68  let future_owner = getStringValue(this, "future_owner")
69 69  
70 70  let is_killed = getBooleanValue(this, "is_killed")
71 71  
72 72  let kill_deadline = getIntegerValue(this, "kill_deadline")
73 73  
74 74  let KILL_DEADLINE_DT = (((2 * 30) * 86400) / 60)
75 75  
76 76  let big0 = toBigInt(0)
77 77  
78 78  let big1 = toBigInt(1)
79 79  
80 80  let big2 = toBigInt(2)
81 81  
82 82  let heightAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, "heightAddress"), "no settings defined")), "bad settings address")
83 83  
84 84  let HEIGHT = height
85 85  
86 86  let block_timestamp = HEIGHT
87 87  
88 88  func allowed (caller) = (owner == caller)
89 + 
90 + 
91 + func serialized () = {
92 +     let serialize = invoke(this, "serialize", nil, nil)
93 +     if ((serialize == serialize))
94 +         then true
95 +         else throw("Strict value is not equal to itself.")
96 +     }
89 97  
90 98  
91 99  func assert (a) = if (a)
92 100      then false
93 101      else true
94 102  
95 103  
96 104  func list_itos (list) = if ((size(list) > N_COINS_MAX))
97 105      then throw("list_itos: list.size() > N_COINS_MAX")
98 106      else {
99 107          func fold (acc,val) =         (acc :+ toString(val))
100 108  
101 109          let $l = list
102 110          let $s = size($l)
103 111          let $acc0 = nil
104 112          func $f0_1 ($a,$i) =         if (($i >= $s))
105 113              then $a
106 114              else fold($a, $l[$i])
107 115  
108 116          func $f0_2 ($a,$i) =         if (($i >= $s))
109 117              then $a
110 118              else throw("List size exceeds 10")
111 119  
112 120          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
113 121          }
114 122  
115 123  
116 124  func list_stoi (list) = if ((size(list) > N_COINS_MAX))
117 125      then throw("list_stoi: list.size() > N_COINS_MAX")
118 126      else {
119 127          func fold (acc,val) =         (acc :+ parseIntValue(val))
120 128  
121 129          let $l = list
122 130          let $s = size($l)
123 131          let $acc0 = nil
124 132          func $f0_1 ($a,$i) =         if (($i >= $s))
125 133              then $a
126 134              else fold($a, $l[$i])
127 135  
128 136          func $f0_2 ($a,$i) =         if (($i >= $s))
129 137              then $a
130 138              else throw("List size exceeds 10")
131 139  
132 140          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
133 141          }
134 142  
135 143  
136 144  let balances = list_stoi(split(getStringValue(this, "balances"), ","))
137 145  
138 146  let rates = list_stoi(split(getStringValue(this, "rates"), ","))
139 147  
140 148  let rates_size = size(rates)
141 149  
142 150  let index_N_COINS_MAX = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
143 151  
144 152  func index_n (n) = if ((n > N_COINS_MAX))
145 153      then throw("index_n: n > N_COINS_MAX")
146 154      else {
147 155          func fold (acc,index) =         if ((n > index))
148 156              then (acc :+ index)
149 157              else acc
150 158  
151 159          let $l = index_N_COINS_MAX
152 160          let $s = size($l)
153 161          let $acc0 = nil
154 162          func $f0_1 ($a,$i) =         if (($i >= $s))
155 163              then $a
156 164              else fold($a, $l[$i])
157 165  
158 166          func $f0_2 ($a,$i) =         if (($i >= $s))
159 167              then $a
160 168              else throw("List size exceeds 10")
161 169  
162 170          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
163 171          }
164 172  
165 173  
166 174  let index_N_COINS = index_n(N_COINS)
167 175  
168 176  let index_N_COINS_1 = (index_N_COINS :+ N_COINS)
169 177  
170 178  func big_list (list) = if ((size(list) != N_COINS))
171 179      then throw("big_list: list.size() != N_COINS")
172 180      else {
173 181          func fold (acc,index) =         (acc :+ toBigInt(fraction(list[index], TOKEN_RATE, rates[index])))
174 182  
175 183          let $l = index_N_COINS
176 184          let $s = size($l)
177 185          let $acc0 = nil
178 186          func $f0_1 ($a,$i) =         if (($i >= $s))
179 187              then $a
180 188              else fold($a, $l[$i])
181 189  
182 190          func $f0_2 ($a,$i) =         if (($i >= $s))
183 191              then $a
184 192              else throw("List size exceeds 10")
185 193  
186 194          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
187 195          }
188 196  
189 197  
190 198  func coin_index (payment) = match payment.assetId {
191 199      case assetId: ByteVector => 
192 200          valueOrErrorMessage(indexOf(coins, toBase58String(assetId)), (toBase58String(assetId) + " out of pool"))
193 201      case _ => 
194 202          throw("unsupported assetId")
195 203  }
196 204  
197 205  
198 206  func admin_balance (i) = if (if ((0 > i))
199 207      then true
200 208      else (i > N_COINS))
201 209      then throw("i out of index")
202 210      else (assetBalance(this, fromBase58String(coins[i])) - balances[i])
203 211  
204 212  
205 213  func checkAddress (a58) = {
206 214      let a = addressFromStringValue(a58)
207 215      toString(a)
208 216      }
209 217  
210 218  
211 219  let amp = {
212 220      let t1 = future_A_time
213 221      let A1 = future_A
214 222      if ((t1 > block_timestamp))
215 223          then {
216 224              let A0 = initial_A
217 225              let t0 = initial_A_time
218 226              if ((A1 > A0))
219 227                  then (A0 + (((A1 - A0) * (block_timestamp - t0)) / (t1 - t0)))
220 228                  else (A0 - (((A0 - A1) * (block_timestamp - t0)) / (t1 - t0)))
221 229              }
222 230          else A1
223 231      }
224 232  
225 233  func list_sum (list) = {
226 234      func fold (acc,val) =     (acc + val)
227 235  
228 236      let $l = list
229 237      let $s = size($l)
230 238      let $acc0 = big0
231 239      func $f0_1 ($a,$i) =     if (($i >= $s))
232 240          then $a
233 241          else fold($a, $l[$i])
234 242  
235 243      func $f0_2 ($a,$i) =     if (($i >= $s))
236 244          then $a
237 245          else throw("List size exceeds 10")
238 246  
239 247      $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
240 248      }
241 249  
242 250  
243 251  func list_mult (list) = {
244 252      func fold (acc,val) =     fraction(fraction(acc, val, big1), N_COINS_big, big1)
245 253  
246 254      let $l = list
247 255      let $s = size($l)
248 256      let $acc0 = big1
249 257      func $f0_1 ($a,$i) =     if (($i >= $s))
250 258          then $a
251 259          else fold($a, $l[$i])
252 260  
253 261      func $f0_2 ($a,$i) =     if (($i >= $s))
254 262          then $a
255 263          else throw("List size exceeds 10")
256 264  
257 265      $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
258 266      }
259 267  
260 268  
261 269  let list16 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
262 270  
263 271  func get_D (xp,amp) = {
264 272      let S = list_sum(xp)
265 273      if ((toInt(S) == 0))
266 274          then 0
267 275          else {
268 276              let Ann = (amp * N_COINS)
269 277              let AnnS = fraction(toBigInt(Ann), S, big1)
270 278              let Ann1 = toBigInt((Ann - 1))
271 279              let xd = list_mult(xp)
272 280              let N_COINS_1 = (N_COINS + 1)
273 281              let N_COINS_1_big = toBigInt(N_COINS_1)
274 282              func D_mult (val) =             {
275 283                  func fold (acc,index) =                 fraction(acc, val, big1)
276 284  
277 285                  let $l = index_N_COINS_1
278 286                  let $s = size($l)
279 287                  let $acc0 = big1
280 288                  func $f0_1 ($a,$i) =                 if (($i >= $s))
281 289                      then $a
282 290                      else fold($a, $l[$i])
283 291  
284 292                  func $f0_2 ($a,$i) =                 if (($i >= $s))
285 293                      then $a
286 294                      else throw("List size exceeds 11")
287 295  
288 296                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
289 297                  }
290 298  
291 299              func D_proc (acc,unused) =             if ((acc._2 == true))
292 300                  then acc
293 301                  else {
294 302                      let Dprev = acc._1
295 303                      let D_P = fraction(D_mult(Dprev), big1, xd)
296 304                      let D = fraction((AnnS + fraction(N_COINS_big, D_P, big1)), Dprev, (fraction(Ann1, Dprev, big1) + fraction(N_COINS_1_big, D_P, big1)))
297 305                      if ((D > Dprev))
298 306                          then if ((1 >= toInt((D - Dprev))))
299 307                              then $Tuple2(D, true)
300 308                              else $Tuple2(D, false)
301 309                          else if ((1 >= toInt((Dprev - D))))
302 310                              then $Tuple2(D, true)
303 311                              else $Tuple2(D, false)
304 312                      }
305 313  
306 -             let $t061556217 = {
314 +             let $t062486310 = {
307 315                  let $l = list16
308 316                  let $s = size($l)
309 317                  let $acc0 = $Tuple2(S, false)
310 318                  func $f0_1 ($a,$i) =                 if (($i >= $s))
311 319                      then $a
312 320                      else D_proc($a, $l[$i])
313 321  
314 322                  func $f0_2 ($a,$i) =                 if (($i >= $s))
315 323                      then $a
316 324                      else throw("List size exceeds 16")
317 325  
318 326                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
319 327                  }
320 -             let D = $t061556217._1
321 -             let finished = $t061556217._2
328 +             let D = $t062486310._1
329 +             let finished = $t062486310._2
322 330              if ((finished == false))
323 331                  then throw(("D_proc() not finished with " + toString(D)))
324 332                  else toInt(D)
325 333              }
326 334      }
327 335  
328 336  
329 337  func get_y (i,j,x,xp) = if (assert((i != j)))
330 338      then throw("same coin")
331 339      else if (assert(if ((j >= 0))
332 340          then (i >= 0)
333 341          else false))
334 342          then throw("below zero")
335 343          else if (assert(if ((N_COINS > j))
336 344              then (N_COINS > i)
337 345              else false))
338 346              then throw("above N_COINS")
339 347              else {
340 348                  let D = get_D(xp, amp)
341 349                  let D_big = toBigInt(D)
342 350                  let Ann_big = toBigInt((amp * N_COINS))
343 351                  func S_c (acc,index) =                 {
344 -                     let $t068106829 = acc
345 -                     let S_ = $t068106829._1
346 -                     let c = $t068106829._2
352 +                     let $t069036922 = acc
353 +                     let S_ = $t069036922._1
354 +                     let c = $t069036922._2
347 355                      let x_ = if ((index == i))
348 356                          then toBigInt(fraction(x, TOKEN_RATE, rates[index]))
349 357                          else xp[index]
350 358                      if ((index != j))
351 359                          then $Tuple2((S_ + x_), fraction(c, D_big, fraction(x_, N_COINS_big, big1)))
352 360                          else $Tuple2(S_, c)
353 361                      }
354 362  
355 -                 let $t071057169 = {
363 +                 let $t071987262 = {
356 364                      let $l = index_N_COINS
357 365                      let $s = size($l)
358 366                      let $acc0 = $Tuple2(big0, D_big)
359 367                      func $f0_1 ($a,$i) =                     if (($i >= $s))
360 368                          then $a
361 369                          else S_c($a, $l[$i])
362 370  
363 371                      func $f0_2 ($a,$i) =                     if (($i >= $s))
364 372                          then $a
365 373                          else throw("List size exceeds 10")
366 374  
367 375                      $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
368 376                      }
369 -                 let S_ = $t071057169._1
370 -                 let c_ = $t071057169._2
377 +                 let S_ = $t071987262._1
378 +                 let c_ = $t071987262._2
371 379                  let c = fraction(c_, D_big, fraction(Ann_big, N_COINS_big, big1))
372 380                  let bD = ((S_ + fraction(D_big, big1, Ann_big)) - D_big)
373 381                  func y_proc (acc,unused) =                 if ((acc._2 == true))
374 382                      then acc
375 383                      else {
376 384                          let y_prev = acc._1
377 385                          let y = fraction((fraction(y_prev, y_prev, big1) + c), big1, (fraction(big2, y_prev, big1) + bD))
378 386                          if ((y > y_prev))
379 387                              then if ((1 >= toInt((y - y_prev))))
380 388                                  then $Tuple2(y, true)
381 389                                  else $Tuple2(y, false)
382 390                              else if ((1 >= toInt((y_prev - y))))
383 391                                  then $Tuple2(y, true)
384 392                                  else $Tuple2(y, false)
385 393                          }
386 394  
387 -                 let $t077497815 = {
395 +                 let $t078427908 = {
388 396                      let $l = list16
389 397                      let $s = size($l)
390 398                      let $acc0 = $Tuple2(D_big, false)
391 399                      func $f1_1 ($a,$i) =                     if (($i >= $s))
392 400                          then $a
393 401                          else y_proc($a, $l[$i])
394 402  
395 403                      func $f1_2 ($a,$i) =                     if (($i >= $s))
396 404                          then $a
397 405                          else throw("List size exceeds 16")
398 406  
399 407                      $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
400 408                      }
401 -                 let y = $t077497815._1
402 -                 let finished = $t077497815._2
409 +                 let y = $t078427908._1
410 +                 let finished = $t078427908._2
403 411                  if ((finished == false))
404 412                      then throw(("y_proc() not finished with " + toString(y)))
405 413                      else $Tuple2(fraction(toInt(y), rates[j], TOKEN_RATE), D)
406 414                  }
407 415  
408 416  
409 417  func get_y_D (amp,i,xp,D) = if (assert((i >= 0)))
410 418      then throw("i below zero")
411 419      else if (assert((N_COINS > i)))
412 420          then throw("i above N_COINS")
413 421          else {
414 422              let D_big = toBigInt(D)
415 423              let Ann_big = toBigInt((amp * N_COINS))
416 424              func S_c (acc,index) =             {
417 -                 let $t083208339 = acc
418 -                 let S_ = $t083208339._1
419 -                 let c = $t083208339._2
425 +                 let $t084138432 = acc
426 +                 let S_ = $t084138432._1
427 +                 let c = $t084138432._2
420 428                  let x_ = if ((index == i))
421 429                      then big0
422 430                      else xp[index]
423 431                  if ((index != i))
424 432                      then $Tuple2((S_ + x_), fraction(c, D_big, fraction(x_, N_COINS_big, big1)))
425 433                      else $Tuple2(S_, c)
426 434                  }
427 435  
428 -             let $t085698633 = {
436 +             let $t086628726 = {
429 437                  let $l = index_N_COINS
430 438                  let $s = size($l)
431 439                  let $acc0 = $Tuple2(big0, D_big)
432 440                  func $f0_1 ($a,$i) =                 if (($i >= $s))
433 441                      then $a
434 442                      else S_c($a, $l[$i])
435 443  
436 444                  func $f0_2 ($a,$i) =                 if (($i >= $s))
437 445                      then $a
438 446                      else throw("List size exceeds 10")
439 447  
440 448                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
441 449                  }
442 -             let S_ = $t085698633._1
443 -             let c_ = $t085698633._2
450 +             let S_ = $t086628726._1
451 +             let c_ = $t086628726._2
444 452              let c = fraction(c_, D_big, fraction(Ann_big, N_COINS_big, big1))
445 453              let bD = ((S_ + fraction(D_big, big1, Ann_big)) - D_big)
446 454              func y_proc (acc,unused) =             if ((acc._2 == true))
447 455                  then acc
448 456                  else {
449 457                      let y_prev = acc._1
450 458                      let y = fraction((fraction(y_prev, y_prev, big1) + c), big1, (fraction(big2, y_prev, big1) + bD))
451 459                      if ((y > y_prev))
452 460                          then if ((1 >= toInt((y - y_prev))))
453 461                              then $Tuple2(y, true)
454 462                              else $Tuple2(y, false)
455 463                          else if ((1 >= toInt((y_prev - y))))
456 464                              then $Tuple2(y, true)
457 465                              else $Tuple2(y, false)
458 466                      }
459 467  
460 -             let $t092139279 = {
468 +             let $t093069372 = {
461 469                  let $l = list16
462 470                  let $s = size($l)
463 471                  let $acc0 = $Tuple2(D_big, false)
464 472                  func $f1_1 ($a,$i) =                 if (($i >= $s))
465 473                      then $a
466 474                      else y_proc($a, $l[$i])
467 475  
468 476                  func $f1_2 ($a,$i) =                 if (($i >= $s))
469 477                      then $a
470 478                      else throw("List size exceeds 16")
471 479  
472 480                  $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
473 481                  }
474 -             let y = $t092139279._1
475 -             let finished = $t092139279._2
482 +             let y = $t093069372._1
483 +             let finished = $t093069372._2
476 484              if ((finished == false))
477 485                  then throw(("y_proc() not finished with " + toString(y)))
478 486                  else fraction(toInt(y), rates[i], TOKEN_RATE)
479 487              }
480 488  
481 489  
482 490  func _calc_withdraw_one_coin (_token_amount,i) = {
483 491      let xp = big_list(balances)
484 492      let D0 = get_D(xp, amp)
485 493      let D1 = (D0 - fraction(_token_amount, D0, token_quantity))
486 494      let new_y = get_y_D(amp, i, xp, D1)
487 495      let dy_0 = (balances[i] - new_y)
488 496      func fold (acc,index) =     {
489 497          let xp_j = balances[index]
490 498          let dx_expected = if ((index == i))
491 499              then (fraction(xp_j, D1, D0) - new_y)
492 500              else (xp_j - fraction(xp_j, D1, D0))
493 501          (acc :+ (xp_j - fraction(N_fee_4, dx_expected, FEE_DENOMINATOR)))
494 502          }
495 503  
496 504      let xp_reduced = {
497 505          let $l = index_N_COINS
498 506          let $s = size($l)
499 507          let $acc0 = nil
500 508          func $f0_1 ($a,$i) =         if (($i >= $s))
501 509              then $a
502 510              else fold($a, $l[$i])
503 511  
504 512          func $f0_2 ($a,$i) =         if (($i >= $s))
505 513              then $a
506 514              else throw("List size exceeds 10")
507 515  
508 516          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
509 517          }
510 518      let xp_reduced_i = xp_reduced[i]
511 519      let dy = ((xp_reduced_i - get_y_D(amp, i, big_list(xp_reduced), D1)) - 1)
512 520      $Tuple3(dy, (dy_0 - dy), D0)
513 521      }
514 522  
515 523  
516 524  func virtual_price (D) = fraction(D, VP_PRECISION, token_quantity)
517 525  
518 526  
519 527  func log_data (D,add) = {
520 528      let total_vol = (parseBigIntValue(valueOrElse(getString("vol"), "0")) + toBigInt(add))
521 529      let total_vol_string = toString(total_vol)
522 530      ([StringEntry("vol", total_vol_string)] ++ {
523 531          let log_period = toString((lastBlock.timestamp / VP_LOG_PERIOD))
524 532          let log_key = ("log_" + log_period)
525 533          if (isDefined(getString(log_key)))
526 534              then nil
527 535              else [StringEntry(log_key, ((((toString(virtual_price(D)) + "_") + total_vol_string) + "_") + toString(lastBlock.timestamp)))]
528 536          })
529 537      }
530 538  
531 539  
532 540  func get_nearest_log (period) = {
533 541      func fold (log_value,step) =     if ((log_value != ""))
534 542          then log_value
535 543          else {
536 544              let log_key = ("log_" + toString((period - step)))
537 545              valueOrElse(getString(log_key), "")
538 546              }
539 547  
540 548      let list30p = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
541 549      let list30m = [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20, -21, -22, -23, -24, -25, -26, -27, -28, -29, -30]
542 550      let value30p = {
543 551          let $l = list30p
544 552          let $s = size($l)
545 553          let $acc0 = ""
546 554          func $f0_1 ($a,$i) =         if (($i >= $s))
547 555              then $a
548 556              else fold($a, $l[$i])
549 557  
550 558          func $f0_2 ($a,$i) =         if (($i >= $s))
551 559              then $a
552 560              else throw("List size exceeds 30")
553 561  
554 562          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30)
555 563          }
556 564      if ((value30p != ""))
557 565          then value30p
558 566          else {
559 567              let $l = list30m
560 568              let $s = size($l)
561 569              let $acc0 = ""
562 570              func $f1_1 ($a,$i) =             if (($i >= $s))
563 571                  then $a
564 572                  else fold($a, $l[$i])
565 573  
566 574              func $f1_2 ($a,$i) =             if (($i >= $s))
567 575                  then $a
568 576                  else throw("List size exceeds 30")
569 577  
570 578              $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30)
571 579              }
572 580      }
573 581  
574 582  
575 583  func get_virtual_price_diff (_t0) = {
576 584      let vp1 = virtual_price(get_D(big_list(balances), amp))
577 585      let vp1_timestamp = lastBlock.timestamp
578 586      let t0 = if ((0 >= _t0))
579 587          then (vp1_timestamp + _t0)
580 588          else _t0
581 589      let t0_period = (t0 / VP_LOG_PERIOD)
582 590      let log_value = get_nearest_log(t0_period)
583 591      if ((log_value == ""))
584 592          then $Tuple3(vp1, vp1, 0)
585 593          else {
586 594              let log_list = split(log_value, "_")
587 595              let vp0 = parseIntValue(log_list[0])
588 596              let vp0_timestamp = parseIntValue(log_list[2])
589 597              $Tuple3(vp1, vp0, (vp1_timestamp - vp0_timestamp))
590 598              }
591 599      }
592 600  
593 601  
594 602  func get_volume_diff (_t0) = {
595 603      let vol1 = parseBigIntValue(valueOrElse(getString("vol"), "0"))
596 604      let vol1_timestamp = lastBlock.timestamp
597 605      let t0 = if ((0 >= _t0))
598 606          then (vol1_timestamp + _t0)
599 607          else _t0
600 608      let t0_period = (t0 / VP_LOG_PERIOD)
601 609      let log_value = get_nearest_log(t0_period)
602 610      if ((log_value == ""))
603 611          then $Tuple3(vol1, vol1, 0)
604 612          else {
605 613              let log_list = split(log_value, "_")
606 614              let vol0 = parseBigIntValue(log_list[1])
607 615              let vol0_timestamp = parseIntValue(log_list[2])
608 616              $Tuple3(vol1, vol0, (vol1_timestamp - vol0_timestamp))
609 617              }
610 618      }
611 619  
612 620  
613 621  func _calc_token_amount (new_balances) = {
614 622      let D0 = if ((token_quantity == 0))
615 623          then 0
616 624          else get_D(big_list(balances), amp)
617 625      let D1 = get_D(big_list(new_balances), amp)
618 626      if (assert((D1 > D0)))
619 627          then throw("D1 > D0")
620 628          else {
621 -             let $t01295914909 = if ((token_quantity > 0))
629 +             let $t01305215002 = if ((token_quantity > 0))
622 630                  then {
623 631                      func fee_balances (old,new) =                     {
624 632                          func fold (acc,index) =                         {
625 633                              let old_balance = old[index]
626 634                              let new_balance = new[index]
627 635                              let ideal_balance = fraction(D1, old_balance, D0)
628 636                              let difference = if ((ideal_balance > new_balance))
629 637                                  then (ideal_balance - new_balance)
630 638                                  else (new_balance - ideal_balance)
631 639                              let amount_fee = fraction(N_fee_4, difference, FEE_DENOMINATOR)
632 640                              let amount_admin_fee = fraction(amount_fee, admin_fee, FEE_DENOMINATOR)
633 641                              $Tuple4((acc._1 :+ (new_balance - amount_admin_fee)), (acc._2 :+ (new_balance - amount_fee)), if (if (is_auto_fees)
634 642                                  then (amount_admin_fee > 0)
635 643                                  else false)
636 644                                  then (acc._3 :+ ScriptTransfer(owner, amount_admin_fee, fromBase58String(coins[index])))
637 645                                  else acc._3, (acc._4 + fraction(amount_fee, TOKEN_RATE, rates[index])))
638 646                              }
639 647  
640 648                          let $l = index_N_COINS
641 649                          let $s = size($l)
642 650                          let $acc0 = $Tuple4(nil, nil, nil, 0)
643 651                          func $f0_1 ($a,$i) =                         if (($i >= $s))
644 652                              then $a
645 653                              else fold($a, $l[$i])
646 654  
647 655                          func $f0_2 ($a,$i) =                         if (($i >= $s))
648 656                              then $a
649 657                              else throw("List size exceeds 10")
650 658  
651 659                          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
652 660                          }
653 661  
654 -                     let $t01443314515 = fee_balances(balances, new_balances)
655 -                     let finals = $t01443314515._1
656 -                     let no_fees = $t01443314515._2
657 -                     let actions = $t01443314515._3
658 -                     let fee_sum = $t01443314515._4
662 +                     let $t01452614608 = fee_balances(balances, new_balances)
663 +                     let finals = $t01452614608._1
664 +                     let no_fees = $t01452614608._2
665 +                     let actions = $t01452614608._3
666 +                     let fee_sum = $t01452614608._4
659 667                      $Tuple3(finals, get_D(big_list(no_fees), amp), (actions ++ log_data(D0, if ((fee == 0))
660 668                          then 0
661 669                          else fraction(fee_sum, FEE_DENOMINATOR, fee))))
662 670                      }
663 671                  else $Tuple3(new_balances, D1, nil)
664 -             let final_balances = $t01295914909._1
665 -             let D2 = $t01295914909._2
666 -             let fees_actions = $t01295914909._3
672 +             let final_balances = $t01305215002._1
673 +             let D2 = $t01305215002._2
674 +             let fees_actions = $t01305215002._3
667 675              let mint_amount = if ((token_quantity == 0))
668 676                  then D1
669 677                  else fraction(token_quantity, (D2 - D0), D0)
670 678              $Tuple3(final_balances, mint_amount, fees_actions)
671 679              }
672 680      }
673 681  
674 682  
675 683  @Callable(msg)
676 684  func init (_owner,_coins,_pool_token,_A,_fee,_admin_fee) = if (isDefined(getString(this, "token")))
677 685      then throw("already initialized")
678 686      else if ((msg.caller != this))
679 687          then throw("self initialization only")
680 688          else {
681 689              let coins_list = split(_coins, ",")
682 690              let n = size(coins_list)
683 691              if ((2 > n))
684 692                  then throw("too small coins")
685 693                  else if ((n > N_COINS_MAX))
686 694                      then throw("too many coins")
687 695                      else {
688 696                          func duplicates (acc,index) =                         if (if ((index >= n))
689 697                              then true
690 698                              else (acc == false))
691 699                              then acc
692 700                              else (indexOf(coins_list, coins_list[index]) == index)
693 701  
694 702                          if ((false == {
695 703                              let $l = index_N_COINS_MAX
696 704                              let $s = size($l)
697 705                              let $acc0 = true
698 706                              func $f0_1 ($a,$i) =                             if (($i >= $s))
699 707                                  then $a
700 708                                  else duplicates($a, $l[$i])
701 709  
702 710                              func $f0_2 ($a,$i) =                             if (($i >= $s))
703 711                                  then $a
704 712                                  else throw("List size exceeds 10")
705 713  
706 714                              $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
707 715                              }))
708 716                              then throw("duplicate coin detected")
709 717                              else {
710 718                                  func decimals (coin) =                                 valueOrErrorMessage(assetInfo(valueOrErrorMessage(fromBase58String(coin), ("fromBase58String: " + coin))), ("assetInfo: " + coin)).decimals
711 719  
712 720                                  func fold (acc,coin) =                                 $Tuple3((acc._1 + 1), (acc._2 :+ 0), (acc._3 :+ pow(10, 0, decimals(coin), 0, 0, DOWN)))
713 721  
714 -                                 let $t01617016265 = {
722 +                                 let $t01626316358 = {
715 723                                      let $l = coins_list
716 724                                      let $s = size($l)
717 725                                      let $acc0 = $Tuple3(0, nil, nil)
718 726                                      func $f0_1 ($a,$i) =                                     if (($i >= $s))
719 727                                          then $a
720 728                                          else fold($a, $l[$i])
721 729  
722 730                                      func $f0_2 ($a,$i) =                                     if (($i >= $s))
723 731                                          then $a
724 732                                          else throw("List size exceeds 10")
725 733  
726 734                                      $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
727 735                                      }
728 -                                 let _N_COINS = $t01617016265._1
729 -                                 let zeros = $t01617016265._2
730 -                                 let _rates = $t01617016265._3
736 +                                 let _N_COINS = $t01626316358._1
737 +                                 let zeros = $t01626316358._2
738 +                                 let _rates = $t01626316358._3
731 739                                  let issueToken = Issue(_pool_token, ("LP token for " + _coins), 0, TOKEN_DECIMALS, true)
732 740                                  let tokenId = toBase58String(calculateAssetId(issueToken))
733 741  [StringEntry("coins", _coins), StringEntry("rates", makeString(list_itos(_rates), ",")), StringEntry("balances", makeString(list_itos(zeros), ",")), IntegerEntry("N_COINS", _N_COINS), IntegerEntry("initial_A", _A), IntegerEntry("future_A", _A), IntegerEntry("fee", _fee), IntegerEntry("admin_fee", _admin_fee), StringEntry("owner", checkAddress(_owner)), IntegerEntry("kill_deadline", (height + KILL_DEADLINE_DT)), StringEntry("token", tokenId), BooleanEntry("is_killed", false), BooleanEntry("is_auto_fees", true), issueToken]
734 742                                  }
735 743                          }
736 744              }
737 745  
738 746  
739 747  
740 748  @Callable(msg)
741 - func add_liquidity (min_mint_amount) = if (!(allowed(msg.caller)))
742 -     then throw("!allowed")
749 + func add_liquidity (min_mint_amount) = if (!(serialized()))
750 +     then throw()
743 751      else if (assert(!(is_killed)))
744 752          then throw("is killed")
745 753          else {
746 754              func update_1_balance (base,target,amount) =             {
747 755                  func fold (acc,index) =                 (acc :+ (base[index] + (if ((index == target))
748 756                      then amount
749 757                      else 0)))
750 758  
751 759                  let $l = index_N_COINS
752 760                  let $s = size($l)
753 761                  let $acc0 = nil
754 762                  func $f0_1 ($a,$i) =                 if (($i >= $s))
755 763                      then $a
756 764                      else fold($a, $l[$i])
757 765  
758 766                  func $f0_2 ($a,$i) =                 if (($i >= $s))
759 767                      then $a
760 768                      else throw("List size exceeds 10")
761 769  
762 770                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
763 771                  }
764 772  
765 773              func up_balances (base,payments) =             {
766 774                  let n = size(payments)
767 775                  if ((1 > n))
768 776                      then throw("payments size < 1")
769 777                      else if ((n > N_COINS_MAX))
770 778                          then throw("payments size > N_COINS_MAX")
771 779                          else {
772 780                              func fold (acc,payment) =                             update_1_balance(acc, coin_index(payment), payment.amount)
773 781  
774 782                              let $l = payments
775 783                              let $s = size($l)
776 784                              let $acc0 = base
777 785                              func $f0_1 ($a,$i) =                             if (($i >= $s))
778 786                                  then $a
779 787                                  else fold($a, $l[$i])
780 788  
781 789                              func $f0_2 ($a,$i) =                             if (($i >= $s))
782 790                                  then $a
783 791                                  else throw("List size exceeds 10")
784 792  
785 793                              $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
786 794                              }
787 795                  }
788 796  
789 797              let new_balances = up_balances(balances, msg.payments)
790 798              if (if ((token_quantity == 0))
791 799                  then (min(new_balances) == 0)
792 800                  else false)
793 801                  then throw("initial deposit requires all coins")
794 802                  else {
795 -                     let $t01820918295 = _calc_token_amount(new_balances)
796 -                     let final_balances = $t01820918295._1
797 -                     let mint_amount = $t01820918295._2
798 -                     let fees_actions = $t01820918295._3
803 +                     let $t01828118367 = _calc_token_amount(new_balances)
804 +                     let final_balances = $t01828118367._1
805 +                     let mint_amount = $t01828118367._2
806 +                     let fees_actions = $t01828118367._3
799 807                      if (assert((mint_amount >= min_mint_amount)))
800 808                          then throw("slippage screwed you")
801 809                          else ([StringEntry("balances", makeString(list_itos(final_balances), ",")), Reissue(token, mint_amount, true), ScriptTransfer(msg.caller, mint_amount, token)] ++ fees_actions)
802 810                      }
803 811              }
804 812  
805 813  
806 814  
807 815  @Callable(msg)
808 816  func get_dy (i,j,dx) = {
809 817      let xp_i = balances[i]
810 818      let xp_j = balances[j]
811 819      let x = (xp_i + dx)
812 -     let $t01875518808 = get_y(i, j, x, big_list(balances))
813 -     let y = $t01875518808._1
814 -     let D = $t01875518808._2
820 +     let $t01882718880 = get_y(i, j, x, big_list(balances))
821 +     let y = $t01882718880._1
822 +     let D = $t01882718880._2
815 823      let _dy = ((xp_j - y) - 1)
816 824      let dy_fee = fraction(_dy, fee, FEE_DENOMINATOR)
817 825      let dy = (_dy - dy_fee)
818 826      $Tuple2(nil, dy)
819 827      }
820 828  
821 829  
822 830  
823 831  @Callable(msg)
824 832  func exchange (j,min_dy) = if (!(allowed(msg.caller)))
825 833      then throw("!allowed")
826 834      else if (assert(!(is_killed)))
827 835          then throw("is killed")
828 836          else if ((size(msg.payments) != 1))
829 837              then throw("size( payments ) != 1")
830 838              else {
831 839                  let payment = msg.payments[0]
832 840                  let dx = payment.amount
833 841                  let i = coin_index(payment)
834 842                  let xp_i = balances[i]
835 843                  let xp_j = balances[j]
836 844                  let x = (xp_i + dx)
837 -                 let $t01937719430 = get_y(i, j, x, big_list(balances))
838 -                 let y = $t01937719430._1
839 -                 let D = $t01937719430._2
845 +                 let $t01944919502 = get_y(i, j, x, big_list(balances))
846 +                 let y = $t01944919502._1
847 +                 let D = $t01944919502._2
840 848                  let _dy = ((xp_j - y) - 1)
841 849                  let dy_fee = fraction(_dy, fee, FEE_DENOMINATOR)
842 850                  let dy = (_dy - dy_fee)
843 851                  if (assert((dy >= min_dy)))
844 852                      then throw("exchange resulted in fewer coins than expected")
845 853                      else {
846 854                          let dy_admin_fee = fraction(dy_fee, admin_fee, FEE_DENOMINATOR)
847 855                          func fold (acc,index) =                         (acc :+ (if ((index == i))
848 856                              then (balances[index] + dx)
849 857                              else if ((index == j))
850 858                                  then ((balances[index] - dy) - dy_admin_fee)
851 859                                  else balances[index]))
852 860  
853 861                          let final_balances = {
854 862                              let $l = index_N_COINS
855 863                              let $s = size($l)
856 864                              let $acc0 = nil
857 865                              func $f0_1 ($a,$i) =                             if (($i >= $s))
858 866                                  then $a
859 867                                  else fold($a, $l[$i])
860 868  
861 869                              func $f0_2 ($a,$i) =                             if (($i >= $s))
862 870                                  then $a
863 871                                  else throw("List size exceeds 10")
864 872  
865 873                              $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
866 874                              }
867 875                          let tokenOut = fromBase58String(coins[j])
868 876                          $Tuple2((([StringEntry("balances", makeString(list_itos(final_balances), ",")), ScriptTransfer(msg.caller, dy, tokenOut)] ++ (if (if (is_auto_fees)
869 877                              then (dy_admin_fee > 0)
870 878                              else false)
871 879                              then [ScriptTransfer(owner, dy_admin_fee, tokenOut)]
872 880                              else nil)) ++ log_data(D, if ((fee == 0))
873 881                              then 0
874 882                              else fraction(fraction(dy_fee, TOKEN_RATE, rates[j]), FEE_DENOMINATOR, fee))), dy)
875 883                          }
876 884                  }
877 885  
878 886  
879 887  
880 888  @Callable(msg)
881 - func remove_liquidity (_min_amounts) = if ((size(msg.payments) != 1))
882 -     then throw("size( payments ) != 1")
883 -     else {
884 -         let payment = msg.payments[0]
885 -         if ((payment.assetId != token))
886 -             then throw("unknown token")
887 -             else {
888 -                 let min_amounts = if ((_min_amounts == "0"))
889 -                     then nil
890 -                     else list_stoi(split(_min_amounts, ","))
891 -                 if (if ((_min_amounts != "0"))
892 -                     then (size(min_amounts) != N_COINS)
893 -                     else false)
894 -                     then throw("min_amounts.size() != N_COINS")
895 -                     else {
896 -                         let amount = payment.amount
897 -                         let caller = msg.caller
898 -                         func fold (acc,index) =                         {
899 -                             let balance = balances[index]
900 -                             let amount_out = fraction(balance, amount, token_quantity)
901 -                             if (if ((_min_amounts != "0"))
902 -                                 then (min_amounts[index] > amount_out)
903 -                                 else false)
904 -                                 then throw("withdrawal resulted in fewer coins than expected")
905 -                                 else $Tuple2((acc._1 :+ ScriptTransfer(caller, amount_out, fromBase58String(coins[index]))), (acc._2 :+ (balance - amount_out)))
889 + func remove_liquidity (_min_amounts) = if (!(serialized()))
890 +     then throw()
891 +     else if ((size(msg.payments) != 1))
892 +         then throw("size( payments ) != 1")
893 +         else {
894 +             let payment = msg.payments[0]
895 +             if ((payment.assetId != token))
896 +                 then throw("unknown token")
897 +                 else {
898 +                     let min_amounts = if ((_min_amounts == "0"))
899 +                         then nil
900 +                         else list_stoi(split(_min_amounts, ","))
901 +                     if (if ((_min_amounts != "0"))
902 +                         then (size(min_amounts) != N_COINS)
903 +                         else false)
904 +                         then throw("min_amounts.size() != N_COINS")
905 +                         else {
906 +                             let amount = payment.amount
907 +                             let caller = msg.caller
908 +                             func fold (acc,index) =                             {
909 +                                 let balance = balances[index]
910 +                                 let amount_out = fraction(balance, amount, token_quantity)
911 +                                 if (if ((_min_amounts != "0"))
912 +                                     then (min_amounts[index] > amount_out)
913 +                                     else false)
914 +                                     then throw("withdrawal resulted in fewer coins than expected")
915 +                                     else $Tuple2((acc._1 :+ ScriptTransfer(caller, amount_out, fromBase58String(coins[index]))), (acc._2 :+ (balance - amount_out)))
916 +                                 }
917 + 
918 +                             let $t02172921808 = {
919 +                                 let $l = index_N_COINS
920 +                                 let $s = size($l)
921 +                                 let $acc0 = $Tuple2(nil, nil)
922 +                                 func $f0_1 ($a,$i) =                                 if (($i >= $s))
923 +                                     then $a
924 +                                     else fold($a, $l[$i])
925 + 
926 +                                 func $f0_2 ($a,$i) =                                 if (($i >= $s))
927 +                                     then $a
928 +                                     else throw("List size exceeds 10")
929 + 
930 +                                 $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
931 +                                 }
932 +                             let transfers = $t02172921808._1
933 +                             let final_balances = $t02172921808._2
934 +                             (transfers ++ [StringEntry("balances", makeString(list_itos(final_balances), ",")), Burn(token, amount)])
906 935                              }
907 - 
908 -                         let $t02161521694 = {
909 -                             let $l = index_N_COINS
910 -                             let $s = size($l)
911 -                             let $acc0 = $Tuple2(nil, nil)
912 -                             func $f0_1 ($a,$i) =                             if (($i >= $s))
913 -                                 then $a
914 -                                 else fold($a, $l[$i])
915 - 
916 -                             func $f0_2 ($a,$i) =                             if (($i >= $s))
917 -                                 then $a
918 -                                 else throw("List size exceeds 10")
919 - 
920 -                             $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
921 -                             }
922 -                         let transfers = $t02161521694._1
923 -                         let final_balances = $t02161521694._2
924 -                         (transfers ++ [StringEntry("balances", makeString(list_itos(final_balances), ",")), Burn(token, amount)])
925 -                         }
926 -                 }
927 -         }
936 +                     }
937 +             }
928 938  
929 939  
930 940  
931 941  @Callable(msg)
932 942  func calc_withdraw_one_coin (_token_amount,i) = $Tuple2(nil, _calc_withdraw_one_coin(_token_amount, i)._1)
933 943  
934 944  
935 945  
936 946  @Callable(msg)
937 947  func remove_liquidity_one_coin (i,min_amount) = if (!(allowed(msg.caller)))
938 948      then throw("!allowed")
939 949      else if (assert(!(is_killed)))
940 950          then throw("is killed")
941 951          else if ((size(msg.payments) != 1))
942 952              then throw("size( payments ) != 1")
943 953              else {
944 954                  let payment = msg.payments[0]
945 955                  if ((payment.assetId != token))
946 956                      then throw("unknown token")
947 957                      else {
948 958                          let _token_amount = payment.amount
949 -                         let $t02241822485 = _calc_withdraw_one_coin(_token_amount, i)
950 -                         let dy = $t02241822485._1
951 -                         let dy_fee = $t02241822485._2
952 -                         let D = $t02241822485._3
959 +                         let $t02253222599 = _calc_withdraw_one_coin(_token_amount, i)
960 +                         let dy = $t02253222599._1
961 +                         let dy_fee = $t02253222599._2
962 +                         let D = $t02253222599._3
953 963                          if (assert((dy >= min_amount)))
954 964                              then throw("not enough coins removed")
955 965                              else {
956 966                                  let dy_admin_fee = fraction(dy_fee, admin_fee, FEE_DENOMINATOR)
957 967                                  let dy_and_fee = (dy + dy_admin_fee)
958 968                                  func fold (acc,index) =                                 (acc :+ (balances[index] - (if ((index == i))
959 969                                      then dy_and_fee
960 970                                      else 0)))
961 971  
962 972                                  let final_balances = {
963 973                                      let $l = index_N_COINS
964 974                                      let $s = size($l)
965 975                                      let $acc0 = nil
966 976                                      func $f0_1 ($a,$i) =                                     if (($i >= $s))
967 977                                          then $a
968 978                                          else fold($a, $l[$i])
969 979  
970 980                                      func $f0_2 ($a,$i) =                                     if (($i >= $s))
971 981                                          then $a
972 982                                          else throw("List size exceeds 10")
973 983  
974 984                                      $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
975 985                                      }
976 986                                  let tokenOut = fromBase58String(coins[i])
977 987                                  $Tuple2((([StringEntry("balances", makeString(list_itos(final_balances), ",")), ScriptTransfer(msg.caller, dy, tokenOut), Burn(token, _token_amount)] ++ (if (if (is_auto_fees)
978 988                                      then (dy_admin_fee > 0)
979 989                                      else false)
980 990                                      then [ScriptTransfer(owner, dy_admin_fee, tokenOut)]
981 991                                      else nil)) ++ log_data(D, if ((fee == 0))
982 992                                      then 0
983 993                                      else fraction(fraction(dy_fee, TOKEN_RATE, rates[i]), FEE_DENOMINATOR, fee))), dy)
984 994                                  }
985 995                          }
986 996                  }
987 997  
988 998  
989 999  
990 1000  @Callable(msg)
991 1001  func A () = $Tuple2(nil, amp)
992 1002  
993 1003  
994 1004  
995 1005  @Callable(msg)
996 1006  func get_virtual_price () = {
997 1007      let D = get_D(big_list(balances), amp)
998 1008      $Tuple2(nil, virtual_price(D))
999 1009      }
1000 1010  
1001 1011  
1002 1012  
1003 1013  @Callable(msg)
1004 1014  func calc_token_amount (_amounts) = {
1005 1015      let amounts = list_stoi(split(_amounts, ","))
1006 1016      if ((size(amounts) != N_COINS))
1007 1017          then throw("not enought amounts")
1008 1018          else {
1009 1019              func fold (acc,index) =             (acc :+ (balances[index] + amounts[index]))
1010 1020  
1011 1021              let new_balances = {
1012 1022                  let $l = index_N_COINS
1013 1023                  let $s = size($l)
1014 1024                  let $acc0 = nil
1015 1025                  func $f0_1 ($a,$i) =                 if (($i >= $s))
1016 1026                      then $a
1017 1027                      else fold($a, $l[$i])
1018 1028  
1019 1029                  func $f0_2 ($a,$i) =                 if (($i >= $s))
1020 1030                      then $a
1021 1031                      else throw("List size exceeds 10")
1022 1032  
1023 1033                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1024 1034                  }
1025 -             let $t02396324049 = _calc_token_amount(new_balances)
1026 -             let final_balances = $t02396324049._1
1027 -             let mint_amount = $t02396324049._2
1028 -             let fees_actions = $t02396324049._3
1035 +             let $t02407724163 = _calc_token_amount(new_balances)
1036 +             let final_balances = $t02407724163._1
1037 +             let mint_amount = $t02407724163._2
1038 +             let fees_actions = $t02407724163._3
1029 1039              $Tuple2(nil, mint_amount)
1030 1040              }
1031 1041      }
1032 1042  
1033 1043  
1034 1044  
1035 1045  @Callable(msg)
1036 1046  func ramp_A (_future_A,_future_time) = if (assert((msg.caller == owner)))
1037 1047      then throw("only owner")
1038 1048      else if (assert(if ((initial_A_time == 0))
1039 1049          then true
1040 1050          else (block_timestamp >= (initial_A_time + MIN_RAMP_TIME))))
1041 1051          then throw("too often")
1042 1052          else if (assert((_future_time >= (block_timestamp + MIN_RAMP_TIME))))
1043 1053              then throw("insufficient time")
1044 1054              else {
1045 1055                  let _initial_A = amp
1046 1056                  if (assert(if ((_future_A > 0))
1047 1057                      then (MAX_A > _future_A)
1048 1058                      else false))
1049 1059                      then throw("out of base range")
1050 1060                      else if (assert(if (if ((_future_A >= _initial_A))
1051 1061                          then ((_initial_A * MAX_A_CHANGE) >= _future_A)
1052 1062                          else false)
1053 1063                          then true
1054 1064                          else if ((_initial_A > _future_A))
1055 1065                              then ((_future_A * MAX_A_CHANGE) >= _initial_A)
1056 1066                              else false))
1057 1067                          then throw("out of range")
1058 1068                          else [IntegerEntry("initial_A", _initial_A), IntegerEntry("future_A", _future_A), IntegerEntry("initial_A_time", block_timestamp), IntegerEntry("future_A_time", _future_time)]
1059 1069                  }
1060 1070  
1061 1071  
1062 1072  
1063 1073  @Callable(msg)
1064 1074  func stop_ramp_A () = if (assert((msg.caller == owner)))
1065 1075      then throw("only owner")
1066 1076      else {
1067 1077          let current_A = amp
1068 1078  [IntegerEntry("initial_A", current_A), IntegerEntry("future_A", current_A), IntegerEntry("initial_A_time", block_timestamp), IntegerEntry("future_A_time", block_timestamp)]
1069 1079          }
1070 1080  
1071 1081  
1072 1082  
1073 1083  @Callable(msg)
1074 1084  func commit_new_fee (new_fee,new_admin_fee) = if (assert((msg.caller == owner)))
1075 1085      then throw("only owner")
1076 1086      else if (assert((admin_actions_deadline == 0)))
1077 1087          then throw("active action")
1078 1088          else if (assert((MAX_FEE >= new_fee)))
1079 1089              then throw("fee exceeds maximum")
1080 1090              else if (assert((MAX_ADMIN_FEE >= new_admin_fee)))
1081 1091                  then throw("admin fee exceeds maximum")
1082 1092                  else {
1083 1093                      let _deadline = (block_timestamp + ADMIN_ACTIONS_DELAY)
1084 1094  [IntegerEntry("admin_actions_deadline", _deadline), IntegerEntry("future_fee", new_fee), IntegerEntry("future_admin_fee", new_admin_fee)]
1085 1095                      }
1086 1096  
1087 1097  
1088 1098  
1089 1099  @Callable(msg)
1090 1100  func apply_new_fee () = if (assert((msg.caller == owner)))
1091 1101      then throw("only owner")
1092 1102      else if (assert((block_timestamp >= admin_actions_deadline)))
1093 1103          then throw("insufficient time")
1094 1104          else if (assert((admin_actions_deadline != 0)))
1095 1105              then throw("no active action")
1096 1106              else [IntegerEntry("admin_actions_deadline", 0), IntegerEntry("fee", future_fee), IntegerEntry("admin_fee", future_admin_fee)]
1097 1107  
1098 1108  
1099 1109  
1100 1110  @Callable(msg)
1101 1111  func revert_new_parameters () = if (assert((msg.caller == owner)))
1102 1112      then throw("only owner")
1103 1113      else [IntegerEntry("admin_actions_deadline", 0)]
1104 1114  
1105 1115  
1106 1116  
1107 1117  @Callable(msg)
1108 1118  func commit_transfer_ownership (_owner) = if (assert((msg.caller == owner)))
1109 1119      then throw("only owner")
1110 1120      else if (assert((transfer_ownership_deadline == 0)))
1111 1121          then throw("active transfer")
1112 1122          else {
1113 1123              let _deadline = (block_timestamp + ADMIN_ACTIONS_DELAY)
1114 1124  [IntegerEntry("transfer_ownership_deadline", _deadline), StringEntry("future_owner", checkAddress(_owner))]
1115 1125              }
1116 1126  
1117 1127  
1118 1128  
1119 1129  @Callable(msg)
1120 1130  func apply_transfer_ownership () = if (assert((msg.caller == owner)))
1121 1131      then throw("only owner")
1122 1132      else if (assert((block_timestamp >= transfer_ownership_deadline)))
1123 1133          then throw("insufficient time")
1124 1134          else if (assert((transfer_ownership_deadline != 0)))
1125 1135              then throw("no active transfer")
1126 1136              else [IntegerEntry("transfer_ownership_deadline", 0), StringEntry("owner", future_owner)]
1127 1137  
1128 1138  
1129 1139  
1130 1140  @Callable(msg)
1131 1141  func revert_transfer_ownership () = if (assert((msg.caller == owner)))
1132 1142      then throw("only owner")
1133 1143      else [IntegerEntry("transfer_ownership_deadline", 0)]
1134 1144  
1135 1145  
1136 1146  
1137 1147  @Callable(msg)
1138 1148  func admin_balances (i) = $Tuple2(nil, admin_balance(i))
1139 1149  
1140 1150  
1141 1151  
1142 1152  @Callable(msg)
1143 1153  func withdraw_admin_fees () = if (assert((msg.caller == owner)))
1144 1154      then throw("only owner")
1145 1155      else {
1146 1156          func fold (acc,index) =         (acc :+ ScriptTransfer(owner, admin_balance(index), fromBase58String(coins[index])))
1147 1157  
1148 1158          let $l = index_N_COINS
1149 1159          let $s = size($l)
1150 1160          let $acc0 = nil
1151 1161          func $f0_1 ($a,$i) =         if (($i >= $s))
1152 1162              then $a
1153 1163              else fold($a, $l[$i])
1154 1164  
1155 1165          func $f0_2 ($a,$i) =         if (($i >= $s))
1156 1166              then $a
1157 1167              else throw("List size exceeds 10")
1158 1168  
1159 1169          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1160 1170          }
1161 1171  
1162 1172  
1163 1173  
1164 1174  @Callable(msg)
1165 1175  func donate_admin_fees () = if (assert((msg.caller == owner)))
1166 1176      then throw("only owner")
1167 1177      else {
1168 1178          func fold (acc,index) =         (acc :+ (balances[index] + admin_balance(index)))
1169 1179  
1170 1180          let new_balances = {
1171 1181              let $l = index_N_COINS
1172 1182              let $s = size($l)
1173 1183              let $acc0 = nil
1174 1184              func $f0_1 ($a,$i) =             if (($i >= $s))
1175 1185                  then $a
1176 1186                  else fold($a, $l[$i])
1177 1187  
1178 1188              func $f0_2 ($a,$i) =             if (($i >= $s))
1179 1189                  then $a
1180 1190                  else throw("List size exceeds 10")
1181 1191  
1182 1192              $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1183 1193              }
1184 1194  [StringEntry("balances", makeString(list_itos(new_balances), ","))]
1185 1195          }
1186 1196  
1187 1197  
1188 1198  
1189 1199  @Callable(msg)
1190 1200  func set_auto_fees (_is_auto_fees) = if (assert((msg.caller == owner)))
1191 1201      then throw("only owner")
1192 1202      else [BooleanEntry("is_auto_fees", _is_auto_fees)]
1193 1203  
1194 1204  
1195 1205  
1196 1206  @Callable(msg)
1197 1207  func kill_me () = if (assert((msg.caller == owner)))
1198 1208      then throw("only owner")
1199 1209      else if (assert((kill_deadline > block_timestamp)))
1200 1210          then throw("deadline has passed")
1201 1211          else [BooleanEntry("is_killed", true)]
1202 1212  
1203 1213  
1204 1214  
1205 1215  @Callable(msg)
1206 1216  func unkill_me () = if (assert((msg.caller == owner)))
1207 1217      then throw("only owner")
1208 1218      else [BooleanEntry("is_killed", false)]
1209 1219  
1210 1220  
1211 1221  
1212 1222  @Callable(msg)
1223 + func serialize () = if ((msg.caller != this))
1224 +     then throw("self only")
1225 +     else {
1226 +         let id = toBase58String(msg.transactionId)
1227 +         if ((getString(this, "serialized") == id))
1228 +             then throw("already serialized")
1229 +             else [StringEntry("serialized", id)]
1230 +         }
1231 + 
1232 + 
1233 + 
1234 + @Callable(msg)
1213 1235  func set_height_address (_heightAddress) = if ((msg.caller != owner))
1214 1236      then throw("only owner")
1215 1237      else [StringEntry("heightAddress", checkAddress(_heightAddress))]
1216 1238  
1217 1239  
1218 1240  
1219 1241  @Callable(i)
1220 1242  func set_verifier (verifier) = if ((i.caller != this))
1221 1243      then throw("self call only")
1222 1244      else {
1223 1245          let addressOK =         match addressFromString(verifier) {
1224 1246              case a: Address => 
1225 1247                  true
1226 1248              case _ => 
1227 1249                  false
1228 1250          }
1229 1251          if (!(addressOK))
1230 1252              then throw(("verifier wrong address " + verifier))
1231 1253              else if (isDefined(getString(this, "verifier")))
1232 1254                  then throw("verifier already defined")
1233 1255                  else [StringEntry("verifier", verifier)]
1234 1256          }
1235 1257  
1236 1258  
1237 1259  @Verifier(tx)
1238 1260  func verify () = match getString(this, "verifier") {
1239 1261      case verifier: String => 
1240 1262          valueOrElse(getBoolean(addressFromStringValue(verifier), ((("status_" + toString(this)) + "_") + toBase58String(tx.id))), false)
1241 1263      case _ => 
1242 1264          sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
1243 1265  }
1244 1266

Old	New		Differences
86	86		let block_timestamp = HEIGHT
87	87
88	88		func allowed (caller) = (owner == caller)
	89	+
	90	+
	91	+	func serialized () = {
	92	+	let serialize = invoke(this, "serialize", nil, nil)
	93	+	if ((serialize == serialize))
	94	+	then true
	95	+	else throw("Strict value is not equal to itself.")
	96	+	}
89	97
90	98
91	99		func assert (a) = if (a)

303	311		else $Tuple2(D, false)
304	312		}
305	313
306		-	let $~~t061556217~~ = {
	314	+	let $t062486310 = {
307	315		let $l = list16
308	316		let $s = size($l)
309	317		let $acc0 = $Tuple2(S, false)

317	325
318	326		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
319	327		}
320		-	let D = $~~t061556217~~._1
321		-	let finished = $~~t061556217~~._2
	328	+	let D = $t062486310._1
	329	+	let finished = $t062486310._2
322	330		if ((finished == false))
323	331		then throw(("D_proc() not finished with " + toString(D)))
324	332		else toInt(D)

341	349		let D_big = toBigInt(D)
342	350		let Ann_big = toBigInt((amp * N_COINS))
343	351		func S_c (acc,index) = {
344		-	let $~~t068106829~~ = acc
345		-	let S_ = $~~t068106829~~._1
346		-	let c = $~~t068106829~~._2
	352	+	let $t069036922 = acc
	353	+	let S_ = $t069036922._1
	354	+	let c = $t069036922._2
347	355		let x_ = if ((index == i))
348	356		then toBigInt(fraction(x, TOKEN_RATE, rates[index]))
349	357		else xp[index]

352	360		else $Tuple2(S_, c)
353	361		}
354	362
355		-	let $~~t071057169~~ = {
	363	+	let $t071987262 = {
356	364		let $l = index_N_COINS
357	365		let $s = size($l)
358	366		let $acc0 = $Tuple2(big0, D_big)

366	374
367	375		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
368	376		}
369		-	let S_ = $~~t071057169~~._1
370		-	let c_ = $~~t071057169~~._2
	377	+	let S_ = $t071987262._1
	378	+	let c_ = $t071987262._2
371	379		let c = fraction(c_, D_big, fraction(Ann_big, N_COINS_big, big1))
372	380		let bD = ((S_ + fraction(D_big, big1, Ann_big)) - D_big)
373	381		func y_proc (acc,unused) = if ((acc._2 == true))

384	392		else $Tuple2(y, false)
385	393		}
386	394
387		-	let $~~t077497815~~ = {
	395	+	let $t078427908 = {
388	396		let $l = list16
389	397		let $s = size($l)
390	398		let $acc0 = $Tuple2(D_big, false)

398	406
399	407		$f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
400	408		}
401		-	let y = $~~t077497815~~._1
402		-	let finished = $~~t077497815~~._2
	409	+	let y = $t078427908._1
	410	+	let finished = $t078427908._2
403	411		if ((finished == false))
404	412		then throw(("y_proc() not finished with " + toString(y)))
405	413		else $Tuple2(fraction(toInt(y), rates[j], TOKEN_RATE), D)

414	422		let D_big = toBigInt(D)
415	423		let Ann_big = toBigInt((amp * N_COINS))
416	424		func S_c (acc,index) = {
417		-	let $~~t083208339~~ = acc
418		-	let S_ = $~~t083208339~~._1
419		-	let c = $~~t083208339~~._2
	425	+	let $t084138432 = acc
	426	+	let S_ = $t084138432._1
	427	+	let c = $t084138432._2
420	428		let x_ = if ((index == i))
421	429		then big0
422	430		else xp[index]

425	433		else $Tuple2(S_, c)
426	434		}
427	435
428		-	let $~~t085698633~~ = {
	436	+	let $t086628726 = {
429	437		let $l = index_N_COINS
430	438		let $s = size($l)
431	439		let $acc0 = $Tuple2(big0, D_big)

439	447
440	448		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
441	449		}
442		-	let S_ = $~~t085698633~~._1
443		-	let c_ = $~~t085698633~~._2
	450	+	let S_ = $t086628726._1
	451	+	let c_ = $t086628726._2
444	452		let c = fraction(c_, D_big, fraction(Ann_big, N_COINS_big, big1))
445	453		let bD = ((S_ + fraction(D_big, big1, Ann_big)) - D_big)
446	454		func y_proc (acc,unused) = if ((acc._2 == true))

457	465		else $Tuple2(y, false)
458	466		}
459	467
460		-	let $~~t092139279~~ = {
	468	+	let $t093069372 = {
461	469		let $l = list16
462	470		let $s = size($l)
463	471		let $acc0 = $Tuple2(D_big, false)

471	479
472	480		$f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
473	481		}
474		-	let y = $~~t092139279~~._1
475		-	let finished = $~~t092139279~~._2
	482	+	let y = $t093069372._1
	483	+	let finished = $t093069372._2
476	484		if ((finished == false))
477	485		then throw(("y_proc() not finished with " + toString(y)))
478	486		else fraction(toInt(y), rates[i], TOKEN_RATE)

618	626		if (assert((D1 > D0)))
619	627		then throw("D1 > D0")
620	628		else {
621		-	let $~~t01295914909~~ = if ((token_quantity > 0))
	629	+	let $t01305215002 = if ((token_quantity > 0))
622	630		then {
623	631		func fee_balances (old,new) = {
624	632		func fold (acc,index) = {

651	659		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
652	660		}
653	661
654		-	let $~~t01443314515~~ = fee_balances(balances, new_balances)
655		-	let finals = $~~t01443314515~~._1
656		-	let no_fees = $~~t01443314515~~._2
657		-	let actions = $~~t01443314515~~._3
658		-	let fee_sum = $~~t01443314515~~._4
	662	+	let $t01452614608 = fee_balances(balances, new_balances)
	663	+	let finals = $t01452614608._1
	664	+	let no_fees = $t01452614608._2
	665	+	let actions = $t01452614608._3
	666	+	let fee_sum = $t01452614608._4
659	667		$Tuple3(finals, get_D(big_list(no_fees), amp), (actions ++ log_data(D0, if ((fee == 0))
660	668		then 0
661	669		else fraction(fee_sum, FEE_DENOMINATOR, fee))))
662	670		}
663	671		else $Tuple3(new_balances, D1, nil)
664		-	let final_balances = $~~t01295914909~~._1
665		-	let D2 = $~~t01295914909~~._2
666		-	let fees_actions = $~~t01295914909~~._3
	672	+	let final_balances = $t01305215002._1
	673	+	let D2 = $t01305215002._2
	674	+	let fees_actions = $t01305215002._3
667	675		let mint_amount = if ((token_quantity == 0))
668	676		then D1
669	677		else fraction(token_quantity, (D2 - D0), D0)

711	719
712	720		func fold (acc,coin) = $Tuple3((acc._1 + 1), (acc._2 :+ 0), (acc._3 :+ pow(10, 0, decimals(coin), 0, 0, DOWN)))
713	721
714		-	let $~~t01617016265~~ = {
	722	+	let $t01626316358 = {
715	723		let $l = coins_list
716	724		let $s = size($l)
717	725		let $acc0 = $Tuple3(0, nil, nil)

725	733
726	734		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
727	735		}
728		-	let _N_COINS = $~~t01617016265~~._1
729		-	let zeros = $~~t01617016265~~._2
730		-	let _rates = $~~t01617016265~~._3
	736	+	let _N_COINS = $t01626316358._1
	737	+	let zeros = $t01626316358._2
	738	+	let _rates = $t01626316358._3
731	739		let issueToken = Issue(_pool_token, ("LP token for " + _coins), 0, TOKEN_DECIMALS, true)
732	740		let tokenId = toBase58String(calculateAssetId(issueToken))
733	741		[StringEntry("coins", _coins), StringEntry("rates", makeString(list_itos(_rates), ",")), StringEntry("balances", makeString(list_itos(zeros), ",")), IntegerEntry("N_COINS", _N_COINS), IntegerEntry("initial_A", _A), IntegerEntry("future_A", _A), IntegerEntry("fee", _fee), IntegerEntry("admin_fee", _admin_fee), StringEntry("owner", checkAddress(_owner)), IntegerEntry("kill_deadline", (height + KILL_DEADLINE_DT)), StringEntry("token", tokenId), BooleanEntry("is_killed", false), BooleanEntry("is_auto_fees", true), issueToken]

738	746
739	747
740	748		@Callable(msg)
741		-	func add_liquidity (min_mint_amount) = if (!(~~allowed~~(~~msg.caller~~)))
742		-	then throw(~~"!allowed"~~)
	749	+	func add_liquidity (min_mint_amount) = if (!(serialized()))
	750	+	then throw()
743	751		else if (assert(!(is_killed)))
744	752		then throw("is killed")
745	753		else {

792	800		else false)
793	801		then throw("initial deposit requires all coins")
794	802		else {
795		-	let $~~t01820918295~~ = _calc_token_amount(new_balances)
796		-	let final_balances = $~~t01820918295~~._1
797		-	let mint_amount = $~~t01820918295~~._2
798		-	let fees_actions = $~~t01820918295~~._3
	803	+	let $t01828118367 = _calc_token_amount(new_balances)
	804	+	let final_balances = $t01828118367._1
	805	+	let mint_amount = $t01828118367._2
	806	+	let fees_actions = $t01828118367._3
799	807		if (assert((mint_amount >= min_mint_amount)))
800	808		then throw("slippage screwed you")
801	809		else ([StringEntry("balances", makeString(list_itos(final_balances), ",")), Reissue(token, mint_amount, true), ScriptTransfer(msg.caller, mint_amount, token)] ++ fees_actions)

809	817		let xp_i = balances[i]
810	818		let xp_j = balances[j]
811	819		let x = (xp_i + dx)
812		-	let $~~t01875518808~~ = get_y(i, j, x, big_list(balances))
813		-	let y = $~~t01875518808~~._1
814		-	let D = $~~t01875518808~~._2
	820	+	let $t01882718880 = get_y(i, j, x, big_list(balances))
	821	+	let y = $t01882718880._1
	822	+	let D = $t01882718880._2
815	823		let _dy = ((xp_j - y) - 1)
816	824		let dy_fee = fraction(_dy, fee, FEE_DENOMINATOR)
817	825		let dy = (_dy - dy_fee)

834	842		let xp_i = balances[i]
835	843		let xp_j = balances[j]
836	844		let x = (xp_i + dx)
837		-	let $~~t01937719430~~ = get_y(i, j, x, big_list(balances))
838		-	let y = $~~t01937719430~~._1
839		-	let D = $~~t01937719430~~._2
	845	+	let $t01944919502 = get_y(i, j, x, big_list(balances))
	846	+	let y = $t01944919502._1
	847	+	let D = $t01944919502._2
840	848		let _dy = ((xp_j - y) - 1)
841	849		let dy_fee = fraction(_dy, fee, FEE_DENOMINATOR)
842	850		let dy = (_dy - dy_fee)

878	886
879	887
880	888		@Callable(msg)
881		-	func remove_liquidity (_min_amounts) = if ((size(msg.payments) != 1))
882		-	then throw("size( payments ) != 1")
883		-	else {
884		-	let payment = msg.payments[0]
885		-	if ((payment.assetId != token))
886		-	then throw("unknown token")
887		-	else {
888		-	let min_amounts = if ((_min_amounts == "0"))
889		-	then nil
890		-	else list_stoi(split(_min_amounts, ","))
891		-	if (if ((_min_amounts != "0"))
892		-	then (size(min_amounts) != N_COINS)
893		-	else false)
894		-	then throw("min_amounts.size() != N_COINS")
895		-	else {
896		-	let amount = payment.amount
897		-	let caller = msg.caller
898		-	func fold (acc,index) = {
899		-	let balance = balances[index]
900		-	let amount_out = fraction(balance, amount, token_quantity)
901		-	if (if ((_min_amounts != "0"))
902		-	then (min_amounts[index] > amount_out)
903		-	else false)
904		-	then throw("withdrawal resulted in fewer coins than expected")
905		-	else $Tuple2((acc._1 :+ ScriptTransfer(caller, amount_out, fromBase58String(coins[index]))), (acc._2 :+ (balance - amount_out)))
	889	+	func remove_liquidity (_min_amounts) = if (!(serialized()))
	890	+	then throw()
	891	+	else if ((size(msg.payments) != 1))
	892	+	then throw("size( payments ) != 1")
	893	+	else {
	894	+	let payment = msg.payments[0]
	895	+	if ((payment.assetId != token))
	896	+	then throw("unknown token")
	897	+	else {
	898	+	let min_amounts = if ((_min_amounts == "0"))
	899	+	then nil
	900	+	else list_stoi(split(_min_amounts, ","))
	901	+	if (if ((_min_amounts != "0"))
	902	+	then (size(min_amounts) != N_COINS)
	903	+	else false)
	904	+	then throw("min_amounts.size() != N_COINS")
	905	+	else {
	906	+	let amount = payment.amount
	907	+	let caller = msg.caller
	908	+	func fold (acc,index) = {
	909	+	let balance = balances[index]
	910	+	let amount_out = fraction(balance, amount, token_quantity)
	911	+	if (if ((_min_amounts != "0"))
	912	+	then (min_amounts[index] > amount_out)
	913	+	else false)
	914	+	then throw("withdrawal resulted in fewer coins than expected")
	915	+	else $Tuple2((acc._1 :+ ScriptTransfer(caller, amount_out, fromBase58String(coins[index]))), (acc._2 :+ (balance - amount_out)))
	916	+	}
	917	+
	918	+	let $t02172921808 = {
	919	+	let $l = index_N_COINS
	920	+	let $s = size($l)
	921	+	let $acc0 = $Tuple2(nil, nil)
	922	+	func $f0_1 ($a,$i) = if (($i >= $s))
	923	+	then $a
	924	+	else fold($a, $l[$i])
	925	+
	926	+	func $f0_2 ($a,$i) = if (($i >= $s))
	927	+	then $a
	928	+	else throw("List size exceeds 10")
	929	+
	930	+	$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
	931	+	}
	932	+	let transfers = $t02172921808._1
	933	+	let final_balances = $t02172921808._2
	934	+	(transfers ++ [StringEntry("balances", makeString(list_itos(final_balances), ",")), Burn(token, amount)])
906	935		}
907		-
908		-	let $t02161521694 = {
909		-	let $l = index_N_COINS
910		-	let $s = size($l)
911		-	let $acc0 = $Tuple2(nil, nil)
912		-	func $f0_1 ($a,$i) = if (($i >= $s))
913		-	then $a
914		-	else fold($a, $l[$i])
915		-
916		-	func $f0_2 ($a,$i) = if (($i >= $s))
917		-	then $a
918		-	else throw("List size exceeds 10")
919		-
920		-	$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
921		-	}
922		-	let transfers = $t02161521694._1
923		-	let final_balances = $t02161521694._2
924		-	(transfers ++ [StringEntry("balances", makeString(list_itos(final_balances), ",")), Burn(token, amount)])
925		-	}
926		-	}
927		-	}
	936	+	}
	937	+	}
928	938
929	939
930	940

946	956		then throw("unknown token")
947	957		else {
948	958		let _token_amount = payment.amount
949		-	let $~~t02241822485~~ = _calc_withdraw_one_coin(_token_amount, i)
950		-	let dy = $~~t02241822485~~._1
951		-	let dy_fee = $~~t02241822485~~._2
952		-	let D = $~~t02241822485~~._3
	959	+	let $t02253222599 = _calc_withdraw_one_coin(_token_amount, i)
	960	+	let dy = $t02253222599._1
	961	+	let dy_fee = $t02253222599._2
	962	+	let D = $t02253222599._3
953	963		if (assert((dy >= min_amount)))
954	964		then throw("not enough coins removed")
955	965		else {

1022	1032
1023	1033		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1024	1034		}
1025		-	let $~~t02396324049~~ = _calc_token_amount(new_balances)
1026		-	let final_balances = $~~t02396324049~~._1
1027		-	let mint_amount = $~~t02396324049~~._2
1028		-	let fees_actions = $~~t02396324049~~._3
	1035	+	let $t02407724163 = _calc_token_amount(new_balances)
	1036	+	let final_balances = $t02407724163._1
	1037	+	let mint_amount = $t02407724163._2
	1038	+	let fees_actions = $t02407724163._3
1029	1039		$Tuple2(nil, mint_amount)
1030	1040		}
1031	1041		}

1210	1220
1211	1221
1212	1222		@Callable(msg)
	1223	+	func serialize () = if ((msg.caller != this))
	1224	+	then throw("self only")
	1225	+	else {
	1226	+	let id = toBase58String(msg.transactionId)
	1227	+	if ((getString(this, "serialized") == id))
	1228	+	then throw("already serialized")
	1229	+	else [StringEntry("serialized", id)]
	1230	+	}
	1231	+
	1232	+
	1233	+
	1234	+	@Callable(msg)
1213	1235		func set_height_address (_heightAddress) = if ((msg.caller != owner))
1214	1236		then throw("only owner")
1215	1237		else [StringEntry("heightAddress", checkAddress(_heightAddress))]

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let N_COINS = getIntegerValue(this, "N_COINS")
5	5
6	6		let N_COINS_big = toBigInt(N_COINS)
7	7
8	8		let N_COINS_MAX = 10
9	9
10	10		let TOKEN_DECIMALS = 6
11	11
12	12		let TOKEN_RATE = 1000000
13	13
14	14		let FEE_DENOMINATOR = 10000000000
15	15
16	16		let PRECISION = 1000000
17	17
18	18		let DECIMALS = 6
19	19
20	20		let MAX_ADMIN_FEE = 10000000000
21	21
22	22		let MAX_FEE = 5000000000
23	23
24	24		let MAX_A = 1000000
25	25
26	26		let MAX_A_CHANGE = 10
27	27
28	28		let ADMIN_ACTIONS_DELAY = ((3 * 86400) / 60)
29	29
30	30		let MIN_RAMP_TIME = (86400 / 60)
31	31
32	32		let VP_LOG_PERIOD = 86400000
33	33
34	34		let VP_PRECISION = 1000000000000
35	35
36	36		let coins = split(getStringValue(this, "coins"), ",")
37	37
38	38		let fee = getIntegerValue(this, "fee")
39	39
40	40		let N_fee_4 = ((fee * N_COINS) / (4 * (N_COINS - 1)))
41	41
42	42		let admin_fee = getIntegerValue(this, "admin_fee")
43	43
44	44		let is_auto_fees = getBooleanValue(this, "is_auto_fees")
45	45
46	46		let owner = addressFromStringValue(getStringValue(this, "owner"))
47	47
48	48		let token = fromBase58String(getStringValue(this, "token"))
49	49
50	50		let token_quantity = value(assetInfo(token)).quantity
51	51
52	52		let initial_A = getIntegerValue(this, "initial_A")
53	53
54	54		let future_A = getIntegerValue(this, "future_A")
55	55
56	56		let initial_A_time = valueOrElse(getInteger(this, "initial_A_time"), 0)
57	57
58	58		let future_A_time = valueOrElse(getInteger(this, "future_A_time"), 0)
59	59
60	60		let admin_actions_deadline = valueOrElse(getInteger(this, "admin_actions_deadline"), 0)
61	61
62	62		let transfer_ownership_deadline = valueOrElse(getInteger(this, "transfer_ownership_deadline"), 0)
63	63
64	64		let future_fee = getIntegerValue(this, "future_fee")
65	65
66	66		let future_admin_fee = getIntegerValue(this, "future_admin_fee")
67	67
68	68		let future_owner = getStringValue(this, "future_owner")
69	69
70	70		let is_killed = getBooleanValue(this, "is_killed")
71	71
72	72		let kill_deadline = getIntegerValue(this, "kill_deadline")
73	73
74	74		let KILL_DEADLINE_DT = (((2 * 30) * 86400) / 60)
75	75
76	76		let big0 = toBigInt(0)
77	77
78	78		let big1 = toBigInt(1)
79	79
80	80		let big2 = toBigInt(2)
81	81
82	82		let heightAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, "heightAddress"), "no settings defined")), "bad settings address")
83	83
84	84		let HEIGHT = height
85	85
86	86		let block_timestamp = HEIGHT
87	87
88	88		func allowed (caller) = (owner == caller)
	89	+
	90	+
	91	+	func serialized () = {
	92	+	let serialize = invoke(this, "serialize", nil, nil)
	93	+	if ((serialize == serialize))
	94	+	then true
	95	+	else throw("Strict value is not equal to itself.")
	96	+	}
89	97
90	98
91	99		func assert (a) = if (a)
92	100		then false
93	101		else true
94	102
95	103
96	104		func list_itos (list) = if ((size(list) > N_COINS_MAX))
97	105		then throw("list_itos: list.size() > N_COINS_MAX")
98	106		else {
99	107		func fold (acc,val) = (acc :+ toString(val))
100	108
101	109		let $l = list
102	110		let $s = size($l)
103	111		let $acc0 = nil
104	112		func $f0_1 ($a,$i) = if (($i >= $s))
105	113		then $a
106	114		else fold($a, $l[$i])
107	115
108	116		func $f0_2 ($a,$i) = if (($i >= $s))
109	117		then $a
110	118		else throw("List size exceeds 10")
111	119
112	120		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
113	121		}
114	122
115	123
116	124		func list_stoi (list) = if ((size(list) > N_COINS_MAX))
117	125		then throw("list_stoi: list.size() > N_COINS_MAX")
118	126		else {
119	127		func fold (acc,val) = (acc :+ parseIntValue(val))
120	128
121	129		let $l = list
122	130		let $s = size($l)
123	131		let $acc0 = nil
124	132		func $f0_1 ($a,$i) = if (($i >= $s))
125	133		then $a
126	134		else fold($a, $l[$i])
127	135
128	136		func $f0_2 ($a,$i) = if (($i >= $s))
129	137		then $a
130	138		else throw("List size exceeds 10")
131	139
132	140		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
133	141		}
134	142
135	143
136	144		let balances = list_stoi(split(getStringValue(this, "balances"), ","))
137	145
138	146		let rates = list_stoi(split(getStringValue(this, "rates"), ","))
139	147
140	148		let rates_size = size(rates)
141	149
142	150		let index_N_COINS_MAX = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
143	151
144	152		func index_n (n) = if ((n > N_COINS_MAX))
145	153		then throw("index_n: n > N_COINS_MAX")
146	154		else {
147	155		func fold (acc,index) = if ((n > index))
148	156		then (acc :+ index)
149	157		else acc
150	158
151	159		let $l = index_N_COINS_MAX
152	160		let $s = size($l)
153	161		let $acc0 = nil
154	162		func $f0_1 ($a,$i) = if (($i >= $s))
155	163		then $a
156	164		else fold($a, $l[$i])
157	165
158	166		func $f0_2 ($a,$i) = if (($i >= $s))
159	167		then $a
160	168		else throw("List size exceeds 10")
161	169
162	170		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
163	171		}
164	172
165	173
166	174		let index_N_COINS = index_n(N_COINS)
167	175
168	176		let index_N_COINS_1 = (index_N_COINS :+ N_COINS)
169	177
170	178		func big_list (list) = if ((size(list) != N_COINS))
171	179		then throw("big_list: list.size() != N_COINS")
172	180		else {
173	181		func fold (acc,index) = (acc :+ toBigInt(fraction(list[index], TOKEN_RATE, rates[index])))
174	182
175	183		let $l = index_N_COINS
176	184		let $s = size($l)
177	185		let $acc0 = nil
178	186		func $f0_1 ($a,$i) = if (($i >= $s))
179	187		then $a
180	188		else fold($a, $l[$i])
181	189
182	190		func $f0_2 ($a,$i) = if (($i >= $s))
183	191		then $a
184	192		else throw("List size exceeds 10")
185	193
186	194		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
187	195		}
188	196
189	197
190	198		func coin_index (payment) = match payment.assetId {
191	199		case assetId: ByteVector =>
192	200		valueOrErrorMessage(indexOf(coins, toBase58String(assetId)), (toBase58String(assetId) + " out of pool"))
193	201		case _ =>
194	202		throw("unsupported assetId")
195	203		}
196	204
197	205
198	206		func admin_balance (i) = if (if ((0 > i))
199	207		then true
200	208		else (i > N_COINS))
201	209		then throw("i out of index")
202	210		else (assetBalance(this, fromBase58String(coins[i])) - balances[i])
203	211
204	212
205	213		func checkAddress (a58) = {
206	214		let a = addressFromStringValue(a58)
207	215		toString(a)
208	216		}
209	217
210	218
211	219		let amp = {
212	220		let t1 = future_A_time
213	221		let A1 = future_A
214	222		if ((t1 > block_timestamp))
215	223		then {
216	224		let A0 = initial_A
217	225		let t0 = initial_A_time
218	226		if ((A1 > A0))
219	227		then (A0 + (((A1 - A0) * (block_timestamp - t0)) / (t1 - t0)))
220	228		else (A0 - (((A0 - A1) * (block_timestamp - t0)) / (t1 - t0)))
221	229		}
222	230		else A1
223	231		}
224	232
225	233		func list_sum (list) = {
226	234		func fold (acc,val) = (acc + val)
227	235
228	236		let $l = list
229	237		let $s = size($l)
230	238		let $acc0 = big0
231	239		func $f0_1 ($a,$i) = if (($i >= $s))
232	240		then $a
233	241		else fold($a, $l[$i])
234	242
235	243		func $f0_2 ($a,$i) = if (($i >= $s))
236	244		then $a
237	245		else throw("List size exceeds 10")
238	246
239	247		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
240	248		}
241	249
242	250
243	251		func list_mult (list) = {
244	252		func fold (acc,val) = fraction(fraction(acc, val, big1), N_COINS_big, big1)
245	253
246	254		let $l = list
247	255		let $s = size($l)
248	256		let $acc0 = big1
249	257		func $f0_1 ($a,$i) = if (($i >= $s))
250	258		then $a
251	259		else fold($a, $l[$i])
252	260
253	261		func $f0_2 ($a,$i) = if (($i >= $s))
254	262		then $a
255	263		else throw("List size exceeds 10")
256	264
257	265		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
258	266		}
259	267
260	268
261	269		let list16 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
262	270
263	271		func get_D (xp,amp) = {
264	272		let S = list_sum(xp)
265	273		if ((toInt(S) == 0))
266	274		then 0
267	275		else {
268	276		let Ann = (amp * N_COINS)
269	277		let AnnS = fraction(toBigInt(Ann), S, big1)
270	278		let Ann1 = toBigInt((Ann - 1))
271	279		let xd = list_mult(xp)
272	280		let N_COINS_1 = (N_COINS + 1)
273	281		let N_COINS_1_big = toBigInt(N_COINS_1)
274	282		func D_mult (val) = {
275	283		func fold (acc,index) = fraction(acc, val, big1)
276	284
277	285		let $l = index_N_COINS_1
278	286		let $s = size($l)
279	287		let $acc0 = big1
280	288		func $f0_1 ($a,$i) = if (($i >= $s))
281	289		then $a
282	290		else fold($a, $l[$i])
283	291
284	292		func $f0_2 ($a,$i) = if (($i >= $s))
285	293		then $a
286	294		else throw("List size exceeds 11")
287	295
288	296		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
289	297		}
290	298
291	299		func D_proc (acc,unused) = if ((acc._2 == true))
292	300		then acc
293	301		else {
294	302		let Dprev = acc._1
295	303		let D_P = fraction(D_mult(Dprev), big1, xd)
296	304		let D = fraction((AnnS + fraction(N_COINS_big, D_P, big1)), Dprev, (fraction(Ann1, Dprev, big1) + fraction(N_COINS_1_big, D_P, big1)))
297	305		if ((D > Dprev))
298	306		then if ((1 >= toInt((D - Dprev))))
299	307		then $Tuple2(D, true)
300	308		else $Tuple2(D, false)
301	309		else if ((1 >= toInt((Dprev - D))))
302	310		then $Tuple2(D, true)
303	311		else $Tuple2(D, false)
304	312		}
305	313
306		-	let $~~t061556217~~ = {
	314	+	let $t062486310 = {
307	315		let $l = list16
308	316		let $s = size($l)
309	317		let $acc0 = $Tuple2(S, false)
310	318		func $f0_1 ($a,$i) = if (($i >= $s))
311	319		then $a
312	320		else D_proc($a, $l[$i])
313	321
314	322		func $f0_2 ($a,$i) = if (($i >= $s))
315	323		then $a
316	324		else throw("List size exceeds 16")
317	325
318	326		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
319	327		}
320		-	let D = $~~t061556217~~._1
321		-	let finished = $~~t061556217~~._2
	328	+	let D = $t062486310._1
	329	+	let finished = $t062486310._2
322	330		if ((finished == false))
323	331		then throw(("D_proc() not finished with " + toString(D)))
324	332		else toInt(D)
325	333		}
326	334		}
327	335
328	336
329	337		func get_y (i,j,x,xp) = if (assert((i != j)))
330	338		then throw("same coin")
331	339		else if (assert(if ((j >= 0))
332	340		then (i >= 0)
333	341		else false))
334	342		then throw("below zero")
335	343		else if (assert(if ((N_COINS > j))
336	344		then (N_COINS > i)
337	345		else false))
338	346		then throw("above N_COINS")
339	347		else {
340	348		let D = get_D(xp, amp)
341	349		let D_big = toBigInt(D)
342	350		let Ann_big = toBigInt((amp * N_COINS))
343	351		func S_c (acc,index) = {
344		-	let $~~t068106829~~ = acc
345		-	let S_ = $~~t068106829~~._1
346		-	let c = $~~t068106829~~._2
	352	+	let $t069036922 = acc
	353	+	let S_ = $t069036922._1
	354	+	let c = $t069036922._2
347	355		let x_ = if ((index == i))
348	356		then toBigInt(fraction(x, TOKEN_RATE, rates[index]))
349	357		else xp[index]
350	358		if ((index != j))
351	359		then $Tuple2((S_ + x_), fraction(c, D_big, fraction(x_, N_COINS_big, big1)))
352	360		else $Tuple2(S_, c)
353	361		}
354	362
355		-	let $~~t071057169~~ = {
	363	+	let $t071987262 = {
356	364		let $l = index_N_COINS
357	365		let $s = size($l)
358	366		let $acc0 = $Tuple2(big0, D_big)
359	367		func $f0_1 ($a,$i) = if (($i >= $s))
360	368		then $a
361	369		else S_c($a, $l[$i])
362	370
363	371		func $f0_2 ($a,$i) = if (($i >= $s))
364	372		then $a
365	373		else throw("List size exceeds 10")
366	374
367	375		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
368	376		}
369		-	let S_ = $~~t071057169~~._1
370		-	let c_ = $~~t071057169~~._2
	377	+	let S_ = $t071987262._1
	378	+	let c_ = $t071987262._2
371	379		let c = fraction(c_, D_big, fraction(Ann_big, N_COINS_big, big1))
372	380		let bD = ((S_ + fraction(D_big, big1, Ann_big)) - D_big)
373	381		func y_proc (acc,unused) = if ((acc._2 == true))
374	382		then acc
375	383		else {
376	384		let y_prev = acc._1
377	385		let y = fraction((fraction(y_prev, y_prev, big1) + c), big1, (fraction(big2, y_prev, big1) + bD))
378	386		if ((y > y_prev))
379	387		then if ((1 >= toInt((y - y_prev))))
380	388		then $Tuple2(y, true)
381	389		else $Tuple2(y, false)
382	390		else if ((1 >= toInt((y_prev - y))))
383	391		then $Tuple2(y, true)
384	392		else $Tuple2(y, false)
385	393		}
386	394
387		-	let $~~t077497815~~ = {
	395	+	let $t078427908 = {
388	396		let $l = list16
389	397		let $s = size($l)
390	398		let $acc0 = $Tuple2(D_big, false)
391	399		func $f1_1 ($a,$i) = if (($i >= $s))
392	400		then $a
393	401		else y_proc($a, $l[$i])
394	402
395	403		func $f1_2 ($a,$i) = if (($i >= $s))
396	404		then $a
397	405		else throw("List size exceeds 16")
398	406
399	407		$f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
400	408		}
401		-	let y = $~~t077497815~~._1
402		-	let finished = $~~t077497815~~._2
	409	+	let y = $t078427908._1
	410	+	let finished = $t078427908._2
403	411		if ((finished == false))
404	412		then throw(("y_proc() not finished with " + toString(y)))
405	413		else $Tuple2(fraction(toInt(y), rates[j], TOKEN_RATE), D)
406	414		}
407	415
408	416
409	417		func get_y_D (amp,i,xp,D) = if (assert((i >= 0)))
410	418		then throw("i below zero")
411	419		else if (assert((N_COINS > i)))
412	420		then throw("i above N_COINS")
413	421		else {
414	422		let D_big = toBigInt(D)
415	423		let Ann_big = toBigInt((amp * N_COINS))
416	424		func S_c (acc,index) = {
417		-	let $~~t083208339~~ = acc
418		-	let S_ = $~~t083208339~~._1
419		-	let c = $~~t083208339~~._2
	425	+	let $t084138432 = acc
	426	+	let S_ = $t084138432._1
	427	+	let c = $t084138432._2
420	428		let x_ = if ((index == i))
421	429		then big0
422	430		else xp[index]
423	431		if ((index != i))
424	432		then $Tuple2((S_ + x_), fraction(c, D_big, fraction(x_, N_COINS_big, big1)))
425	433		else $Tuple2(S_, c)
426	434		}
427	435
428		-	let $~~t085698633~~ = {
	436	+	let $t086628726 = {
429	437		let $l = index_N_COINS
430	438		let $s = size($l)
431	439		let $acc0 = $Tuple2(big0, D_big)
432	440		func $f0_1 ($a,$i) = if (($i >= $s))
433	441		then $a
434	442		else S_c($a, $l[$i])
435	443
436	444		func $f0_2 ($a,$i) = if (($i >= $s))
437	445		then $a
438	446		else throw("List size exceeds 10")
439	447
440	448		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
441	449		}
442		-	let S_ = $~~t085698633~~._1
443		-	let c_ = $~~t085698633~~._2
	450	+	let S_ = $t086628726._1
	451	+	let c_ = $t086628726._2
444	452		let c = fraction(c_, D_big, fraction(Ann_big, N_COINS_big, big1))
445	453		let bD = ((S_ + fraction(D_big, big1, Ann_big)) - D_big)
446	454		func y_proc (acc,unused) = if ((acc._2 == true))
447	455		then acc
448	456		else {
449	457		let y_prev = acc._1
450	458		let y = fraction((fraction(y_prev, y_prev, big1) + c), big1, (fraction(big2, y_prev, big1) + bD))
451	459		if ((y > y_prev))
452	460		then if ((1 >= toInt((y - y_prev))))
453	461		then $Tuple2(y, true)
454	462		else $Tuple2(y, false)
455	463		else if ((1 >= toInt((y_prev - y))))
456	464		then $Tuple2(y, true)
457	465		else $Tuple2(y, false)
458	466		}
459	467
460		-	let $~~t092139279~~ = {
	468	+	let $t093069372 = {
461	469		let $l = list16
462	470		let $s = size($l)
463	471		let $acc0 = $Tuple2(D_big, false)
464	472		func $f1_1 ($a,$i) = if (($i >= $s))
465	473		then $a
466	474		else y_proc($a, $l[$i])
467	475
468	476		func $f1_2 ($a,$i) = if (($i >= $s))
469	477		then $a
470	478		else throw("List size exceeds 16")
471	479
472	480		$f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
473	481		}

github/deemru/w8io/3ef1775 
148.95 ms ◑