w8 · tx · tED···YJW

tx · tEDh3rNWtafsXjwqkxk6KSq7RkhxZJny9VsjEMAJYJW

3N4vUDe3oc1YPNwMyQi2h8f2tmGoA7wBZp2:  -0.04300000 Waves

2024.07.02 10:59 [3176106] smart account 3N4vUDe3oc1YPNwMyQi2h8f2tmGoA7wBZp2 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "tEDh3rNWtafsXjwqkxk6KSq7RkhxZJny9VsjEMAJYJW",
    "fee": 4300000,
    "feeAssetId": null,
    "timestamp": 1719907180303,
    "version": 2,
    "chainId": 84,
    "sender": "3N4vUDe3oc1YPNwMyQi2h8f2tmGoA7wBZp2",
    "senderPublicKey": "6MuWw1pkme7UgQX2hZh8yTZyoWVkz8A4rmHZ1acrsrVm",
    "proofs": [
        "32D8vJ9MNV3QBpeTpp2nFrELYykhvgrrTzhJcRbgRKNUQosk4ExD2HL4x1UFsqAxX5zMYEDNiZYd2uKZjq53SCqR"
    ],
    "script": "base64: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",
    "height": 3176106,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: D8uxvjoEmPTrgimWJ4cyQ6a3KGw4KH1we9s4mWsvoqDk
Next: FAyC8XmHSTTkWBpD3PeAKrzKrmqspsvPeKZ6AAqVdpJU

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

Old	New		Differences
1029	1029		let gB = if ((gy == false))
1030	1030		then aW(this, af())
1031	1031		else aW(this, ae())
1032		-	let gD = ((bV(gC) - value(fd.payments[0]).amount) ~~- gz)~~
	1032	+	let gD = (bV(gC) - value(fd.payments[0]).amount)
1033	1033		let gE = bV(gB)
1034	1034		let gF = fraction(gE, gx, (gD + gx))
1035	1035		let gG = (toBigInt(gD) * toBigInt(gE))
1036		-	let gH = ((toBigInt(bV(gC~~)) + toBigInt(gz~~)) * (toBigInt(bV(gB)) - toBigInt(gF)))
	1036	+	let gH = (toBigInt(bV(gC)) * (toBigInt(bV(gB)) - toBigInt(gF)))
1037	1037		let gI = if ((gH >= gG))
1038	1038		then true
1039	1039		else throw("new K is fewer error")

1044	1044		else throw("Exchange result is fewer coins than expected")
1045	1045		if ((gO == gO))
1046	1046		then {
1047		-	let eL = if (gy)
1048		-	then -(gF)
1049		-	else gz
1050		-	let eM = if (gy)
1051		-	then gz
1052		-	else -(gF)
1053		-	let gP = eK(eL, eM, 0)._1
1054		-	if ((gP == gP))
	1047	+	let gP = aW(this, af())
	1048	+	let gQ = fromBase58String(gP)
	1049	+	let fr = fraction(gx, gz, 100)
	1050	+	let gR = cK(gC)
	1051	+	if ((gR == gR))
1055	1052		then {
1056		-	let gQ = cK(gC)
1057		-	if ((gQ == gQ))
	1053	+	let gS = cR(gB, (gF + fr))
	1054	+	if ((gS == gS))
1058	1055		then {
1059		-	let gR = cR(gB, gF)
1060		-	if ((gR == gR))
1061		-	then $Tuple2(((gR ++ gQ) ++ [ScriptTransfer(addressFromStringValue(gK), gF, bp(gB))]), gF)
1062		-	else throw("Strict value is not equal to itself.")
	1056	+	let gT = ScriptTransfer(be, fr, gQ)
	1057	+	$Tuple2(((gS ++ gR) ++ [ScriptTransfer(addressFromStringValue(gK), (gF - fr), bp(gB)), gT]), gF)
1063	1058		}
1064	1059		else throw("Strict value is not equal to itself.")
1065	1060		}

1075	1070
1076	1071
1077	1072		@Callable(fd)
1078		-	func put (dQ,gS) = if ((0 > dQ))
	1073	+	func put (dQ,gU) = if ((0 > dQ))
1079	1074		then throw("Invalid slippageTolerance passed")
1080	1075		else {
1081	1076		let fk = fh(fd, dQ, true)

1084	1079		let dO = fk._9
1085	1080		let et = fk._10
1086	1081		let eu = fk._11
1087		-	let gT = fk._12
1088		-	let gU = fk._13
	1082	+	let gV = fk._12
	1083	+	let gW = fk._13
1089	1084		let fi = toBigInt(value(fd.payments[0]).amount)
1090	1085		let fj = toBigInt(value(fd.payments[1]).amount)
1091	1086		let eJ = eC(fi, fj, toBigInt(0))

1105	1100		}
1106	1101		if ((fo == fo))
1107	1102		then {
1108		-	let gV = if ((et > 0))
1109		-	then invoke(bF, "put", nil, [AttachedPayment(gT, et)])
	1103	+	let gX = if ((et > 0))
	1104	+	then invoke(bF, "put", nil, [AttachedPayment(gV, et)])
1110	1105		else nil
1111		-	if ((gV == gV))
	1106	+	if ((gX == gX))
1112	1107		then {
1113		-	let gW = if ((eu > 0))
1114		-	then invoke(bF, "put", nil, [AttachedPayment(gU, eu)])
	1108	+	let gY = if ((eu > 0))
	1109	+	then invoke(bF, "put", nil, [AttachedPayment(gW, eu)])
1115	1110		else nil
1116		-	if ((gW == gW))
	1111	+	if ((gY == gY))
1117	1112		then {
1118		-	let gX = if (gS)
	1113	+	let gZ = if (gU)
1119	1114		then {
1120		-	let gY = invoke(bE, "stake", nil, [AttachedPayment(dx, es)])
1121		-	if ((gY == gY))
	1115	+	let ha = invoke(bE, "stake", nil, [AttachedPayment(dx, es)])
	1116	+	if ((ha == ha))
1122	1117		then nil
1123	1118		else throw("Strict value is not equal to itself.")
1124	1119		}
1125	1120		else [ScriptTransfer(fd.caller, es, dx)]
1126		-	let gZ = eK(0, 0, 0)
1127		-	if ((gZ == gZ))
	1121	+	let hb = eK(0, 0, 0)
	1122	+	if ((hb == hb))
1128	1123		then {
1129		-	let eB = gZ._2
1130		-	let gP = gZ._1
1131		-	let ha = eP(eJ, eB)
1132		-	if ((ha == ha))
	1124	+	let eB = hb._2
	1125	+	let hc = hb._1
	1126	+	let hd = eP(eJ, eB)
	1127	+	if ((hd == hd))
1133	1128		then {
1134		-	let hb = invoke(this, "rebalance", nil, nil)
1135		-	if ((hb == hb))
1136		-	then ((dO ++ gX) ++ gP)
	1129	+	let he = invoke(this, "rebalance", nil, nil)
	1130	+	if ((he == he))
	1131	+	then ((dO ++ gZ) ++ hc)
1137	1132		else throw("Strict value is not equal to itself.")
1138	1133		}
1139	1134		else throw("Strict value is not equal to itself.")

1154	1149
1155	1150
1156	1151		@Callable(fd)
1157		-	func putForFree (hc) = if ((0 > hc))
	1152	+	func putForFree (hf) = if ((0 > hf))
1158	1153		then throw("Invalid value passed")
1159	1154		else {
1160		-	let fk = fh(fd, hc, false)
	1155	+	let fk = fh(fd, hf, false)
1161	1156		let dO = fk._9
1162	1157		let fi = toBigInt(value(fd.payments[0]).amount)
1163	1158		let fj = toBigInt(value(fd.payments[1]).amount)
1164	1159		let eJ = eC(fi, fj, toBigInt(0))
1165	1160		if ((eJ == eJ))
1166	1161		then {
1167		-	let hd = eK(0, 0, 0)
1168		-	let gP = hd._1
1169		-	let eB = hd._2
1170		-	let ha = eP(eJ, eB)
1171		-	if ((ha == ha))
1172		-	then (dO ++ gP)
	1162	+	let hg = eK(0, 0, 0)
	1163	+	let hc = hg._1
	1164	+	let eB = hg._2
	1165	+	let hd = eP(eJ, eB)
	1166	+	if ((hd == hd))
	1167	+	then (dO ++ hc)
1173	1168		else throw("Strict value is not equal to itself.")
1174	1169		}
1175	1170		else throw("Strict value is not equal to itself.")

1178	1173
1179	1174
1180	1175		@Callable(fd)
1181		-	func putOneTkn (he,hf) = {
1182		-	let hg = {
	1176	+	func putOneTkn (hh,hi) = {
	1177	+	let hj = {
1183	1178		let bg = invoke(bd, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1184	1179		if ($isInstanceOf(bg, "Boolean"))
1185	1180		then bg

1192	1187		then true
1193	1188		else (bx == n))
1194	1189		then true
1195		-	else hg
	1190	+	else hj
1196	1191		else false
1197	1192		let fZ = [if (if (!(fl))
1198	1193		then true

1203	1198		else ba("exactly 1 payment are expected")]
1204	1199		if ((fZ == fZ))
1205	1200		then {
1206		-	let hh = fd.payments[0]
1207		-	let fu = hh.assetId
1208		-	let ft = hh.amount
	1201	+	let hk = fd.payments[0]
	1202	+	let fu = hk.assetId
	1203	+	let ft = hk.amount
1209	1204		let eJ = if ((fu == bz))
1210	1205		then eC(toBigInt(ft), toBigInt(0), toBigInt(0))
1211	1206		else if ((fu == bA))

1215	1210		then {
1216	1211		let ab = fd.caller
1217	1212		let ac = fd.transactionId
1218		-	let hi = fs(ft, fu, ab, ac)
1219		-	if ((hi == hi))
	1213	+	let hl = fs(ft, fu, ab, ac)
	1214	+	if ((hl == hl))
1220	1215		then {
1221		-	let fy = hi._5
1222		-	let hj = hi._4
1223		-	let fr = hi._3
1224		-	let ev = hi._2
1225		-	let hk = hi._1
1226		-	let hl = if (if ((he > 0))
1227		-	then (he > hk)
	1216	+	let fy = hl._5
	1217	+	let hm = hl._4
	1218	+	let fr = hl._3
	1219	+	let ev = hl._2
	1220	+	let hn = hl._1
	1221	+	let ho = if (if ((hh > 0))
	1222	+	then (hh > hn)
1228	1223		else false)
1229		-	then ba(makeString(["amount to receive is less than ", toString(he)], ""))
1230		-	else hk
1231		-	let fn = fm(hl)
	1224	+	then ba(makeString(["amount to receive is less than ", toString(hh)], ""))
	1225	+	else hn
	1226	+	let fn = fm(ho)
1232	1227		if ((fn == fn))
1233	1228		then {
1234		-	let gX = if (hf)
	1229	+	let gZ = if (hi)
1235	1230		then {
1236		-	let hm = invoke(bE, "stake", nil, [AttachedPayment(by, hl)])
1237		-	if ((hm == hm))
	1231	+	let hp = invoke(bE, "stake", nil, [AttachedPayment(by, ho)])
	1232	+	if ((hp == hp))
1238	1233		then nil
1239	1234		else throw("Strict value is not equal to itself.")
1240	1235		}
1241		-	else [ScriptTransfer(fd.caller, hl, by)]
1242		-	let hn = if ((fr > 0))
	1236	+	else [ScriptTransfer(fd.caller, ho, by)]
	1237	+	let hq = if ((fr > 0))
1243	1238		then [ScriptTransfer(be, fr, fu)]
1244	1239		else nil
1245		-	let ho = if ((this == be))
	1240	+	let hr = if ((this == be))
1246	1241		then $Tuple2(0, 0)
1247	1242		else if (fy)
1248	1243		then $Tuple2(-(fr), 0)
1249	1244		else $Tuple2(0, -(fr))
1250		-	let eL = ho._1
1251		-	let eM = ho._2
1252		-	let hp = eK(eL, eM, 0)
1253		-	let gP = hp._1
1254		-	let eB = hp._2
	1245	+	let eL = hr._1
	1246	+	let eM = hr._2
	1247	+	let hs = eK(eL, eM, 0)
	1248	+	let hc = hs._1
	1249	+	let eB = hs._2
1255	1250		let eW = value(getString(aj))
1256		-	let ha = eP(eJ, eB)
1257		-	if ((ha == ha))
	1251	+	let hd = eP(eJ, eB)
	1252	+	if ((hd == hd))
1258	1253		then {
1259		-	let hb = invoke(this, "rebalance", nil, nil)
1260		-	if ((hb == hb))
1261		-	then $Tuple2((((ev ++ gX) ++ hn) ++ gP), hl)
	1254	+	let he = invoke(this, "rebalance", nil, nil)
	1255	+	if ((he == he))
	1256	+	then $Tuple2((((ev ++ gZ) ++ hq) ++ hc), ho)
1262	1257		else throw("Strict value is not equal to itself.")
1263	1258		}
1264	1259		else throw("Strict value is not equal to itself.")

1276	1271
1277	1272		@Callable(fd)
1278	1273		func putOneTknREADONLY (fu,ft) = {
1279		-	let hq = fs(ft, bp(fu), unit, unit)
1280		-	let hk = hq._1
1281		-	let ev = hq._2
1282		-	let fr = hq._3
1283		-	let hj = hq._4
1284		-	let fy = hq._5
1285		-	$Tuple2(nil, $Tuple3(hk, fr, hj))
	1274	+	let ht = fs(ft, bp(fu), unit, unit)
	1275	+	let hn = ht._1
	1276	+	let ev = ht._2
	1277	+	let fr = ht._3
	1278	+	let hm = ht._4
	1279	+	let fy = ht._5
	1280	+	$Tuple2(nil, $Tuple3(hn, fr, hm))
1286	1281		}
1287	1282
1288	1283
1289	1284
1290	1285		@Callable(fd)
1291		-	func getOneTkn (hr,he) = {
1292		-	let hg = {
	1286	+	func getOneTkn (hu,hh) = {
	1287	+	let hj = {
1293	1288		let bg = invoke(bd, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1294	1289		if ($isInstanceOf(bg, "Boolean"))
1295	1290		then bg

1300	1295		then true
1301	1296		else (bx == n))
1302	1297		then true
1303		-	else hg
	1298	+	else hj
1304	1299		else false
1305	1300		let fZ = [if (if (!(fg))
1306	1301		then true

1311	1306		else ba("exactly 1 payment are expected")]
1312	1307		if ((fZ == fZ))
1313	1308		then {
1314		-	let fY = bp(hr)
1315		-	let hh = fd.payments[0]
1316		-	let fu = hh.assetId
1317		-	let fG = hh.amount
	1309	+	let fY = bp(hu)
	1310	+	let hk = fd.payments[0]
	1311	+	let fu = hk.assetId
	1312	+	let fG = hk.amount
1318	1313		let eJ = eC(toBigInt(0), toBigInt(0), toBigInt(0))
1319	1314		if ((eJ == eJ))
1320	1315		then {
1321	1316		let ab = fd.caller
1322	1317		let ac = fd.transactionId
1323		-	let hs = fX(fY, fG, fu, ab, ac)
1324		-	if ((hs == hs))
	1318	+	let hv = fX(fY, fG, fu, ab, ac)
	1319	+	if ((hv == hv))
1325	1320		then {
1326		-	let ga = hs._5
1327		-	let hj = hs._4
1328		-	let fr = hs._3
1329		-	let ev = hs._2
1330		-	let ht = hs._1
1331		-	let ch = if (if ((he > 0))
1332		-	then (he > ht)
	1321	+	let ga = hv._5
	1322	+	let hm = hv._4
	1323	+	let fr = hv._3
	1324	+	let ev = hv._2
	1325	+	let hw = hv._1
	1326	+	let ch = if (if ((hh > 0))
	1327	+	then (hh > hw)
1333	1328		else false)
1334		-	then ba(makeString(["amount to receive is less than ", toString(he)], ""))
1335		-	else ht
1336		-	let hu = invoke(bd, "burn", [fG], [AttachedPayment(fu, fG)])
1337		-	if ((hu == hu))
	1329	+	then ba(makeString(["amount to receive is less than ", toString(hh)], ""))
	1330	+	else hw
	1331	+	let hx = invoke(bd, "burn", [fG], [AttachedPayment(fu, fG)])
	1332	+	if ((hx == hx))
1338	1333		then {
1339		-	let gR = cR(hr, (ch + max([0, fr])))
1340		-	let hv = [ScriptTransfer(ab, ch, fY)]
1341		-	let hn = if ((fr > 0))
	1334	+	let gS = cR(hu, (ch + max([0, fr])))
	1335	+	let hy = [ScriptTransfer(ab, ch, fY)]
	1336	+	let hq = if ((fr > 0))
1342	1337		then [ScriptTransfer(be, fr, fY)]
1343	1338		else nil
1344		-	let hw = {
1345		-	let hx = if ((this == be))
	1339	+	let hz = {
	1340	+	let hA = if ((this == be))
1346	1341		then 0
1347	1342		else fr
1348	1343		if (ga)
1349		-	then $Tuple2(-((ch + hx)), 0)
1350		-	else $Tuple2(0, -((ch + hx)))
	1344	+	then $Tuple2(-((ch + hA)), 0)
	1345	+	else $Tuple2(0, -((ch + hA)))
1351	1346		}
1352		-	let eL = hw._1
1353		-	let eM = hw._2
1354		-	let hy = eK(eL, eM, 0)
1355		-	let gP = hy._1
1356		-	let eB = hy._2
1357		-	let ha = eP(eJ, eB)
1358		-	if ((ha == ha))
1359		-	then $Tuple2(((((ev ++ gR) ++ hv) ++ hn) ++ gP), ch)
	1347	+	let eL = hz._1
	1348	+	let eM = hz._2
	1349	+	let hB = eK(eL, eM, 0)
	1350	+	let hc = hB._1
	1351	+	let eB = hB._2
	1352	+	let hd = eP(eJ, eB)
	1353	+	if ((hd == hd))
	1354	+	then $Tuple2(((((ev ++ gS) ++ hy) ++ hq) ++ hc), ch)
1360	1355		else throw("Strict value is not equal to itself.")
1361	1356		}
1362	1357		else throw("Strict value is not equal to itself.")

1372	1367
1373	1368		@Callable(fd)
1374	1369		func getOneTknREADONLY (fY,fG) = {
1375		-	let hz = fX(bp(fY), fG, by, unit, unit)
1376		-	let ht = hz._1
1377		-	let ev = hz._2
1378		-	let fr = hz._3
1379		-	let hj = hz._4
1380		-	let ga = hz._5
1381		-	$Tuple2(nil, $Tuple3(ht, fr, hj))
	1370	+	let hC = fX(bp(fY), fG, by, unit, unit)
	1371	+	let hw = hC._1
	1372	+	let ev = hC._2
	1373	+	let fr = hC._3
	1374	+	let hm = hC._4
	1375	+	let ga = hC._5
	1376	+	$Tuple2(nil, $Tuple3(hw, fr, hm))
1382	1377		}
1383	1378
1384	1379
1385	1380
1386	1381		@Callable(fd)
1387		-	func unstakeAndGetOneTkn (hA,hr,he) = {
1388		-	let hg = {
	1382	+	func unstakeAndGetOneTkn (hD,hu,hh) = {
	1383	+	let hj = {
1389	1384		let bg = invoke(bd, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1390	1385		if ($isInstanceOf(bg, "Boolean"))
1391	1386		then bg

1396	1391		then true
1397	1392		else (bx == n))
1398	1393		then true
1399		-	else hg
	1394	+	else hj
1400	1395		else false
1401	1396		let fZ = [if (if (!(fg))
1402	1397		then true

1407	1402		else ba("no payments are expected")]
1408	1403		if ((fZ == fZ))
1409	1404		then {
1410		-	let fY = bp(hr)
	1405	+	let fY = bp(hu)
1411	1406		let ab = fd.caller
1412	1407		let ac = fd.transactionId
1413	1408		let eJ = eC(toBigInt(0), toBigInt(0), toBigInt(0))
1414	1409		if ((eJ == eJ))
1415	1410		then {
1416		-	let hB = invoke(bE, "unstake", [toBase58String(by), hA], nil)
1417		-	if ((hB == hB))
	1411	+	let hE = invoke(bE, "unstake", [toBase58String(by), hD], nil)
	1412	+	if ((hE == hE))
1418	1413		then {
1419		-	let hC = fX(fY, hA, by, ab, ac)
1420		-	if ((hC == hC))
	1414	+	let hF = fX(fY, hD, by, ab, ac)
	1415	+	if ((hF == hF))
1421	1416		then {
1422		-	let ga = hC._5
1423		-	let hj = hC._4
1424		-	let fr = hC._3
1425		-	let ev = hC._2
1426		-	let ht = hC._1
1427		-	let ch = if (if ((he > 0))
1428		-	then (he > ht)
	1417	+	let ga = hF._5
	1418	+	let hm = hF._4
	1419	+	let fr = hF._3
	1420	+	let ev = hF._2
	1421	+	let hw = hF._1
	1422	+	let ch = if (if ((hh > 0))
	1423	+	then (hh > hw)
1429	1424		else false)
1430		-	then ba(makeString(["amount to receive is less than ", toString(he)], ""))
1431		-	else ht
1432		-	let hu = invoke(bd, "burn", [hA], [AttachedPayment(by, hA)])
1433		-	if ((hu == hu))
	1425	+	then ba(makeString(["amount to receive is less than ", toString(hh)], ""))
	1426	+	else hw
	1427	+	let hx = invoke(bd, "burn", [hD], [AttachedPayment(by, hD)])
	1428	+	if ((hx == hx))
1434	1429		then {
1435		-	let gR = cR(hr, (ch + max([0, fr])))
1436		-	let hv = [ScriptTransfer(fd.caller, ch, fY)]
1437		-	let hn = if ((fr > 0))
	1430	+	let gS = cR(hu, (ch + max([0, fr])))
	1431	+	let hy = [ScriptTransfer(fd.caller, ch, fY)]
	1432	+	let hq = if ((fr > 0))
1438	1433		then [ScriptTransfer(be, fr, fY)]
1439	1434		else nil
1440		-	let hD = {
1441		-	let hx = if ((this == be))
	1435	+	let hG = {
	1436	+	let hA = if ((this == be))
1442	1437		then 0
1443	1438		else fr
1444	1439		if (ga)
1445		-	then $Tuple2(-((ch + hx)), 0)
1446		-	else $Tuple2(0, -((ch + hx)))
	1440	+	then $Tuple2(-((ch + hA)), 0)
	1441	+	else $Tuple2(0, -((ch + hA)))
1447	1442		}
1448		-	let eL = hD._1
1449		-	let eM = hD._2
1450		-	let hE = eK(eL, eM, 0)
1451		-	let gP = hE._1
1452		-	let eB = hE._2
1453		-	let ha = eP(eJ, eB)
1454		-	if ((ha == ha))
1455		-	then $Tuple2(((((ev ++ gR) ++ hv) ++ hn) ++ gP), ch)
	1443	+	let eL = hG._1
	1444	+	let eM = hG._2

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

github/deemru/w8io/026f985 
304.38 ms ◑