tx · 45EcZ4Gs9aJD2wdXAf97tZHLipSGDFcahParJbc6iX5Q

3Mw8ZcMK47vENHqhYYhCZTCPDXhff6ZQVwt:  -0.06200000 Waves

2023.08.10 15:30 [2704489] smart account 3Mw8ZcMK47vENHqhYYhCZTCPDXhff6ZQVwt > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "45EcZ4Gs9aJD2wdXAf97tZHLipSGDFcahParJbc6iX5Q",
    "fee": 6200000,
    "feeAssetId": null,
    "timestamp": 1691670379489,
    "version": 2,
    "chainId": 84,
    "sender": "3Mw8ZcMK47vENHqhYYhCZTCPDXhff6ZQVwt",
    "senderPublicKey": "3fNYAZ872D7hsaic3sPDZd5uAk59U5CiWiA153FUZ6Qv",
    "proofs": [
        "5nBCEuWobsj2TP34WJ3vGiJhENRwZHBWVt3T2EtPSraxgNyCcFi2wubyG1wEL6tMacMurqKcc2Z6KYDNJDXgmkwx"
    ],
    "script": "base64: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",
    "height": 2704489,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: C7AFEknEoWCDGjqRfurQsA28eowsH5pUcEpec9G8QH6q
Next: 7EYmVN4bsGkpXRNwu8omCtmm7inQu7pZqWhPjn9m9t5S

Diff: 
Old
New
Differences
21
21
 
22
22
 
let j = 1000000
23
23
 
24
-
let k = toBigInt(1000000000000)
24
+
let k = toBigInt(1000000000000000000)
25
25
 
26
26
 
let l = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
27
27
 
1013
1013
 
        let cz = fraction((cw - cp(cv, cw, bD, bL, cj, ck, cl)), j, cb)
1014
1014
 
        let cA = (cz - cy)
1015
1015
 
        if (if ((0 >= cA))
1016
-
            then ((-1 * j) > cA)
1016
+
            then ((-1 * aZ()) > cA)
1017
1017
 
            else false)
1018
1018
 
            then throw(("_validateLiquidityInvariant: revert: diff=" + toString(cA)))
1019
1019
 
            else true
1025
1025
 
    let cD = (cw - cp(cv, cw, bD, bL, cj, ck, cl))
1026
1026
 
    let cA = (cD - cC)
1027
1027
 
    if (if ((0 >= cA))
1028
-
        then ((-1 * j) > cA)
1028
+
        then ((-1 * aZ()) > cA)
1029
1029
 
        else false)
1030
1030
 
        then throw(("_validateSwapInvariant: revert: diff=" + toString(cA)))
1031
1031
 
        else true
1050
1050
 
        else if ((cJ > ch))
1051
1051
 
            then if ((cF > cK))
1052
1052
 
                then throw("_validateAssetAllocation: new down")
1053
-
                else if (((cK - cF) > (cJ - ch)))
1053
+
                else if (((cJ - ch) > (cK - cF)))
1054
1054
 
                    then throw("_validateAssetAllocation: still down")
1055
1055
 
                    else true
1056
1056
 
            else true
1238
1238
 
func dH (O,bx) = {
1239
1239
 
    let bq = aH()
1240
1240
 
    let dk = bq._3
1241
-
    let dI = bq._6
1241
+
    let dI = bq._4
1242
+
    let dJ = bq._5
1243
+
    let dK = bq._6
1242
1244
 
    let dl = bq._7
1243
1245
 
    let dm = bq._8
1244
1246
 
    let dn = bq._9
1245
1247
 
    let do = aL()
1246
-
    let dJ = aR()
1247
-
    let dq = dJ._1
1248
-
    let dr = dJ._2
1249
-
    let dK = aN()
1250
-
    let dt = dK._1
1251
-
    let du = dK._2
1248
+
    let dL = aR()
1249
+
    let dq = dL._1
1250
+
    let dr = dL._2
1251
+
    let dM = aN()
1252
+
    let dt = dM._1
1253
+
    let du = dM._2
1252
1254
 
    let dE = bX(dt, value(indexOf(do, O)), bx)
1253
1255
 
    let dF = (du + bx)
1254
-
    let dG = cL(dE, dF, dt, du, dq, dr, dI)
1256
+
    let dG = cL(dE, dF, dt, du, dq, dr, dK)
1255
1257
 
    if ((dG == dG))
1256
1258
 
        then {
1257
-
            let dL = cp(dt, du, dq, dr, dl, dm, dn)
1258
-
            let dM = cp(dE, dF, dq, dr, dl, dm, dn)
1259
+
            let dN = cp(dt, du, dq, dr, dl, dm, dn)
1260
+
            let dO = cp(dE, dF, dq, dr, dl, dm, dn)
1259
1261
 
            let dC = if ((dk == 0))
1260
-
                then (dF - dM)
1262
+
                then throw("_deposit: empty pool")
1261
1263
 
                else {
1262
-
                    let dN = (dF - du)
1263
-
                    let dO = (dM - dL)
1264
-
                    let dP = fraction((dN - dO), j, (du - dL))
1265
-
                    let dQ = fraction(dk, dP, j)
1266
-
                    let dR = cs(dt, du, dE, dF, dk, (dk + dQ), dq, dr, dl, dm, dn)
1267
-
                    if ((dR == dR))
1268
-
                        then dQ
1264
+
                    let dP = (dF - du)
1265
+
                    let dQ = (dO - dN)
1266
+
                    let dR = fraction((dP - dQ), j, (du - dN))
1267
+
                    let dS = fraction(dk, dR, j)
1268
+
                    let dT = cs(dt, du, dE, dF, dk, (dk + dS), dq, dr, dl, dm, dn)
1269
+
                    if ((dT == dT))
1270
+
                        then dS
1269
1271
 
                        else throw("Strict value is not equal to itself.")
1270
1272
 
                    }
1271
-
            $Tuple2(dC, dE)
1272
-
            }
1273
-
        else throw("Strict value is not equal to itself.")
1274
-
    }
1275
-
1276
-
1277
-
func dS (bx) = {
1273
+
            let dU = db(0, dC, (dI / 2), (dJ / 2))
1274
+
            let dh = dU._1
1275
+
            let di = dU._2
1276
+
            let cZ = dU._3
1277
+
            $Tuple5(dC, dE, dh, di, cZ)
1278
+
            }
1279
+
        else throw("Strict value is not equal to itself.")
1280
+
    }
1281
+
1282
+
1283
+
func dV (bx) = {
1278
1284
 
    let bq = aH()
1279
1285
 
    let dk = bq._3
1280
-
    let dT = bq._4
1281
-
    let dU = bq._5
1282
-
    let dI = bq._6
1286
+
    let dK = bq._6
1283
1287
 
    let dl = bq._7
1284
1288
 
    let dm = bq._8
1285
1289
 
    let dn = bq._9
1286
-
    let dV = aN()
1287
-
    let dt = dV._1
1288
-
    let du = dV._2
1289
-
    let dW = aR()
1290
-
    let dq = dW._1
1291
-
    let dr = dW._2
1292
-
    let dX = db(0, bx, dT, dU)
1293
-
    let dh = dX._1
1294
-
    let di = dX._2
1295
-
    let cZ = dX._3
1296
-
    let dY = ((bx - dh) - di)
1290
+
    let dW = aN()
1291
+
    let dt = dW._1
1292
+
    let du = dW._2
1293
+
    let dX = aR()
1294
+
    let dq = dX._1
1295
+
    let dr = dX._2
1296
+
    let dY = bx
1297
1297
 
    let bW = P(dY, 0, c, "_withdrawAll: lpTokensToBurn less than 0")
1298
1298
 
    if ((bW == bW))
1299
1299
 
        then {
1303
1303
 
            let ea = dZ._3
1304
1304
 
            let dG = cs(dt, du, dE, dF, dk, (dk - dY), dq, dr, dl, dm, dn)
1305
1305
 
            if ((dG == dG))
1306
-
                then $Tuple6(dY, ea, dE, dh, di, cZ)
1306
+
                then $Tuple3(dY, ea, dE)
1307
1307
 
                else throw("Strict value is not equal to itself.")
1308
1308
 
            }
1309
1309
 
        else throw("Strict value is not equal to itself.")
1313
1313
 
func eb (O,ec) = {
1314
1314
 
    let bq = aH()
1315
1315
 
    let dk = bq._3
1316
-
    let dT = bq._4
1317
-
    let dU = bq._5
1318
-
    let dI = bq._6
1316
+
    let dI = bq._4
1317
+
    let dJ = bq._5
1318
+
    let dK = bq._6
1319
1319
 
    let dl = bq._7
1320
1320
 
    let dm = bq._8
1321
1321
 
    let dn = bq._9
1328
1328
 
    let dq = ef._1
1329
1329
 
    let dr = ef._2
1330
1330
 
    let eg = value(indexOf(do, O))
1331
-
    let dL = cp(dt, du, dq, dr, dl, dm, dn)
1332
-
    let eh = (du - dL)
1331
+
    let dN = cp(dt, du, dq, dr, dl, dm, dn)
1332
+
    let eh = (du - dN)
1333
1333
 
    let ei = fraction(toBigInt((dk - ec)), k, toBigInt(dk))
1334
1334
 
    let ej = toInt(fraction(toBigInt(eh), ei, k))
1335
1335
 
    func aa (ab,ac) =     if (ab._1)
1341
1341
 
            let en = bZ(dt, eg, em)
1342
1342
 
            let eo = (du - em)
1343
1343
 
            let ep = (eo - cp(en, eo, dq, dr, dl, dm, dn))
1344
-
            if (if ((ed > (ep - ej)))
1345
-
                then ((ep - ej) >= 0)
1344
+
            if (if (((ep - ej) > (-1 * ed)))
1345
+
                then (ed > (ep - ej))
1346
1346
 
                else false)
1347
1347
 
                then $Tuple4(true, ek, el, em)
1348
1348
 
                else if ((0 > (ep - ej)))
1349
-
                    then $Tuple4(false, ek, em, 0)
1350
-
                    else $Tuple4(false, em, el, 0)
1349
+
                    then $Tuple4(false, ek, em, em)
1350
+
                    else $Tuple4(false, em, el, em)
1351
1351
 
            }
1352
1352
 
1353
1353
 
    let eq = {
1354
-
        let eq = ec
1355
-
        let en = bZ(dt, eg, eq)
1356
-
        let eo = (du - eq)
1357
-
        let dM = cp(en, eo, dq, dr, dl, dm, dn)
1358
-
        let dO = (dM - dL)
1359
-
        if ((dO == 0))
1360
-
            then eq
1361
-
            else {
1362
-
                let er = {
1363
-
                    let ad = r
1364
-
                    let ae = size(ad)
1365
-
                    let af = $Tuple4(false, 0, (ec + dL), 0)
1366
-
                    func ag (ah,ai) =                     if ((ai >= ae))
1367
-
                        then ah
1368
-
                        else aa(ah, ad[ai])
1369
-
1370
-
                    func aj (ah,ai) =                     if ((ai >= ae))
1371
-
                        then ah
1372
-
                        else throw("List size exceeds 64")
1373
-
1374
-
                    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64)
1375
-
                    }
1376
-
                let es = er._1
1377
-
                let et = er._2
1378
-
                let eu = er._3
1379
-
                let ev = er._4
1380
-
                if (!(es))
1381
-
                    then throw(("_withdraw: can't calculate targetAmount=" + toString(ev)))
1382
-
                    else ev
1383
-
                }
1354
+
        let er = {
1355
+
            let ad = r
1356
+
            let ae = size(ad)
1357
+
            let af = $Tuple4(false, 0, (ec + dN), 0)
1358
+
            func ag (ah,ai) =             if ((ai >= ae))
1359
+
                then ah
1360
+
                else aa(ah, ad[ai])
1361
+
1362
+
            func aj (ah,ai) =             if ((ai >= ae))
1363
+
                then ah
1364
+
                else throw("List size exceeds 64")
1365
+
1366
+
            aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64)
1367
+
            }
1368
+
        let es = er._1
1369
+
        let et = er._2
1370
+
        let eu = er._3
1371
+
        let ev = er._4
1372
+
        if (!(es))
1373
+
            then throw(("_withdraw: can't calculate targetAmount=" + toString(ev)))
1374
+
            else ev
1384
1375
 
        }
1385
1376
 
    let ew = bZ(dt, eg, eq)
1386
1377
 
    let ex = (du - eq)
1387
-
    let ey = if (cL(ew, ex, dt, du, dq, dr, dI))
1378
+
    let ey = if (cL(ew, ex, dt, du, dq, dr, dK))
1388
1379
 
        then cs(dt, du, ew, ex, dk, (dk - ec), dq, dr, dl, dm, dn)
1389
1380
 
        else false
1390
1381
 
    if ((ey == ey))
1391
1382
 
        then {
1392
-
            let ez = db((eg + 1), eq, dT, dU)
1383
+
            let ez = db((eg + 1), eq, (dI / 2), (dJ / 2))
1393
1384
 
            let dh = ez._1
1394
1385
 
            let di = ez._2
1395
1386
 
            let cZ = ez._3
1404
1395
 
    let eE = bq._1
1405
1396
 
    let eF = bv(toBase58String(eE))
1406
1397
 
    let dk = bq._3
1407
-
    let dT = bq._4
1408
-
    let dU = bq._5
1409
-
    let dI = bq._6
1398
+
    let dI = bq._4
1399
+
    let dJ = bq._5
1400
+
    let dK = bq._6
1410
1401
 
    let dl = bq._7
1411
1402
 
    let dm = bq._8
1412
1403
 
    let dn = bq._9
1419
1410
 
    let dr = eH._2
1420
1411
 
    let dE = bX(dt, eB, eD)
1421
1412
 
    let dF = (du + eD)
1422
-
    let dL = cp(dt, du, dq, dr, dl, dm, dn)
1423
-
    let eh = (du - dL)
1413
+
    let dN = cp(dt, du, dq, dr, dl, dm, dn)
1414
+
    let eh = (du - dN)
1424
1415
 
    func aa (ab,ac) =     if (ab._1)
1425
1416
 
        then ab
1426
1417
 
        else {
1430
1421
 
            let en = bZ(dE, eC, em)
1431
1422
 
            let eo = (dF - em)
1432
1423
 
            let ep = (eo - cp(en, eo, dq, dr, dl, dm, dn))
1433
-
            if (if ((ed > (ep - eh)))
1434
-
                then ((ep - eh) >= 0)
1424
+
            if (if (((ep - eh) > (-1 * ed)))
1425
+
                then (ed > (ep - eh))
1435
1426
 
                else false)
1436
1427
 
                then $Tuple4(true, ek, el, em)
1437
1428
 
                else if ((0 > (ep - eh)))
1438
-
                    then $Tuple4(false, ek, em, 0)
1439
-
                    else $Tuple4(false, em, el, 0)
1429
+
                    then $Tuple4(false, ek, em, em)
1430
+
                    else $Tuple4(false, em, el, em)
1440
1431
 
            }
1441
1432
 
1442
1433
 
    let eq = {
1443
1434
 
        let eq = eD
1444
1435
 
        let en = bZ(dE, eC, eq)
1445
1436
 
        let eo = (dF - eq)
1446
-
        let dM = cp(en, eo, dq, dr, dl, dm, dn)
1447
-
        let dO = (dM - dL)
1448
-
        if ((dO == 0))
1437
+
        let dO = cp(en, eo, dq, dr, dl, dm, dn)
1438
+
        let dQ = (dO - dN)
1439
+
        if ((dQ == 0))
1449
1440
 
            then eq
1450
1441
 
            else {
1451
1442
 
                let eI = {
1452
1443
 
                    let ad = r
1453
1444
 
                    let ae = size(ad)
1454
-
                    let af = $Tuple4(false, 0, (eD + dL), 0)
1445
+
                    let af = $Tuple4(false, 0, (eD + dN), 0)
1455
1446
 
                    func ag (ah,ai) =                     if ((ai >= ae))
1456
1447
 
                        then ah
1457
1448
 
                        else aa(ah, ad[ai])
1473
1464
 
        }
1474
1465
 
    let ew = bZ(dE, eC, eq)
1475
1466
 
    let ex = (dF - eq)
1476
-
    let ey = if (cL(ew, ex, dt, du, dq, dr, dI))
1467
+
    let ey = if (cL(ew, ex, dt, du, dq, dr, dK))
1477
1468
 
        then cB(dt, du, ew, ex, dq, dr, dl, dm, dn)
1478
1469
 
        else false
1479
1470
 
    if ((ey == ey))
1480
1471
 
        then {
1481
-
            let eJ = db((eC + 1), eq, dT, dU)
1472
+
            let eJ = db((eC + 1), eq, dI, dJ)
1482
1473
 
            let dh = eJ._1
1483
1474
 
            let di = eJ._2
1484
1475
 
            let cZ = eJ._3
1489
1480
 
1490
1481
 
1491
1482
 
@Callable(eK)
1492
-
func init (al,bD,dd,de,eL,eM,eN,eO,cj,ck,cl,eP,eQ) = {
1493
-
    let bW = if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (bm(eK.caller))
1483
+
func init (al,bD,dd,de,eL,eM,eN,eO,cj,ck,cl,eP,eQ,aD) = {
1484
+
    let bW = if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (bm(eK.caller))
1494
1485
 
        then bp()
1495
1486
 
        else false)
1496
1487
 
        then bo()
1497
1488
 
        else false)
1498
1489
 
        then ak(al, "init: invalid assets")
1499
1490
 
        else false)
1500
-
        then Z(bD, 0, g, "init: invalid assetWeights")
1491
+
        then Z(bD, 1, g, "init: invalid assetWeights")
1501
1492
 
        else false)
1502
1493
 
        then am(size(al), size(bD), "init: invalid assetWeights size")
1503
1494
 
        else false)
1521
1512
 
        else false)
1522
1513
 
        then I(eP, "init: invalid protocolFeeContract")
1523
1514
 
        else false)
1524
-
        then P(eQ, 0, c, "init: invalid precision")
1515
+
        then P(eQ, 1, c, "init: invalid precision")
1516
+
        else false)
1517
+
        then I(aD, "init: invalid pauser")
1525
1518
 
        else false
1526
1519
 
    if ((bW == bW))
1527
1520
 
        then {
1532
1525
 
            let eS = Issue(eL, eM, 0, eN, true)
1533
1526
 
            let eE = calculateAssetId(eS)
1534
1527
 
            let eT = $Tuple10(eE, true, 0, dd, de, eO, cj, ck, cl, addressFromStringValue(eP))
1535
-
            $Tuple2((((((([eS] ++ aJ(eT)) ++ aM(al)) ++ aP(dE)) ++ aT(dq)) ++ ba(eQ)) ++ bc(bb())), unit)
1528
+
            $Tuple2(((((((([eS] ++ aJ(eT)) ++ aM(al)) ++ aP(dE)) ++ aT(dq)) ++ ba(eQ)) ++ bc(bb())) ++ aC(addressFromStringValue(aD))), unit)
1536
1529
 
            }
1537
1530
 
        else throw("Strict value is not equal to itself.")
1538
1531
 
    }
1610
1603
 
        then {
1611
1604
 
            let bq = aH()
1612
1605
 
            let eE = bq._1
1613
-
            let eF = bv(toBase58String(eE))
1606
+
            let fb = av(eE)
1607
+
            let eF = bv(fb)
1614
1608
 
            let ey = if (if (if (if (br())
1615
1609
 
                then bs()
1616
1610
 
                else false)
1618
1612
 
                else false)
1619
1613
 
                then at(aL(), av(eK.payments[0].assetId), "deposit: invalid payment asset")
1620
1614
 
                else false)
1621
-
                then P(eK.payments[0].amount, 0, c, "deposit: invalid payment amount")
1615
+
                then P(eK.payments[0].amount, 1, c, "deposit: invalid payment amount")
1622
1616
 
                else false
1623
1617
 
            if ((ey == ey))
1624
1618
 
                then {
1625
-
                    let fb = av(eK.payments[0].assetId)
1626
-
                    let bG = bv(fb)
1627
-
                    let fc = bw(eK.payments[0].amount, bG, eF, DOWN)
1628
-
                    let fd = dH(fb, fc)
1629
-
                    let dC = fd._1
1630
-
                    let dE = fd._2
1631
-
                    let dG = P(dC, fa, c, "deposit: less than min lp")
1619
+
                    let fc = av(eK.payments[0].assetId)
1620
+
                    let bG = bv(fc)
1621
+
                    let fd = bw(eK.payments[0].amount, bG, eF, DOWN)
1622
+
                    let fe = dH(fc, fd)
1623
+
                    let dC = fe._1
1624
+
                    let dE = fe._2
1625
+
                    let dh = fe._3
1626
+
                    let di = fe._4
1627
+
                    let cZ = fe._5
1628
+
                    let ff = ((dC - dh) - di)
1629
+
                    let dG = P(ff, fa, c, "deposit: less than min")
1632
1630
 
                    if ((dG == dG))
1633
1631
 
                        then {
1634
1632
 
                            let eT = $Tuple10(bq._1, bq._2, (bq._3 + dC), bq._4, bq._5, bq._6, bq._7, bq._8, bq._9, bq._10)
1635
-
                            $Tuple2((([Reissue(eE, dC, true), ScriptTransfer(eK.caller, dC, eE)] ++ aJ(eT)) ++ aP(dE)), unit)
1633
+
                            $Tuple2(((((([Reissue(eE, dC, true), ScriptTransfer(eK.caller, ff, eE)] ++ aJ(eT)) ++ aP(dE)) ++ aW(fb, (dh + aV(fb)))) ++ aY(fb, (di + aX(fb)))) ++ bc(cZ)), unit)
1636
1634
 
                            }
1637
1635
 
                        else throw("Strict value is not equal to itself.")
1638
1636
 
                    }
1647
1645
 
func withdrawAll () = {
1648
1646
 
    let bq = aH()
1649
1647
 
    let eE = bq._1
1650
-
    let fe = toBase58String(eE)
1651
-
    let eF = bv(fe)
1648
+
    let fb = toBase58String(eE)
1649
+
    let eF = bv(fb)
1652
1650
 
    let do = aL()
1653
1651
 
    let bW = if (if (if (if (br())
1654
1652
 
        then bs()
1655
1653
 
        else false)
1656
1654
 
        then am(size(eK.payments), 1, "withdrawAll: invalid payments size")
1657
1655
 
        else false)
1658
-
        then V(fe, av(eK.payments[0].assetId), "withdrawAll: invalid payment asset")
1659
-
        else false)
1660
-
        then P(eK.payments[0].amount, 0, c, "withdrawAll: invalid payment amount")
1656
+
        then V(fb, av(eK.payments[0].assetId), "withdrawAll: invalid payment asset")
1657
+
        else false)
1658
+
        then P(eK.payments[0].amount, 1, c, "withdrawAll: invalid payment amount")
1661
1659
 
        else false
1662
1660
 
    if ((bW == bW))
1663
1661
 
        then {
1664
-
            let ff = dS(eK.payments[0].amount)
1665
-
            let dY = ff._1
1666
-
            let ea = ff._2
1667
-
            let dE = ff._3
1668
-
            let dh = ff._4
1669
-
            let di = ff._5
1670
-
            let cZ = ff._6
1671
-
            let fg = ce(do, ea, eK.caller, eF)
1662
+
            let fg = dV(eK.payments[0].amount)
1663
+
            let dY = fg._1
1664
+
            let ea = fg._2
1665
+
            let dE = fg._3
1666
+
            let fh = ce(do, ea, eK.caller, eF)
1672
1667
 
            let eT = $Tuple10(bq._1, bq._2, (bq._3 - dY), bq._4, bq._5, bq._6, bq._7, bq._8, bq._9, bq._10)
1673
-
            $Tuple2((((((([Burn(eE, dY)] ++ fg) ++ aJ(eT)) ++ aP(dE)) ++ aW(fe, (dh + aV(fe)))) ++ aY(fe, (di + aX(fe)))) ++ bc(cZ)), unit)
1668
+
            $Tuple2(((([Burn(eE, dY)] ++ fh) ++ aJ(eT)) ++ aP(dE)), unit)
1674
1669
 
            }
1675
1670
 
        else throw("Strict value is not equal to itself.")
1676
1671
 
    }
1678
1673
 
1679
1674
 
1680
1675
 
@Callable(eK)
1681
-
func withdraw (O,fh) = {
1676
+
func withdraw (O,fi) = {
1682
1677
 
    let bq = aH()
1683
1678
 
    let eE = bq._1
1684
-
    let fe = toBase58String(eE)
1685
-
    let eF = bv(fe)
1679
+
    let fb = toBase58String(eE)
1680
+
    let eF = bv(fb)
1686
1681
 
    let do = aL()
1687
1682
 
    let bW = if (if (if (if (if (if (br())
1688
1683
 
        then bs()
1689
1684
 
        else false)
1690
1685
 
        then am(size(eK.payments), 1, "withdraw: invalid payments size")
1691
1686
 
        else false)
1692
-
        then V(fe, av(eK.payments[0].assetId), "withdraw: invalid payment asset")
1693
-
        else false)
1694
-
        then P(eK.payments[0].amount, 0, c, "withdraw: invalid payment amount")
1687
+
        then V(fb, av(eK.payments[0].assetId), "withdraw: invalid payment asset")
1688
+
        else false)
1689
+
        then P(eK.payments[0].amount, 1, c, "withdraw: invalid payment amount")
1695
1690
 
        else false)
1696
1691
 
        then at(do, O, "withdraw: invalid assetId")
1697
1692
 
        else false)
1698
-
        then P(fh, 0, c, "withdraw: invalid minAmount")
1693
+
        then P(fi, 0, c, "withdraw: invalid minAmount")
1699
1694
 
        else false
1700
1695
 
    if ((bW == bW))
1701
1696
 
        then {
1702
-
            let fi = eb(O, eK.payments[0].amount)
1703
-
            let fj = fi._1
1704
-
            let ew = fi._2
1705
-
            let dh = fi._3
1706
-
            let di = fi._4
1707
-
            let cZ = fi._5
1708
-
            let fk = ((fj - dh) - di)
1709
-
            let fl = bv(O)
1710
-
            let fm = bw(fk, eF, fl, DOWN)
1711
-
            let ey = P(fm, fh, c, "withdraw: insufficient final amount")
1697
+
            let fj = eb(O, eK.payments[0].amount)
1698
+
            let fk = fj._1
1699
+
            let ew = fj._2
1700
+
            let dh = fj._3
1701
+
            let di = fj._4
1702
+
            let cZ = fj._5
1703
+
            let fl = ((fk - dh) - di)
1704
+
            let fm = bv(O)
1705
+
            let fn = bw(fl, eF, fm, DOWN)
1706
+
            let ey = P(fn, fi, c, "withdraw: less than min")
1712
1707
 
            if ((ey == ey))
1713
1708
 
                then {
1714
1709
 
                    let eT = $Tuple10(bq._1, bq._2, (bq._3 - eK.payments[0].amount), bq._4, bq._5, bq._6, bq._7, bq._8, bq._9, bq._10)
1715
-
                    $Tuple2(((((([Burn(eE, eK.payments[0].amount), ScriptTransfer(eK.caller, fm, ax(O))] ++ aJ(eT)) ++ aP(ew)) ++ aW(O, (dh + aV(O)))) ++ aY(O, (di + aX(O)))) ++ bc(cZ)), unit)
1710
+
                    $Tuple2(((((([Burn(eE, eK.payments[0].amount), ScriptTransfer(eK.caller, fn, ax(O))] ++ aJ(eT)) ++ aP(ew)) ++ aW(O, (dh + aV(O)))) ++ aY(O, (di + aX(O)))) ++ bc(cZ)), unit)
1716
1711
 
                    }
1717
1712
 
                else throw("Strict value is not equal to itself.")
1718
1713
 
            }
1722
1717
 
1723
1718
 
1724
1719
 
@Callable(eK)
1725
-
func swap (fn,fh) = {
1720
+
func swap (fo,fi) = {
1726
1721
 
    let bq = aH()
1727
1722
 
    let eE = bq._1
1728
1723
 
    let eF = bv(toBase58String(eE))
1729
1724
 
    let do = aL()
1730
-
    let fo = av(eK.payments[0].assetId)
1731
-
    let fp = bw(eK.payments[0].amount, bv(fo), eF, DOWN)
1732
-
    let fq = valueOrErrorMessage(indexOf(do, fo), "swap: invalid source asset")
1733
-
    if ((fq == fq))
1734
-
        then {
1735
-
            let eg = valueOrErrorMessage(indexOf(do, fn), "swap: invalid target asset")
1725
+
    let fp = av(eK.payments[0].assetId)
1726
+
    let fq = bw(eK.payments[0].amount, bv(fp), eF, DOWN)
1727
+
    let fr = valueOrErrorMessage(indexOf(do, fp), "swap: invalid source asset")
1728
+
    if ((fr == fr))
1729
+
        then {
1730
+
            let eg = valueOrErrorMessage(indexOf(do, fo), "swap: invalid target asset")
1736
1731
 
            if ((eg == eg))
1737
1732
 
                then {
1738
1733
 
                    let bW = if (if (if (if (if (br())
1739
1734
 
                        then bs()
1740
1735
 
                        else false)
1741
-
                        then P(fh, 0, c, "swap: invalid min target amount")
1736
+
                        then P(fi, 0, c, "swap: invalid min target amount")
1742
1737
 
                        else false)
1743
-
                        then P(fp, 0, c, "swap: invalid source amount")
1738
+
                        then P(fq, 1, c, "swap: invalid source amount")
1744
1739
 
                        else false)
1745
-
                        then Y(fo, fn, "swap: same assets")
1740
+
                        then Y(fp, fo, "swap: same assets")
1746
1741
 
                        else false)
1747
1742
 
                        then am(size(eK.payments), 1, "swap: invalid payments size")
1748
1743
 
                        else false
1749
1744
 
                    if ((bW == bW))
1750
1745
 
                        then {
1751
-
                            let fr = eA(fq, eg, fp)
1752
-
                            let fj = fr._1
1753
-
                            let ew = fr._2
1754
-
                            let dh = fr._3
1755
-
                            let di = fr._4
1756
-
                            let cZ = fr._5
1757
-
                            let fk = ((fj - dh) - di)
1758
-
                            let fl = bv(fn)
1759
-
                            let fm = bw(fk, eF, fl, DOWN)
1760
-
                            let ey = P(fm, fh, c, "swap: insufficient final amount")
1746
+
                            let fs = eA(fr, eg, fq)
1747
+
                            let fk = fs._1
1748
+
                            let ew = fs._2
1749
+
                            let dh = fs._3
1750
+
                            let di = fs._4
1751
+
                            let cZ = fs._5
1752
+
                            let fl = ((fk - dh) - di)
1753
+
                            let fm = bv(fo)
1754
+
                            let fn = bw(fl, eF, fm, DOWN)
1755
+
                            let ey = P(fn, fi, c, "swap: less than min")
1761
1756
 
                            if ((ey == ey))
1762
-
                                then $Tuple2((((([ScriptTransfer(eK.caller, fm, ax(fn))] ++ aP(ew)) ++ aW(fn, (dh + aV(fn)))) ++ aY(fn, (di + aX(fn)))) ++ bc(cZ)), unit)
1757
+
                                then $Tuple2((((([ScriptTransfer(eK.caller, fn, ax(fo))] ++ aP(ew)) ++ aW(fo, (dh + aV(fo)))) ++ aY(fo, (di + aX(fo)))) ++ bc(cZ)), unit)
1763
1758
 
                                else throw("Strict value is not equal to itself.")
1764
1759
 
                            }
1765
1760
 
                        else throw("Strict value is not equal to itself.")
1773
1768
 
1774
1769
 
@Callable(eK)
1775
1770
 
func getDepositAll (ec) = {
1776
-
    let bW = P(ec, 0, c, "getDepositAll: invalid amount")
1771
+
    let bW = P(ec, 1, c, "getDepositAll: invalid amount")
1777
1772
 
    if ((bW == bW))
1778
1773
 
        then {
1779
-
            let fs = dj(ec)
1780
-
            let dC = fs._1
1781
-
            let dy = fs._2
1782
-
            let dE = fs._3
1774
+
            let ft = dj(ec)
1775
+
            let dC = ft._1
1776
+
            let dy = ft._2
1777
+
            let dE = ft._3
1783
1778
 
            $Tuple2(nil, $Tuple2(dC, dy))
1784
1779
 
            }
1785
1780
 
        else throw("Strict value is not equal to itself.")
1790
1785
 
@Callable(eK)
1791
1786
 
func getDeposit (O,bx) = {
1792
1787
 
    let bW = if (at(aL(), O, "getDeposit: invalid asset"))
1793
-
        then P(bx, 0, c, "getDeposit: invalid amount")
1788
+
        then P(bx, 1, c, "getDeposit: invalid amount")
1794
1789
 
        else false
1795
1790
 
    if ((bW == bW))
1796
1791
 
        then {
1798
1793
 
            let eE = bq._1
1799
1794
 
            let eF = bv(toBase58String(eE))
1800
1795
 
            let bG = bv(O)
1801
-
            let fc = bw(bx, bG, eF, DOWN)
1802
-
            let ft = dH(O, fc)
1803
-
            let dC = ft._1
1804
-
            let dE = ft._2
1805
-
            $Tuple2(nil, dC)
1796
+
            let fd = bw(bx, bG, eF, DOWN)
1797
+
            let fu = dH(O, fd)
1798
+
            let dC = fu._1
1799
+
            let dE = fu._2
1800
+
            let dh = fu._3
1801
+
            let di = fu._4
1802
+
            let cZ = fu._5
1803
+
            let ff = ((dC - dh) - di)
1804
+
            $Tuple2(nil, ff)
1806
1805
 
            }
1807
1806
 
        else throw("Strict value is not equal to itself.")
1808
1807
 
    }
1814
1813
 
    let bW = P(ec, 0, c, "getWithdrawAll: invalid amount")
1815
1814
 
    if ((bW == bW))
1816
1815
 
        then {
1817
-
            let fu = dS(ec)
1818
-
            let dY = fu._1
1819
-
            let fv = fu._2
1820
-
            let dE = fu._3
1821
-
            let dh = fu._4
1822
-
            let di = fu._5
1823
-
            let cZ = fu._6
1824
-
            $Tuple2(nil, fv)
1816
+
            let fv = dV(ec)
1817
+
            let dY = fv._1
1818
+
            let fw = fv._2
1819
+
            let dE = fv._3
1820
+
            $Tuple2(nil, fw)
1825
1821
 
            }
1826
1822
 
        else throw("Strict value is not equal to itself.")
1827
1823
 
    }
1831
1827
 
@Callable(eK)
1832
1828
 
func getWithdraw (O,bx) = {
1833
1829
 
    let bW = if (at(aL(), O, "getWithdraw: invalid asset"))
1834
-
        then P(bx, 0, c, "getWithdraw: invalid amount")
1830
+
        then P(bx, 1, c, "getWithdraw: invalid amount")
1835
1831
 
        else false
1836
1832
 
    if ((bW == bW))
1837
1833
 
        then {
1838
1834
 
            let bq = aH()
1839
1835
 
            let eE = bq._1
1840
1836
 
            let eF = bv(toBase58String(eE))
1841
-
            let fw = eb(O, bx)
1842
-
            let fj = fw._1
1843
-
            let dE = fw._2
1844
-
            let dh = fw._3
1845
-
            let di = fw._4
1846
-
            let cZ = fw._5
1847
-
            let fk = ((fj - dh) - di)
1848
-
            let fl = bv(O)
1849
-
            let fm = bw(fk, eF, fl, DOWN)
1850
-
            $Tuple2(nil, fm)
1837
+
            let fx = eb(O, bx)
1838
+
            let fk = fx._1
1839
+
            let dE = fx._2
1840
+
            let dh = fx._3
1841
+
            let di = fx._4
1842
+
            let cZ = fx._5
1843
+
            let fl = ((fk - dh) - di)
1844
+
            let fm = bv(O)
1845
+
            let fn = bw(fl, eF, fm, DOWN)
1846
+
            $Tuple2(nil, fn)
1851
1847
 
            }
1852
1848
 
        else throw("Strict value is not equal to itself.")
1853
1849
 
    }
1855
1851
 
1856
1852
 
1857
1853
 
@Callable(eK)
1858
-
func getSwap (fx,fn,eD) = {
1854
+
func getSwap (fy,fo,eD) = {
1859
1855
 
    let bq = aH()
1860
1856
 
    let eE = bq._1
1861
1857
 
    let eF = bv(toBase58String(eE))
1862
1858
 
    let do = aL()
1863
-
    let fq = valueOrErrorMessage(indexOf(do, fx), "swap: invalid source asset")
1864
-
    if ((fq == fq))
1865
-
        then {
1866
-
            let eg = valueOrErrorMessage(indexOf(do, fn), "swap: invalid target asset")
1859
+
    let fr = valueOrErrorMessage(indexOf(do, fy), "swap: invalid source asset")
1860
+
    if ((fr == fr))
1861
+
        then {
1862
+
            let eg = valueOrErrorMessage(indexOf(do, fo), "swap: invalid target asset")
1867
1863
 
            if ((eg == eg))
1868
1864
 
                then {
1869
-
                    let fp = bw(eD, bv(fx), eF, DOWN)
1870
-
                    let bW = if (P(fp, 0, c, "swap: invalid source amount"))
1871
-
                        then Y(fx, fn, "swap: same assets")
1865
+
                    let fq = bw(eD, bv(fy), eF, DOWN)
1866
+
                    let bW = if (P(fq, 1, c, "swap: invalid source amount"))
1867
+
                        then Y(fy, fo, "swap: same assets")
1872
1868
 
                        else false
1873
1869
 
                    if ((bW == bW))
1874
1870
 
                        then {
1875
-
                            let fy = eA(fq, eg, fp)
1876
-
                            let fj = fy._1
1877
-
                            let ew = fy._2
1878
-
                            let dh = fy._3
1879
-
                            let di = fy._4
1880
-
                            let cZ = fy._5
1881
-
                            let fk = ((fj - dh) - di)
1882
-
                            let fl = bv(fn)
1883
-
                            let fm = bw(fk, eF, fl, DOWN)
1884
-
                            $Tuple2(nil, fm)
1871
+
                            let fz = eA(fr, eg, fq)
1872
+
                            let fk = fz._1
1873
+
                            let ew = fz._2
1874
+
                            let dh = fz._3
1875
+
                            let di = fz._4
1876
+
                            let cZ = fz._5
1877
+
                            let fl = ((fk - dh) - di)
1878
+
                            let fm = bv(fo)
1879
+
                            let fn = bw(fl, eF, fm, DOWN)
1880
+
                            $Tuple2(nil, fn)
1885
1881
 
                            }
1886
1882
 
                        else throw("Strict value is not equal to itself.")
1887
1883
 
                    }
1894
1890
 
1895
1891
 
@Callable(eK)
1896
1892
 
func getClaim (be) = {
1897
-
    let fz = if ((size(be) > 0))
1893
+
    let fA = if ((size(be) > 0))
1898
1894
 
        then valueOrErrorMessage(addressFromString(be), "getClaim: invalid user")
1899
1895
 
        else eK.caller
1900
-
    let fA = cM(fz)
1901
-
    let fB = fA._1
1902
-
    let cO = fA._2
1896
+
    let fB = cM(fA)
1897
+
    let fC = fB._1
1898
+
    let cO = fB._2
1903
1899
 
    $Tuple2(nil, cO)
1904
1900
 
    }
1905
1901
 
1912
1908
 
    let dl = bq._7
1913
1909
 
    let dm = bq._8
1914
1910
 
    let dn = bq._9
1915
-
    let fC = aN()
1916
-
    let dE = fC._1
1917
-
    let dF = fC._2
1918
-
    let fD = aR()
1919
-
    let dq = fD._1
1920
-
    let dr = fD._2
1921
-
    let dM = cp(dE, dF, dq, dr, dl, dm, dn)
1922
-
    let ep = (dF - dM)
1911
+
    let fD = aN()
1912
+
    let dE = fD._1
1913
+
    let dF = fD._2
1914
+
    let fE = aR()
1915
+
    let dq = fE._1
1916
+
    let dr = fE._2
1917
+
    let dO = cp(dE, dF, dq, dr, dl, dm, dn)
1918
+
    let ep = (dF - dO)
1923
1919
 
    $Tuple2(nil, $Tuple2(ep, dk))
1920
+
    }
1921
+
1922
+
1923
+
1924
+
@Callable(eK)
1925
+
func getFeeFunc () = {
1926
+
    let bq = aH()
1927
+
    let dl = bq._7
1928
+
    let dm = bq._8
1929
+
    let dn = bq._9
1930
+
    let fF = aN()
1931
+
    let dE = fF._1
1932
+
    let dF = fF._2
1933
+
    let fG = aR()
1934
+
    let dq = fG._1
1935
+
    let dr = fG._2
1936
+
    let dO = cp(dE, dF, dq, dr, dl, dm, dn)
1937
+
    $Tuple2(nil, dO)
1924
1938
 
    }
1925
1939
 
1926
1940
 
1932
1946
 
        else false
1933
1947
 
    if ((bW == bW))
1934
1948
 
        then {
1935
-
            let fz = if ((size(be) > 0))
1949
+
            let fA = if ((size(be) > 0))
1936
1950
 
                then valueOrErrorMessage(addressFromString(be), "checkpoint: invalid user")
1937
1951
 
                else eK.caller
1938
-
            cM(fz)
1952
+
            cM(fA)
1939
1953
 
            }
1940
1954
 
        else throw("Strict value is not equal to itself.")
1941
1955
 
    }
1950
1964
 
    if ((bW == bW))
1951
1965
 
        then {
1952
1966
 
            let bq = aH()
1953
-
            let fe = av(bq._1)
1967
+
            let fb = av(bq._1)
1954
1968
 
            let ey = if (if (am(size(eK.payments), 1, "stake: invalid payments size"))
1955
-
                then V(fe, av(eK.payments[0].assetId), "stake: invalid payment asset")
1969
+
                then V(fb, av(eK.payments[0].assetId), "stake: invalid payment asset")
1956
1970
 
                else false)
1957
1971
 
                then P(eK.payments[0].amount, 0, c, "stake: invalid payment amount")
1958
1972
 
                else false
1959
1973
 
            if ((ey == ey))
1960
1974
 
                then {
1961
-
                    let fE = cM(eK.caller)
1962
-
                    let fB = fE._1
1963
-
                    let cO = fE._2
1964
-
                    $Tuple2(((fB ++ bh(eK.caller, (bg(eK.caller) + eK.payments[0].amount))) ++ bj((bi() + eK.payments[0].amount))), unit)
1975
+
                    let fH = cM(eK.caller)
1976
+
                    let fC = fH._1
1977
+
                    let cO = fH._2
1978
+
                    $Tuple2(((fC ++ bh(eK.caller, (bg(eK.caller) + eK.payments[0].amount))) ++ bj((bi() + eK.payments[0].amount))), unit)
1965
1979
 
                    }
1966
1980
 
                else throw("Strict value is not equal to itself.")
1967
1981
 
            }
1983
1997
 
            let ey = P(bx, 0, cN, "unstake: invalid amount")
1984
1998
 
            if ((ey == ey))
1985
1999
 
                then {
1986
-
                    let fF = cM(eK.caller)
1987
-
                    let fB = fF._1
1988
-
                    let cO = fF._2
1989
-
                    $Tuple2(((([ScriptTransfer(eK.caller, bx, eE)] ++ fB) ++ bh(eK.caller, (cN - bx))) ++ bj((bi() - bx))), unit)
2000
+
                    let fI = cM(eK.caller)
2001
+
                    let fC = fI._1
2002
+
                    let cO = fI._2
2003
+
                    $Tuple2(((([ScriptTransfer(eK.caller, bx, eE)] ++ fC) ++ bh(eK.caller, (cN - bx))) ++ bj((bi() - bx))), unit)
1990
2004
 
                    }
1991
2005
 
                else throw("Strict value is not equal to itself.")
1992
2006
 
            }
1996
2010
 
1997
2011
 
1998
2012
 
@Callable(eK)
1999
-
func claim (be,al) = {
2000
-
    let bW = if (if (br())
2013
+
func claim (be) = {
2014
+
    let bW = if (br())
2001
2015
 
        then bs()
2002
-
        else false)
2003
-
        then P(size(al), 1, 10, "claim: invalid assets size")
2004
2016
 
        else false
2005
2017
 
    if ((bW == bW))
2006
2018
 
        then {
2007
-
            let fz = if ((size(be) > 0))
2019
+
            let fA = if ((size(be) > 0))
2008
2020
 
                then valueOrErrorMessage(addressFromString(be), "claim: invalid user")
2009
2021
 
                else eK.caller
2010
2022
 
            let bq = aH()
2011
2023
 
            let eE = bq._1
2012
-
            let fe = av(eE)
2013
-
            let do = [fe, aL()]
2014
-
            let fG = (size(do) - 1)
2015
-
            let cN = bg(fz)
2016
-
            let fH = cM(fz)
2017
-
            let fB = fH._1
2018
-
            let cO = fH._2
2019
-
            func aa (ab,fI) =             {
2024
+
            let fb = av(eE)
2025
+
            let do = [fb, aL()]
2026
+
            let fJ = (size(do) - 1)
2027
+
            let cN = bg(fA)
2028
+
            let fK = cM(fA)
2029
+
            let fC = fK._1
2030
+
            let cO = fK._2
2031
+
            func aa (ab,fL) =             {
2020
2032
 
                let bO = ab._1
2021
-
                if ((bO > fG))
2022
-
                    then $Tuple3((bO + 1), (ab._2 :+ fI), ab._3)
2023
-
                    else {
2024
-
                        let fJ = do[bO]
2025
-
                        if (containsElement(al, fJ))
2026
-
                            then $Tuple3((bO + 1), (ab._2 :+ 0), (ab._3 :+ ScriptTransfer(fz, fI, ax(fJ))))
2027
-
                            else $Tuple3((bO + 1), (ab._2 :+ fI), ab._3)
2033
+
                if (if ((fJ >= bO))
2034
+
                    then (fL > 0)
2035
+
                    else false)
2036
+
                    then {
2037
+
                        let fM = do[bO]
2038
+
                        $Tuple3((bO + 1), (ab._2 :+ 0), (ab._3 :+ ScriptTransfer(fA, fL, ax(fM))))
2028
2039
 
                        }
2040
+
                    else $Tuple3((bO + 1), (ab._2 :+ fL), ab._3)
2029
2041
 
                }
2030
2042
 
2031
-
            let fK = {
2043
+
            let fN = {
2032
2044
 
                let ad = cO
2033
2045
 
                let ae = size(ad)
2034
2046
 
                let af = $Tuple3(0, nil, nil)
2042
2054
 
2043
2055
 
                aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
2044
2056
 
                }
2045
-
            let cT = fK._1
2046
-
            let fL = fK._2
2047
-
            let fM = fK._3
2048
-
            $Tuple2(((fM ++ removeByIndex(fB, 0)) ++ bl(fz, fL)), unit)
2057
+
            let cT = fN._1
2058
+
            let fO = fN._2
2059
+
            let fP = fN._3
2060
+
            $Tuple2(((fP ++ removeByIndex(fC, 0)) ++ bl(fA, fO)), unit)
2049
2061
 
            }
2050
2062
 
        else throw("Strict value is not equal to itself.")
2051
2063
 
    }
2105
2117
 
    }
2106
2118
 
2107
2119
 
2108
-
@Verifier(fN)
2109
-
func fO () = {
2120
+
@Verifier(fQ)
2121
+
func fR () = {
2110
2122
 
    let L = getString(s)
2111
2123
 
    if ($isInstanceOf(L, "String"))
2112
2124
 
        then {
2113
-
            let fP = L
2114
-
            valueOrElse(getBoolean(addressFromStringValue(fP), makeString([t, toString(this), toBase58String(fN.id)], a)), false)
2115
-
            }
2116
-
        else sigVerify(fN.bodyBytes, fN.proofs[0], fN.senderPublicKey)
2125
+
            let fS = L
2126
+
            valueOrElse(getBoolean(addressFromStringValue(fS), makeString([t, toString(this), toBase58String(fQ.id)], a)), false)
2127
+
            }
2128
+
        else sigVerify(fQ.bodyBytes, fQ.proofs[0], fQ.senderPublicKey)
2117
2129
 
    }
2118
2130
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let a = "__"
5
5
 
6
6
 
let b = "waves"
7
7
 
8
8
 
let c = 9223372036854775807
9
9
 
10
10
 
let d = 1000000
11
11
 
12
12
 
let e = 1000000
13
13
 
14
14
 
let f = 1000000
15
15
 
16
16
 
let g = 1000000
17
17
 
18
18
 
let h = 1000000
19
19
 
20
20
 
let i = 1000000
21
21
 
22
22
 
let j = 1000000
23
23
 
24
-
let k = toBigInt(1000000000000)
24
+
let k = toBigInt(1000000000000000000)
25
25
 
26
26
 
let l = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
27
27
 
28
28
 
let m = (l :+ 0)
29
29
 
30
30
 
let n = toBigInt(0)
31
31
 
32
32
 
let o = [n, n, n, n, n, n, n, n, n, n, n]
33
33
 
34
34
 
let p = 8
35
35
 
36
36
 
let q = 18
37
37
 
38
38
 
let r = split_51C("0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0", "_")
39
39
 
40
40
 
let s = "MULTISIG"
41
41
 
42
42
 
let t = "STATUS"
43
43
 
44
44
 
let u = "PAUSED"
45
45
 
46
46
 
let v = "PAUSER"
47
47
 
48
48
 
let w = "STORAGE"
49
49
 
50
50
 
let x = "ASSETS"
51
51
 
52
52
 
let y = "ASSET_BALANCES"
53
53
 
54
54
 
let z = "ASSET_WEIGHTS"
55
55
 
56
56
 
let A = "LP_FEE"
57
57
 
58
58
 
let B = "PROTOCOL_FEE"
59
59
 
60
60
 
let C = "PRECISION"
61
61
 
62
62
 
let D = "SIGMA_FEE_PER_LP"
63
63
 
64
64
 
let E = "USER_SIGMA_FEE_PER_LP"
65
65
 
66
66
 
let F = "USER_LP"
67
67
 
68
68
 
let G = "TOTAL_LP"
69
69
 
70
70
 
let H = "USER_PROFITS"
71
71
 
72
72
 
func I (J,K) = {
73
73
 
    let L = addressFromString(J)
74
74
 
    if ($isInstanceOf(L, "Address"))
75
75
 
        then {
76
76
 
            let M = L
77
77
 
            true
78
78
 
            }
79
79
 
        else throw(K)
80
80
 
    }
81
81
 
82
82
 
83
83
 
func N (O,K) = if ((O == b))
84
84
 
    then true
85
85
 
    else {
86
86
 
        let L = assetInfo(fromBase58String(O))
87
87
 
        if ($isInstanceOf(L, "Asset"))
88
88
 
            then {
89
89
 
                let M = L
90
90
 
                true
91
91
 
                }
92
92
 
            else throw(K)
93
93
 
        }
94
94
 
95
95
 
96
96
 
func P (Q,R,S,K) = if (if ((R > Q))
97
97
 
    then true
98
98
 
    else (Q > S))
99
99
 
    then throw(K)
100
100
 
    else true
101
101
 
102
102
 
103
103
 
func T (Q,U,K) = if ((Q != U))
104
104
 
    then throw(K)
105
105
 
    else true
106
106
 
107
107
 
108
108
 
func V (W,X,K) = if ((W != X))
109
109
 
    then throw(K)
110
110
 
    else true
111
111
 
112
112
 
113
113
 
func Y (W,X,K) = if ((W == X))
114
114
 
    then throw(K)
115
115
 
    else true
116
116
 
117
117
 
118
118
 
func Z (Q,R,S,K) = {
119
119
 
    func aa (ab,ac) =     {
120
120
 
        let L = parseInt(ac)
121
121
 
        if ($isInstanceOf(L, "Int"))
122
122
 
            then {
123
123
 
                let M = L
124
124
 
                if (ab)
125
125
 
                    then P(M, R, S, K)
126
126
 
                    else false
127
127
 
                }
128
128
 
            else throw(K)
129
129
 
        }
130
130
 
131
131
 
    let ad = Q
132
132
 
    let ae = size(ad)
133
133
 
    let af = true
134
134
 
    func ag (ah,ai) =     if ((ai >= ae))
135
135
 
        then ah
136
136
 
        else aa(ah, ad[ai])
137
137
 
138
138
 
    func aj (ah,ai) =     if ((ai >= ae))
139
139
 
        then ah
140
140
 
        else throw("List size exceeds 10")
141
141
 
142
142
 
    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
143
143
 
    }
144
144
 
145
145
 
146
146
 
func ak (al,K) = {
147
147
 
    func aa (ab,ac) =     if (ab)
148
148
 
        then N(ac, K)
149
149
 
        else false
150
150
 
151
151
 
    let ad = al
152
152
 
    let ae = size(ad)
153
153
 
    let af = true
154
154
 
    func ag (ah,ai) =     if ((ai >= ae))
155
155
 
        then ah
156
156
 
        else aa(ah, ad[ai])
157
157
 
158
158
 
    func aj (ah,ai) =     if ((ai >= ae))
159
159
 
        then ah
160
160
 
        else throw("List size exceeds 10")
161
161
 
162
162
 
    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
163
163
 
    }
164
164
 
165
165
 
166
166
 
func am (W,X,K) = if ((W != X))
167
167
 
    then throw(K)
168
168
 
    else true
169
169
 
170
170
 
171
171
 
func an (Q,K) = if (if ((4 > size(Q)))
172
172
 
    then true
173
173
 
    else (size(Q) > 16))
174
174
 
    then throw(K)
175
175
 
    else true
176
176
 
177
177
 
178
178
 
func ao (Q,K) = if ((size(Q) > 1000))
179
179
 
    then throw(K)
180
180
 
    else true
181
181
 
182
182
 
183
183
 
func ap (Q,K) = if (if ((0 > Q))
184
184
 
    then true
185
185
 
    else (Q > 8))
186
186
 
    then throw(K)
187
187
 
    else true
188
188
 
189
189
 
190
190
 
func aq (ar,O,as,K) = {
191
191
 
    let L = ar.assetId
192
192
 
    if ($isInstanceOf(L, "ByteVector"))
193
193
 
        then {
194
194
 
            let M = L
195
195
 
            if ((O != toBase58String(M)))
196
196
 
                then throw((K + ": asset"))
197
197
 
                else if ((as > ar.amount))
198
198
 
                    then throw((K + ": amount"))
199
199
 
                    else true
200
200
 
            }
201
201
 
        else throw((K + ": asset"))
202
202
 
    }
203
203
 
204
204
 
205
205
 
func at (au,Q,K) = if (!(containsElement(au, Q)))
206
206
 
    then throw(K)
207
207
 
    else true
208
208
 
209
209
 
210
210
 
func av (aw) = {
211
211
 
    let L = aw
212
212
 
    if ($isInstanceOf(L, "ByteVector"))
213
213
 
        then {
214
214
 
            let M = L
215
215
 
            toBase58String(M)
216
216
 
            }
217
217
 
        else b
218
218
 
    }
219
219
 
220
220
 
221
221
 
func ax (aw) = if (if ((aw == b))
222
222
 
    then true
223
223
 
    else (aw == ""))
224
224
 
    then unit
225
225
 
    else fromBase58String(aw)
226
226
 
227
227
 
228
228
 
func ay () = {
229
229
 
    let L = getBoolean(u)
230
230
 
    if ($isInstanceOf(L, "Boolean"))
231
231
 
        then {
232
232
 
            let M = L
233
233
 
            M
234
234
 
            }
235
235
 
        else false
236
236
 
    }
237
237
 
238
238
 
239
239
 
func az (aA) = [BooleanEntry(u, aA)]
240
240
 
241
241
 
242
242
 
func aB () = {
243
243
 
    let L = getString(v)
244
244
 
    if ($isInstanceOf(L, "String"))
245
245
 
        then {
246
246
 
            let M = L
247
247
 
            addressFromStringValue(M)
248
248
 
            }
249
249
 
        else Address(base58'')
250
250
 
    }
251
251
 
252
252
 
253
253
 
func aC (aD) = [StringEntry(v, toString(aD))]
254
254
 
255
255
 
256
256
 
func aE () = {
257
257
 
    let L = getString(s)
258
258
 
    if ($isInstanceOf(L, "String"))
259
259
 
        then {
260
260
 
            let M = L
261
261
 
            addressFromStringValue(M)
262
262
 
            }
263
263
 
        else Address(base58'')
264
264
 
    }
265
265
 
266
266
 
267
267
 
func aF (aG) = [StringEntry(s, toString(aG))]
268
268
 
269
269
 
270
270
 
func aH () = {
271
271
 
    let L = getString(w)
272
272
 
    if ($isInstanceOf(L, "String"))
273
273
 
        then {
274
274
 
            let M = L
275
275
 
            let aI = split(M, a)
276
276
 
            $Tuple10(fromBase58String(aI[0]), (aI[1] == "1"), parseIntValue(aI[2]), parseIntValue(aI[3]), parseIntValue(aI[4]), parseIntValue(aI[5]), parseIntValue(aI[6]), parseIntValue(aI[7]), parseIntValue(aI[8]), addressFromStringValue(aI[9]))
277
277
 
            }
278
278
 
        else $Tuple10(base58'', false, 0, 0, 0, 0, 0, 0, 0, Address(base58''))
279
279
 
    }
280
280
 
281
281
 
282
282
 
func aJ (aK) = [StringEntry(w, makeString([toBase58String(aK._1), if (aK._2)
283
283
 
    then "1"
284
284
 
    else "0", toString(aK._3), toString(aK._4), toString(aK._5), toString(aK._6), toString(aK._7), toString(aK._8), toString(aK._9), toString(aK._10)], a))]
285
285
 
286
286
 
287
287
 
func aL () = {
288
288
 
    let L = getString(x)
289
289
 
    if ($isInstanceOf(L, "String"))
290
290
 
        then {
291
291
 
            let M = L
292
292
 
            if ((size(M) > 0))
293
293
 
                then split_51C(M, a)
294
294
 
                else nil
295
295
 
            }
296
296
 
        else nil
297
297
 
    }
298
298
 
299
299
 
300
300
 
func aM (al) = [StringEntry(x, makeString_11C(al, a))]
301
301
 
302
302
 
303
303
 
func aN () = {
304
304
 
    func aa (ab,ac) =     {
305
305
 
        let aO = parseIntValue(ac)
306
306
 
        $Tuple2((ab._1 :+ aO), (ab._2 + aO))
307
307
 
        }
308
308
 
309
309
 
    let L = getString(y)
310
310
 
    if ($isInstanceOf(L, "String"))
311
311
 
        then {
312
312
 
            let M = L
313
313
 
            if ((size(M) > 0))
314
314
 
                then {
315
315
 
                    let ad = split_51C(M, a)
316
316
 
                    let ae = size(ad)
317
317
 
                    let af = $Tuple2(nil, 0)
318
318
 
                    func ag (ah,ai) =                     if ((ai >= ae))
319
319
 
                        then ah
320
320
 
                        else aa(ah, ad[ai])
321
321
 
322
322
 
                    func aj (ah,ai) =                     if ((ai >= ae))
323
323
 
                        then ah
324
324
 
                        else throw("List size exceeds 10")
325
325
 
326
326
 
                    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
327
327
 
                    }
328
328
 
                else $Tuple2(l, 0)
329
329
 
            }
330
330
 
        else $Tuple2(l, 0)
331
331
 
    }
332
332
 
333
333
 
334
334
 
func aP (aQ) = {
335
335
 
    func aa (ab,ac) =     (ab :+ toString(ac))
336
336
 
337
337
 
[StringEntry(y, makeString_11C({
338
338
 
        let ad = aQ
339
339
 
        let ae = size(ad)
340
340
 
        let af = nil
341
341
 
        func ag (ah,ai) =         if ((ai >= ae))
342
342
 
            then ah
343
343
 
            else aa(ah, ad[ai])
344
344
 
345
345
 
        func aj (ah,ai) =         if ((ai >= ae))
346
346
 
            then ah
347
347
 
            else throw("List size exceeds 10")
348
348
 
349
349
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
350
350
 
        }, a))]
351
351
 
    }
352
352
 
353
353
 
354
354
 
func aR () = {
355
355
 
    func aa (ab,ac) =     {
356
356
 
        let aS = parseIntValue(ac)
357
357
 
        $Tuple2((ab._1 :+ aS), (ab._2 + aS))
358
358
 
        }
359
359
 
360
360
 
    let L = getString(z)
361
361
 
    if ($isInstanceOf(L, "String"))
362
362
 
        then {
363
363
 
            let M = L
364
364
 
            if ((size(M) > 0))
365
365
 
                then {
366
366
 
                    let ad = split_51C(M, a)
367
367
 
                    let ae = size(ad)
368
368
 
                    let af = $Tuple2(nil, 0)
369
369
 
                    func ag (ah,ai) =                     if ((ai >= ae))
370
370
 
                        then ah
371
371
 
                        else aa(ah, ad[ai])
372
372
 
373
373
 
                    func aj (ah,ai) =                     if ((ai >= ae))
374
374
 
                        then ah
375
375
 
                        else throw("List size exceeds 10")
376
376
 
377
377
 
                    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
378
378
 
                    }
379
379
 
                else $Tuple2(l, 0)
380
380
 
            }
381
381
 
        else $Tuple2(l, 0)
382
382
 
    }
383
383
 
384
384
 
385
385
 
func aT (aU) = {
386
386
 
    func aa (ab,ac) =     (ab :+ toString(ac))
387
387
 
388
388
 
[StringEntry(z, makeString_11C({
389
389
 
        let ad = aU
390
390
 
        let ae = size(ad)
391
391
 
        let af = nil
392
392
 
        func ag (ah,ai) =         if ((ai >= ae))
393
393
 
            then ah
394
394
 
            else aa(ah, ad[ai])
395
395
 
396
396
 
        func aj (ah,ai) =         if ((ai >= ae))
397
397
 
            then ah
398
398
 
            else throw("List size exceeds 10")
399
399
 
400
400
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
401
401
 
        }, a))]
402
402
 
    }
403
403
 
404
404
 
405
405
 
func aV (O) = {
406
406
 
    let L = getInteger(makeString([A, O], a))
407
407
 
    if ($isInstanceOf(L, "Int"))
408
408
 
        then {
409
409
 
            let M = L
410
410
 
            M
411
411
 
            }
412
412
 
        else 0
413
413
 
    }
414
414
 
415
415
 
416
416
 
func aW (O,Q) = [IntegerEntry(makeString([A, O], a), Q)]
417
417
 
418
418
 
419
419
 
func aX (O) = {
420
420
 
    let L = getInteger(makeString([B, O], a))
421
421
 
    if ($isInstanceOf(L, "Int"))
422
422
 
        then {
423
423
 
            let M = L
424
424
 
            M
425
425
 
            }
426
426
 
        else 0
427
427
 
    }
428
428
 
429
429
 
430
430
 
func aY (O,Q) = [IntegerEntry(makeString([B, O], a), Q)]
431
431
 
432
432
 
433
433
 
func aZ () = {
434
434
 
    let L = getInteger(C)
435
435
 
    if ($isInstanceOf(L, "Int"))
436
436
 
        then {
437
437
 
            let M = L
438
438
 
            M
439
439
 
            }
440
440
 
        else 0
441
441
 
    }
442
442
 
443
443
 
444
444
 
func ba (Q) = [IntegerEntry(C, Q)]
445
445
 
446
446
 
447
447
 
func bb () = {
448
448
 
    func aa (ab,ac) =     (ab :+ parseBigIntValue(ac))
449
449
 
450
450
 
    let L = getString(D)
451
451
 
    if ($isInstanceOf(L, "String"))
452
452
 
        then {
453
453
 
            let M = L
454
454
 
            if ((size(M) > 0))
455
455
 
                then {
456
456
 
                    let ad = split_51C(M, a)
457
457
 
                    let ae = size(ad)
458
458
 
                    let af = nil
459
459
 
                    func ag (ah,ai) =                     if ((ai >= ae))
460
460
 
                        then ah
461
461
 
                        else aa(ah, ad[ai])
462
462
 
463
463
 
                    func aj (ah,ai) =                     if ((ai >= ae))
464
464
 
                        then ah
465
465
 
                        else throw("List size exceeds 11")
466
466
 
467
467
 
                    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
468
468
 
                    }
469
469
 
                else o
470
470
 
            }
471
471
 
        else o
472
472
 
    }
473
473
 
474
474
 
475
475
 
func bc (Q) = {
476
476
 
    func aa (ab,ac) =     (ab :+ toString(ac))
477
477
 
478
478
 
[StringEntry(D, makeString_11C({
479
479
 
        let ad = Q
480
480
 
        let ae = size(ad)
481
481
 
        let af = nil
482
482
 
        func ag (ah,ai) =         if ((ai >= ae))
483
483
 
            then ah
484
484
 
            else aa(ah, ad[ai])
485
485
 
486
486
 
        func aj (ah,ai) =         if ((ai >= ae))
487
487
 
            then ah
488
488
 
            else throw("List size exceeds 11")
489
489
 
490
490
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
491
491
 
        }, a))]
492
492
 
    }
493
493
 
494
494
 
495
495
 
func bd (be) = {
496
496
 
    func aa (ab,ac) =     (ab :+ parseBigIntValue(ac))
497
497
 
498
498
 
    let L = getString(makeString([E, toString(be)], a))
499
499
 
    if ($isInstanceOf(L, "String"))
500
500
 
        then {
501
501
 
            let M = L
502
502
 
            if ((size(M) > 0))
503
503
 
                then {
504
504
 
                    let ad = split_51C(M, a)
505
505
 
                    let ae = size(ad)
506
506
 
                    let af = nil
507
507
 
                    func ag (ah,ai) =                     if ((ai >= ae))
508
508
 
                        then ah
509
509
 
                        else aa(ah, ad[ai])
510
510
 
511
511
 
                    func aj (ah,ai) =                     if ((ai >= ae))
512
512
 
                        then ah
513
513
 
                        else throw("List size exceeds 11")
514
514
 
515
515
 
                    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
516
516
 
                    }
517
517
 
                else o
518
518
 
            }
519
519
 
        else o
520
520
 
    }
521
521
 
522
522
 
523
523
 
func bf (be,Q) = {
524
524
 
    func aa (ab,ac) =     (ab :+ toString(ac))
525
525
 
526
526
 
[StringEntry(makeString([E, toString(be)], a), makeString_11C({
527
527
 
        let ad = Q
528
528
 
        let ae = size(ad)
529
529
 
        let af = nil
530
530
 
        func ag (ah,ai) =         if ((ai >= ae))
531
531
 
            then ah
532
532
 
            else aa(ah, ad[ai])
533
533
 
534
534
 
        func aj (ah,ai) =         if ((ai >= ae))
535
535
 
            then ah
536
536
 
            else throw("List size exceeds 11")
537
537
 
538
538
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
539
539
 
        }, a))]
540
540
 
    }
541
541
 
542
542
 
543
543
 
func bg (J) = {
544
544
 
    let L = getInteger(makeString([F, toString(J)], a))
545
545
 
    if ($isInstanceOf(L, "Int"))
546
546
 
        then {
547
547
 
            let M = L
548
548
 
            M
549
549
 
            }
550
550
 
        else 0
551
551
 
    }
552
552
 
553
553
 
554
554
 
func bh (J,Q) = [IntegerEntry(makeString([F, toString(J)], a), Q)]
555
555
 
556
556
 
557
557
 
func bi () = {
558
558
 
    let L = getInteger(G)
559
559
 
    if ($isInstanceOf(L, "Int"))
560
560
 
        then {
561
561
 
            let M = L
562
562
 
            M
563
563
 
            }
564
564
 
        else 0
565
565
 
    }
566
566
 
567
567
 
568
568
 
func bj (Q) = [IntegerEntry(G, Q)]
569
569
 
570
570
 
571
571
 
func bk (be) = {
572
572
 
    func aa (ab,ac) =     (ab :+ parseIntValue(ac))
573
573
 
574
574
 
    let L = getString(makeString([H, toString(be)], a))
575
575
 
    if ($isInstanceOf(L, "String"))
576
576
 
        then {
577
577
 
            let M = L
578
578
 
            if ((size(M) > 0))
579
579
 
                then {
580
580
 
                    let ad = split_51C(M, a)
581
581
 
                    let ae = size(ad)
582
582
 
                    let af = nil
583
583
 
                    func ag (ah,ai) =                     if ((ai >= ae))
584
584
 
                        then ah
585
585
 
                        else aa(ah, ad[ai])
586
586
 
587
587
 
                    func aj (ah,ai) =                     if ((ai >= ae))
588
588
 
                        then ah
589
589
 
                        else throw("List size exceeds 11")
590
590
 
591
591
 
                    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
592
592
 
                    }
593
593
 
                else m
594
594
 
            }
595
595
 
        else m
596
596
 
    }
597
597
 
598
598
 
599
599
 
func bl (be,Q) = {
600
600
 
    func aa (ab,ac) =     (ab :+ toString(ac))
601
601
 
602
602
 
[StringEntry(makeString([H, toString(be)], a), makeString_11C({
603
603
 
        let ad = Q
604
604
 
        let ae = size(ad)
605
605
 
        let af = nil
606
606
 
        func ag (ah,ai) =         if ((ai >= ae))
607
607
 
            then ah
608
608
 
            else aa(ah, ad[ai])
609
609
 
610
610
 
        func aj (ah,ai) =         if ((ai >= ae))
611
611
 
            then ah
612
612
 
            else throw("List size exceeds 11")
613
613
 
614
614
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
615
615
 
        }, a))]
616
616
 
    }
617
617
 
618
618
 
619
619
 
func bm (bn) = if ((bn != this))
620
620
 
    then throw("_onlyThisContract: revert")
621
621
 
    else true
622
622
 
623
623
 
624
624
 
func bo () = if ((aE() == Address(base58'')))
625
625
 
    then throw("_whenMultisigSet: revert")
626
626
 
    else true
627
627
 
628
628
 
629
629
 
func bp () = {
630
630
 
    let bq = aH()
631
631
 
    if ((bq._1 != base58''))
632
632
 
        then throw("_whenNotInitialized: revert")
633
633
 
        else true
634
634
 
    }
635
635
 
636
636
 
637
637
 
func br () = {
638
638
 
    let bq = aH()
639
639
 
    if ((bq._1 == base58''))
640
640
 
        then throw("_whenInitialized: revert")
641
641
 
        else true
642
642
 
    }
643
643
 
644
644
 
645
645
 
func bs () = if (ay())
646
646
 
    then throw("_whenNotPaused: revert")
647
647
 
    else true
648
648
 
649
649
 
650
650
 
func bt () = if (!(ay()))
651
651
 
    then throw("_whenPaused: revert")
652
652
 
    else true
653
653
 
654
654
 
655
655
 
func bu (bn) = if ((bn != aB()))
656
656
 
    then throw("_onlyPauser: revert")
657
657
 
    else true
658
658
 
659
659
 
660
660
 
func bv (O) = {
661
661
 
    let L = assetInfo(fromBase58String(O))
662
662
 
    if ($isInstanceOf(L, "Asset"))
663
663
 
        then {
664
664
 
            let M = L
665
665
 
            M.decimals
666
666
 
            }
667
667
 
        else throw(("_getDecimals: no asset=" + O))
668
668
 
    }
669
669
 
670
670
 
671
671
 
func bw (bx,by,bz,bA) = if ((by >= bz))
672
672
 
    then fraction(bx, 1, pow(10, 0, (by - bz), 0, 0, DOWN), bA)
673
673
 
    else (bx * pow(10, 0, (bz - by), 0, 0, DOWN))
674
674
 
675
675
 
676
676
 
func bB (al) = {
677
677
 
    func aa (ab,ac) =     (ab :+ 0)
678
678
 
679
679
 
    let ad = al
680
680
 
    let ae = size(ad)
681
681
 
    let af = nil
682
682
 
    func ag (ah,ai) =     if ((ai >= ae))
683
683
 
        then ah
684
684
 
        else aa(ah, ad[ai])
685
685
 
686
686
 
    func aj (ah,ai) =     if ((ai >= ae))
687
687
 
        then ah
688
688
 
        else throw("List size exceeds 10")
689
689
 
690
690
 
    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
691
691
 
    }
692
692
 
693
693
 
694
694
 
func bC (bD) = {
695
695
 
    func aa (ab,ac) =     {
696
696
 
        let aS = parseIntValue(ac)
697
697
 
        $Tuple2((ab._1 :+ aS), (ab._2 + aS))
698
698
 
        }
699
699
 
700
700
 
    let ad = bD
701
701
 
    let ae = size(ad)
702
702
 
    let af = $Tuple2(nil, 0)
703
703
 
    func ag (ah,ai) =     if ((ai >= ae))
704
704
 
        then ah
705
705
 
        else aa(ah, ad[ai])
706
706
 
707
707
 
    func aj (ah,ai) =     if ((ai >= ae))
708
708
 
        then ah
709
709
 
        else throw("List size exceeds 10")
710
710
 
711
711
 
    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
712
712
 
    }
713
713
 
714
714
 
715
715
 
func bE (al,bF) = {
716
716
 
    func aa (ab,ac) =     {
717
717
 
        let bG = bv(ac)
718
718
 
        let aO = bw(assetBalance(this, fromBase58String(ac)), bG, bF, DOWN)
719
719
 
        $Tuple2((ab._1 :+ aO), (ab._2 + aO))
720
720
 
        }
721
721
 
722
722
 
    let ad = al
723
723
 
    let ae = size(ad)
724
724
 
    let af = $Tuple2(nil, 0)
725
725
 
    func ag (ah,ai) =     if ((ai >= ae))
726
726
 
        then ah
727
727
 
        else aa(ah, ad[ai])
728
728
 
729
729
 
    func aj (ah,ai) =     if ((ai >= ae))
730
730
 
        then ah
731
731
 
        else throw("List size exceeds 10")
732
732
 
733
733
 
    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
734
734
 
    }
735
735
 
736
736
 
737
737
 
func bH (al) = {
738
738
 
    func aa (ab,ac) =     (ab :+ toString(ac))
739
739
 
740
740
 
    makeString({
741
741
 
        let ad = al
742
742
 
        let ae = size(ad)
743
743
 
        let af = nil
744
744
 
        func ag (ah,ai) =         if ((ai >= ae))
745
745
 
            then ah
746
746
 
            else aa(ah, ad[ai])
747
747
 
748
748
 
        func aj (ah,ai) =         if ((ai >= ae))
749
749
 
            then ah
750
750
 
            else throw("List size exceeds 11")
751
751
 
752
752
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
753
753
 
        }, a)
754
754
 
    }
755
755
 
756
756
 
757
757
 
func bI (al) = {
758
758
 
    func aa (ab,ac) =     (ab :+ toString(ac))
759
759
 
760
760
 
    makeString({
761
761
 
        let ad = al
762
762
 
        let ae = size(ad)
763
763
 
        let af = nil
764
764
 
        func ag (ah,ai) =         if ((ai >= ae))
765
765
 
            then ah
766
766
 
            else aa(ah, ad[ai])
767
767
 
768
768
 
        func aj (ah,ai) =         if ((ai >= ae))
769
769
 
            then ah
770
770
 
            else throw("List size exceeds 11")
771
771
 
772
772
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
773
773
 
        }, a)
774
774
 
    }
775
775
 
776
776
 
777
777
 
func bJ (bK,aU,bL) = {
778
778
 
    func aa (ab,ac) =     (ab :+ fraction(bK, ac, bL))
779
779
 
780
780
 
    let ad = aU
781
781
 
    let ae = size(ad)
782
782
 
    let af = nil
783
783
 
    func ag (ah,ai) =     if ((ai >= ae))
784
784
 
        then ah
785
785
 
        else aa(ah, ad[ai])
786
786
 
787
787
 
    func aj (ah,ai) =     if ((ai >= ae))
788
788
 
        then ah
789
789
 
        else throw("List size exceeds 10")
790
790
 
791
791
 
    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
792
792
 
    }
793
793
 
794
794
 
795
795
 
func bM (aQ,bN) = {
796
796
 
    func aa (ab,ac) =     {
797
797
 
        let bO = ab._1
798
798
 
        let bP = bN[bO]
799
799
 
        let bQ = (ac + bP)
800
800
 
        $Tuple3((bO + 1), (ab._2 :+ bQ), (ab._3 + bQ))
801
801
 
        }
802
802
 
803
803
 
    let bR = {
804
804
 
        let ad = aQ
805
805
 
        let ae = size(ad)
806
806
 
        let af = $Tuple3(0, nil, 0)
807
807
 
        func ag (ah,ai) =         if ((ai >= ae))
808
808
 
            then ah
809
809
 
            else aa(ah, ad[ai])
810
810
 
811
811
 
        func aj (ah,ai) =         if ((ai >= ae))
812
812
 
            then ah
813
813
 
            else throw("List size exceeds 10")
814
814
 
815
815
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
816
816
 
        }
817
817
 
    $Tuple2(bR._2, bR._3)
818
818
 
    }
819
819
 
820
820
 
821
821
 
func bS (aQ,bT,al,bF,K) = {
822
822
 
    func aa (ab,ac) =     {
823
823
 
        let bO = ab._1
824
824
 
        let bU = bT[bO]
825
825
 
        let bV = av(bU.assetId)
826
826
 
        let bW = if ((bV != al[bO]))
827
827
 
            then throw(((K + ": index=") + toString(bO)))
828
828
 
            else unit
829
829
 
        if ((bW == bW))
830
830
 
            then {
831
831
 
                let bG = bv(bV)
832
832
 
                let bQ = (ac + bw(bT[bO].amount, bG, bF, DOWN))
833
833
 
                $Tuple3((bO + 1), (ab._2 :+ bQ), (ab._3 + bQ))
834
834
 
                }
835
835
 
            else throw("Strict value is not equal to itself.")
836
836
 
        }
837
837
 
838
838
 
    let bR = {
839
839
 
        let ad = aQ
840
840
 
        let ae = size(ad)
841
841
 
        let af = $Tuple3(0, nil, 0)
842
842
 
        func ag (ah,ai) =         if ((ai >= ae))
843
843
 
            then ah
844
844
 
            else aa(ah, ad[ai])
845
845
 
846
846
 
        func aj (ah,ai) =         if ((ai >= ae))
847
847
 
            then ah
848
848
 
            else throw("List size exceeds 10")
849
849
 
850
850
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
851
851
 
        }
852
852
 
    $Tuple2(bR._2, bR._3)
853
853
 
    }
854
854
 
855
855
 
856
856
 
func bX (aQ,bY,bx) = {
857
857
 
    func aa (ab,ac) =     {
858
858
 
        let bO = ab._1
859
859
 
        if ((bO == bY))
860
860
 
            then $Tuple2((bO + 1), (ab._2 :+ (ac + bx)))
861
861
 
            else $Tuple2((bO + 1), (ab._2 :+ ac))
862
862
 
        }
863
863
 
864
864
 
    let bR = {
865
865
 
        let ad = aQ
866
866
 
        let ae = size(ad)
867
867
 
        let af = $Tuple2(0, nil)
868
868
 
        func ag (ah,ai) =         if ((ai >= ae))
869
869
 
            then ah
870
870
 
            else aa(ah, ad[ai])
871
871
 
872
872
 
        func aj (ah,ai) =         if ((ai >= ae))
873
873
 
            then ah
874
874
 
            else throw("List size exceeds 10")
875
875
 
876
876
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
877
877
 
        }
878
878
 
    bR._2
879
879
 
    }
880
880
 
881
881
 
882
882
 
func bZ (aQ,bY,bx) = {
883
883
 
    func aa (ab,ac) =     {
884
884
 
        let bO = ab._1
885
885
 
        if ((bO == bY))
886
886
 
            then $Tuple2((bO + 1), (ab._2 :+ (ac - bx)))
887
887
 
            else $Tuple2((bO + 1), (ab._2 :+ ac))
888
888
 
        }
889
889
 
890
890
 
    let bR = {
891
891
 
        let ad = aQ
892
892
 
        let ae = size(ad)
893
893
 
        let af = $Tuple2(0, nil)
894
894
 
        func ag (ah,ai) =         if ((ai >= ae))
895
895
 
            then ah
896
896
 
            else aa(ah, ad[ai])
897
897
 
898
898
 
        func aj (ah,ai) =         if ((ai >= ae))
899
899
 
            then ah
900
900
 
            else throw("List size exceeds 10")
901
901
 
902
902
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
903
903
 
        }
904
904
 
    bR._2
905
905
 
    }
906
906
 
907
907
 
908
908
 
func ca (aQ,bx,cb) = {
909
909
 
    let cc = fraction((cb - bx), j, cb, CEILING)
910
910
 
    func aa (ab,ac) =     {
911
911
 
        let bQ = fraction(ac, cc, j, CEILING)
912
912
 
        let cd = (ac - bQ)
913
913
 
        $Tuple3((ab._1 :+ bQ), (ab._2 + bQ), (ab._3 :+ cd))
914
914
 
        }
915
915
 
916
916
 
    let ad = aQ
917
917
 
    let ae = size(ad)
918
918
 
    let af = $Tuple3(nil, 0, nil)
919
919
 
    func ag (ah,ai) =     if ((ai >= ae))
920
920
 
        then ah
921
921
 
        else aa(ah, ad[ai])
922
922
 
923
923
 
    func aj (ah,ai) =     if ((ai >= ae))
924
924
 
        then ah
925
925
 
        else throw("List size exceeds 10")
926
926
 
927
927
 
    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
928
928
 
    }
929
929
 
930
930
 
931
931
 
func ce (al,aQ,cf,by) = {
932
932
 
    func aa (ab,ac) =     {
933
933
 
        let bO = ab._1
934
934
 
        $Tuple2((bO + 1), (ab._2 :+ ScriptTransfer(cf, bw(aQ[bO], by, bv(ac), DOWN), ax(ac))))
935
935
 
        }
936
936
 
937
937
 
    let bR = {
938
938
 
        let ad = al
939
939
 
        let ae = size(ad)
940
940
 
        let af = $Tuple2(0, nil)
941
941
 
        func ag (ah,ai) =         if ((ai >= ae))
942
942
 
            then ah
943
943
 
            else aa(ah, ad[ai])
944
944
 
945
945
 
        func aj (ah,ai) =         if ((ai >= ae))
946
946
 
            then ah
947
947
 
            else throw("List size exceeds 10")
948
948
 
949
949
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
950
950
 
        }
951
951
 
    bR._2
952
952
 
    }
953
953
 
954
954
 
955
955
 
func cg (ch,ci,cj,ck,cl) = if ((ci > ch))
956
956
 
    then {
957
957
 
        let cm = fraction(ci, (f - cj), f)
958
958
 
        if ((cm > ch))
959
959
 
            then {
960
960
 
                let cn = (cm - ch)
961
961
 
                let co = fraction(fraction(cn, ck, h), i, ci)
962
962
 
                if ((co > cl))
963
963
 
                    then fraction(cn, cl, i)
964
964
 
                    else fraction(cn, co, i)
965
965
 
                }
966
966
 
            else 0
967
967
 
        }
968
968
 
    else {
969
969
 
        let cm = fraction(ci, (f + cj), f)
970
970
 
        if ((ch > cm))
971
971
 
            then {
972
972
 
                let cn = (ch - cm)
973
973
 
                let co = fraction(fraction(cn, ck, h), i, ci)
974
974
 
                if ((co > cl))
975
975
 
                    then fraction(cn, cl, i)
976
976
 
                    else fraction(cn, co, i)
977
977
 
                }
978
978
 
            else 0
979
979
 
        }
980
980
 
981
981
 
982
982
 
func cp (aQ,cq,aU,bL,cj,ck,cl) = {
983
983
 
    func aa (ab,aO) =     {
984
984
 
        let bO = ab._1
985
985
 
        let cr = fraction(cq, aU[bO], bL)
986
986
 
        $Tuple2((bO + 1), (ab._2 + cg(aO, cr, cj, ck, cl)))
987
987
 
        }
988
988
 
989
989
 
    let bR = {
990
990
 
        let ad = aQ
991
991
 
        let ae = size(ad)
992
992
 
        let af = $Tuple2(0, 0)
993
993
 
        func ag (ah,ai) =         if ((ai >= ae))
994
994
 
            then ah
995
995
 
            else aa(ah, ad[ai])
996
996
 
997
997
 
        func aj (ah,ai) =         if ((ai >= ae))
998
998
 
            then ah
999
999
 
            else throw("List size exceeds 10")
1000
1000
 
1001
1001
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1002
1002
 
        }
1003
1003
 
    bR._2
1004
1004
 
    }
1005
1005
 
1006
1006
 
1007
1007
 
func cs (ct,cu,cv,cw,cx,cb,bD,bL,cj,ck,cl) = if (if ((cx == 0))
1008
1008
 
    then true
1009
1009
 
    else (cb == 0))
1010
1010
 
    then true
1011
1011
 
    else {
1012
1012
 
        let cy = fraction((cu - cp(ct, cu, bD, bL, cj, ck, cl)), j, cx)
1013
1013
 
        let cz = fraction((cw - cp(cv, cw, bD, bL, cj, ck, cl)), j, cb)
1014
1014
 
        let cA = (cz - cy)
1015
1015
 
        if (if ((0 >= cA))
1016
-
            then ((-1 * j) > cA)
1016
+
            then ((-1 * aZ()) > cA)
1017
1017
 
            else false)
1018
1018
 
            then throw(("_validateLiquidityInvariant: revert: diff=" + toString(cA)))
1019
1019
 
            else true
1020
1020
 
        }
1021
1021
 
1022
1022
 
1023
1023
 
func cB (ct,cu,cv,cw,bD,bL,cj,ck,cl) = {
1024
1024
 
    let cC = (cu - cp(ct, cu, bD, bL, cj, ck, cl))
1025
1025
 
    let cD = (cw - cp(cv, cw, bD, bL, cj, ck, cl))
1026
1026
 
    let cA = (cD - cC)
1027
1027
 
    if (if ((0 >= cA))
1028
-
        then ((-1 * j) > cA)
1028
+
        then ((-1 * aZ()) > cA)
1029
1029
 
        else false)
1030
1030
 
        then throw(("_validateSwapInvariant: revert: diff=" + toString(cA)))
1031
1031
 
        else true
1032
1032
 
    }
1033
1033
 
1034
1034
 
1035
1035
 
func cE (ch,cw,cF,cu,cG,bL,cH) = {
1036
1036
 
    let cr = fraction(cw, cG, bL)
1037
1037
 
    let cI = if ((ch > cr))
1038
1038
 
        then (e + cH)
1039
1039
 
        else (e - cH)
1040
1040
 
    let cJ = fraction(cr, cI, e)
1041
1041
 
    let cK = fraction(fraction(cu, cG, bL), cI, e)
1042
1042
 
    if ((ch > cr))
1043
1043
 
        then if ((ch > cJ))
1044
1044
 
            then if ((cK > cF))
1045
1045
 
                then throw("_validateAssetAllocation: new up")
1046
1046
 
                else if (((ch - cJ) > (cF - cK)))
1047
1047
 
                    then throw("_validateAssetAllocation: still up")
1048
1048
 
                    else true
1049
1049
 
            else true
1050
1050
 
        else if ((cJ > ch))
1051
1051
 
            then if ((cF > cK))
1052
1052
 
                then throw("_validateAssetAllocation: new down")
1053
-
                else if (((cK - cF) > (cJ - ch)))
1053
+
                else if (((cJ - ch) > (cK - cF)))
1054
1054
 
                    then throw("_validateAssetAllocation: still down")
1055
1055
 
                    else true
1056
1056
 
            else true
1057
1057
 
    }
1058
1058
 
1059
1059
 
1060
1060
 
func cL (cv,cw,ct,cu,bD,bL,cH) = {
1061
1061
 
    func aa (ab,ac) =     {
1062
1062
 
        let bO = ab._1
1063
1063
 
        $Tuple2((bO + 1), if (ab._2)
1064
1064
 
            then cE(ac, cw, ct[bO], cu, bD[bO], bL, cH)
1065
1065
 
            else false)
1066
1066
 
        }
1067
1067
 
1068
1068
 
    let bR = {
1069
1069
 
        let ad = cv
1070
1070
 
        let ae = size(ad)
1071
1071
 
        let af = $Tuple2(0, true)
1072
1072
 
        func ag (ah,ai) =         if ((ai >= ae))
1073
1073
 
            then ah
1074
1074
 
            else aa(ah, ad[ai])
1075
1075
 
1076
1076
 
        func aj (ah,ai) =         if ((ai >= ae))
1077
1077
 
            then ah
1078
1078
 
            else throw("List size exceeds 10")
1079
1079
 
1080
1080
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1081
1081
 
        }
1082
1082
 
    bR._2
1083
1083
 
    }
1084
1084
 
1085
1085
 
1086
1086
 
func cM (be) = {
1087
1087
 
    let cN = bg(be)
1088
1088
 
    let cO = bk(be)
1089
1089
 
    let cP = bb()
1090
1090
 
    let cQ = bd(be)
1091
1091
 
    func aa (ab,ac) =     {
1092
1092
 
        let bO = ab._1
1093
1093
 
        let cR = (cO[bO] + toInt(fraction(toBigInt(cN), (cP[bO] - cQ[bO]), k)))
1094
1094
 
        $Tuple2((bO + 1), (ab._2 :+ cR))
1095
1095
 
        }
1096
1096
 
1097
1097
 
    let cS = {
1098
1098
 
        let ad = m
1099
1099
 
        let ae = size(ad)
1100
1100
 
        let af = $Tuple2(0, nil)
1101
1101
 
        func ag (ah,ai) =         if ((ai >= ae))
1102
1102
 
            then ah
1103
1103
 
            else aa(ah, ad[ai])
1104
1104
 
1105
1105
 
        func aj (ah,ai) =         if ((ai >= ae))
1106
1106
 
            then ah
1107
1107
 
            else throw("List size exceeds 11")
1108
1108
 
1109
1109
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
1110
1110
 
        }
1111
1111
 
    let cT = cS._1
1112
1112
 
    let cU = cS._2
1113
1113
 
    $Tuple2((bl(be, cU) ++ bf(be, cP)), cU)
1114
1114
 
    }
1115
1115
 
1116
1116
 
1117
1117
 
func cV (cW,cX,bY,cY) = {
1118
1118
 
    func aa (ab,ac) =     {
1119
1119
 
        let bO = ab._1
1120
1120
 
        let cZ = if ((bY == bO))
1121
1121
 
            then (cW[bO] + fraction(toBigInt(cY), k, toBigInt(cX)))
1122
1122
 
            else cW[bO]
1123
1123
 
        $Tuple2((bO + 1), (ab._2 :+ cZ))
1124
1124
 
        }
1125
1125
 
1126
1126
 
    let da = {
1127
1127
 
        let ad = m
1128
1128
 
        let ae = size(ad)
1129
1129
 
        let af = $Tuple2(0, nil)
1130
1130
 
        func ag (ah,ai) =         if ((ai >= ae))
1131
1131
 
            then ah
1132
1132
 
            else aa(ah, ad[ai])
1133
1133
 
1134
1134
 
        func aj (ah,ai) =         if ((ai >= ae))
1135
1135
 
            then ah
1136
1136
 
            else throw("List size exceeds 11")
1137
1137
 
1138
1138
 
        aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
1139
1139
 
        }
1140
1140
 
    let cT = da._1
1141
1141
 
    let cZ = da._2
1142
1142
 
    cZ
1143
1143
 
    }
1144
1144
 
1145
1145
 
1146
1146
 
func db (dc,bx,dd,de) = {
1147
1147
 
    let cP = bb()
1148
1148
 
    let df = bi()
1149
1149
 
    let dg = if ((df == 0))
1150
1150
 
        then $Tuple2(0, fraction(bx, de, d))
1151
1151
 
        else $Tuple2(fraction(bx, dd, d), fraction(bx, de, d))
1152
1152
 
    let dh = dg._1
1153
1153
 
    let di = dg._2
1154
1154
 
    let cZ = if ((dh == 0))
1155
1155
 
        then cP
1156
1156
 
        else cV(cP, df, dc, dh)
1157
1157
 
    $Tuple3(dh, di, cZ)
1158
1158
 
    }
1159
1159
 
1160
1160
 
1161
1161
 
func dj (bx) = {
1162
1162
 
    let bq = aH()
1163
1163
 
    let dk = bq._3
1164
1164
 
    let dl = bq._7
1165
1165
 
    let dm = bq._8
1166
1166
 
    let dn = bq._9
1167
1167
 
    let do = aL()
1168
1168
 
    let dp = aR()
1169
1169
 
    let dq = dp._1
1170
1170
 
    let dr = dp._2
1171
1171
 
    let ds = aN()
1172
1172
 
    let dt = ds._1
1173
1173
 
    let du = ds._2
1174
1174
 
    let dv = if ((du == 0))
1175
1175
 
        then {
1176
1176
 
            func aa (ab,ac) =             {
1177
1177
 
                let bO = ab._1
1178
1178
 
                let dw = fraction(dq[bO], bx, dr)
1179
1179
 
                $Tuple2((bO + 1), (ab._2 :+ dw))
1180
1180
 
                }
1181
1181
 
1182
1182
 
            let dx = {
1183
1183
 
                let ad = do
1184
1184
 
                let ae = size(ad)
1185
1185
 
                let af = $Tuple2(0, nil)
1186
1186
 
                func ag (ah,ai) =                 if ((ai >= ae))
1187
1187
 
                    then ah
1188
1188
 
                    else aa(ah, ad[ai])
1189
1189
 
1190
1190
 
                func aj (ah,ai) =                 if ((ai >= ae))
1191
1191
 
                    then ah
1192
1192
 
                    else throw("List size exceeds 10")
1193
1193
 
1194
1194
 
                aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1195
1195
 
                }
1196
1196
 
            let cT = dx._1
1197
1197
 
            let dy = dx._2
1198
1198
 
            $Tuple2(bx, dy)
1199
1199
 
            }
1200
1200
 
        else {
1201
1201
 
            let dz = fraction(toBigInt(bx), k, toBigInt(du))
1202
1202
 
            func dA (ab,ac) =             {
1203
1203
 
                let bO = ab._1
1204
1204
 
                let dw = toInt(fraction(dz, toBigInt(dt[bO]), k))
1205
1205
 
                $Tuple2((bO + 1), (ab._2 :+ dw))
1206
1206
 
                }
1207
1207
 
1208
1208
 
            let dB = {
1209
1209
 
                let ad = do
1210
1210
 
                let ae = size(ad)
1211
1211
 
                let af = $Tuple2(0, nil)
1212
1212
 
                func ag (ah,ai) =                 if ((ai >= ae))
1213
1213
 
                    then ah
1214
1214
 
                    else dA(ah, ad[ai])
1215
1215
 
1216
1216
 
                func aj (ah,ai) =                 if ((ai >= ae))
1217
1217
 
                    then ah
1218
1218
 
                    else throw("List size exceeds 10")
1219
1219
 
1220
1220
 
                aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1221
1221
 
                }
1222
1222
 
            let cT = dB._1
1223
1223
 
            let dy = dB._2
1224
1224
 
            $Tuple2(fraction(bx, dk, du), dy)
1225
1225
 
            }
1226
1226
 
    let dC = dv._1
1227
1227
 
    let dy = dv._2
1228
1228
 
    let dD = bM(dt, dy)
1229
1229
 
    let dE = dD._1
1230
1230
 
    let dF = dD._2
1231
1231
 
    let dG = cs(dt, du, dE, dF, dk, (dk + dC), dq, dr, dl, dm, dn)
1232
1232
 
    if ((dG == dG))
1233
1233
 
        then $Tuple3(dC, dy, dE)
1234
1234
 
        else throw("Strict value is not equal to itself.")
1235
1235
 
    }
1236
1236
 
1237
1237
 
1238
1238
 
func dH (O,bx) = {
1239
1239
 
    let bq = aH()
1240
1240
 
    let dk = bq._3
1241
-
    let dI = bq._6
1241
+
    let dI = bq._4
1242
+
    let dJ = bq._5
1243
+
    let dK = bq._6
1242
1244
 
    let dl = bq._7
1243
1245
 
    let dm = bq._8
1244
1246
 
    let dn = bq._9
1245
1247
 
    let do = aL()
1246
-
    let dJ = aR()
1247
-
    let dq = dJ._1
1248
-
    let dr = dJ._2
1249
-
    let dK = aN()
1250
-
    let dt = dK._1
1251
-
    let du = dK._2
1248
+
    let dL = aR()
1249
+
    let dq = dL._1
1250
+
    let dr = dL._2
1251
+
    let dM = aN()
1252
+
    let dt = dM._1
1253
+
    let du = dM._2
1252
1254
 
    let dE = bX(dt, value(indexOf(do, O)), bx)
1253
1255
 
    let dF = (du + bx)
1254
-
    let dG = cL(dE, dF, dt, du, dq, dr, dI)
1256
+
    let dG = cL(dE, dF, dt, du, dq, dr, dK)
1255
1257
 
    if ((dG == dG))
1256
1258
 
        then {
1257
-
            let dL = cp(dt, du, dq, dr, dl, dm, dn)
1258
-
            let dM = cp(dE, dF, dq, dr, dl, dm, dn)
1259
+
            let dN = cp(dt, du, dq, dr, dl, dm, dn)
1260
+
            let dO = cp(dE, dF, dq, dr, dl, dm, dn)
1259
1261
 
            let dC = if ((dk == 0))
1260
-
                then (dF - dM)
1262
+
                then throw("_deposit: empty pool")
1261
1263
 
                else {
1262
-
                    let dN = (dF - du)
1263
-
                    let dO = (dM - dL)
1264
-
                    let dP = fraction((dN - dO), j, (du - dL))
1265
-
                    let dQ = fraction(dk, dP, j)
1266
-
                    let dR = cs(dt, du, dE, dF, dk, (dk + dQ), dq, dr, dl, dm, dn)
1267
-
                    if ((dR == dR))
1268
-
                        then dQ
1264
+
                    let dP = (dF - du)
1265
+
                    let dQ = (dO - dN)
1266
+
                    let dR = fraction((dP - dQ), j, (du - dN))
1267
+
                    let dS = fraction(dk, dR, j)
1268
+
                    let dT = cs(dt, du, dE, dF, dk, (dk + dS), dq, dr, dl, dm, dn)
1269
+
                    if ((dT == dT))
1270
+
                        then dS
1269
1271
 
                        else throw("Strict value is not equal to itself.")
1270
1272
 
                    }
1271
-
            $Tuple2(dC, dE)
1272
-
            }
1273
-
        else throw("Strict value is not equal to itself.")
1274
-
    }
1275
-
1276
-
1277
-
func dS (bx) = {
1273
+
            let dU = db(0, dC, (dI / 2), (dJ / 2))
1274
+
            let dh = dU._1
1275
+
            let di = dU._2
1276
+
            let cZ = dU._3
1277
+
            $Tuple5(dC, dE, dh, di, cZ)
1278
+
            }
1279
+
        else throw("Strict value is not equal to itself.")
1280
+
    }
1281
+
1282
+
1283
+
func dV (bx) = {
1278
1284
 
    let bq = aH()
1279
1285
 
    let dk = bq._3
1280
-
    let dT = bq._4
1281
-
    let dU = bq._5
1282
-
    let dI = bq._6
1286
+
    let dK = bq._6
1283
1287
 
    let dl = bq._7
1284
1288
 
    let dm = bq._8
1285
1289
 
    let dn = bq._9
1286
-
    let dV = aN()
1287
-
    let dt = dV._1
1288
-
    let du = dV._2
1289
-
    let dW = aR()
1290
-
    let dq = dW._1
1291
-
    let dr = dW._2
1292
-
    let dX = db(0, bx, dT, dU)
1293
-
    let dh = dX._1
1294
-
    let di = dX._2
1295
-
    let cZ = dX._3
1296
-
    let dY = ((bx - dh) - di)
1290
+
    let dW = aN()
1291
+
    let dt = dW._1
1292
+
    let du = dW._2
1293
+
    let dX = aR()
1294
+
    let dq = dX._1
1295
+
    let dr = dX._2
1296
+
    let dY = bx
1297
1297
 
    let bW = P(dY, 0, c, "_withdrawAll: lpTokensToBurn less than 0")
1298
1298
 
    if ((bW == bW))
1299
1299
 
        then {
1300
1300
 
            let dZ = ca(dt, dY, dk)
1301
1301
 
            let dE = dZ._1
1302
1302
 
            let dF = dZ._2
1303
1303
 
            let ea = dZ._3
1304
1304
 
            let dG = cs(dt, du, dE, dF, dk, (dk - dY), dq, dr, dl, dm, dn)
1305
1305
 
            if ((dG == dG))
1306
-
                then $Tuple6(dY, ea, dE, dh, di, cZ)
1306
+
                then $Tuple3(dY, ea, dE)
1307
1307
 
                else throw("Strict value is not equal to itself.")
1308
1308
 
            }
1309
1309
 
        else throw("Strict value is not equal to itself.")
1310
1310
 
    }
1311
1311
 
1312
1312
 
1313
1313
 
func eb (O,ec) = {
1314
1314
 
    let bq = aH()
1315
1315
 
    let dk = bq._3
1316
-
    let dT = bq._4
1317
-
    let dU = bq._5
1318
-
    let dI = bq._6
1316
+
    let dI = bq._4
1317
+
    let dJ = bq._5
1318
+
    let dK = bq._6
1319
1319
 
    let dl = bq._7
1320
1320
 
    let dm = bq._8
1321
1321
 
    let dn = bq._9
1322
1322
 
    let ed = aZ()
1323
1323
 
    let do = aL()
1324
1324
 
    let ee = aN()
1325
1325
 
    let dt = ee._1
1326
1326
 
    let du = ee._2
1327
1327
 
    let ef = aR()
1328
1328
 
    let dq = ef._1
1329
1329
 
    let dr = ef._2
1330
1330
 
    let eg = value(indexOf(do, O))
1331
-
    let dL = cp(dt, du, dq, dr, dl, dm, dn)
1332
-
    let eh = (du - dL)
1331
+
    let dN = cp(dt, du, dq, dr, dl, dm, dn)
1332
+
    let eh = (du - dN)
1333
1333
 
    let ei = fraction(toBigInt((dk - ec)), k, toBigInt(dk))
1334
1334
 
    let ej = toInt(fraction(toBigInt(eh), ei, k))
1335
1335
 
    func aa (ab,ac) =     if (ab._1)
1336
1336
 
        then ab
1337
1337
 
        else {
1338
1338
 
            let ek = ab._2
1339
1339
 
            let el = ab._3
1340
1340
 
            let em = ((el + ek) / 2)
1341
1341
 
            let en = bZ(dt, eg, em)
1342
1342
 
            let eo = (du - em)
1343
1343
 
            let ep = (eo - cp(en, eo, dq, dr, dl, dm, dn))
1344
-
            if (if ((ed > (ep - ej)))
1345
-
                then ((ep - ej) >= 0)
1344
+
            if (if (((ep - ej) > (-1 * ed)))
1345
+
                then (ed > (ep - ej))
1346
1346
 
                else false)
1347
1347
 
                then $Tuple4(true, ek, el, em)
1348
1348
 
                else if ((0 > (ep - ej)))
1349
-
                    then $Tuple4(false, ek, em, 0)
1350
-
                    else $Tuple4(false, em, el, 0)
1349
+
                    then $Tuple4(false, ek, em, em)
1350
+
                    else $Tuple4(false, em, el, em)
1351
1351
 
            }
1352
1352
 
1353
1353
 
    let eq = {
1354
-
        let eq = ec
1355
-
        let en = bZ(dt, eg, eq)
1356
-
        let eo = (du - eq)
1357
-
        let dM = cp(en, eo, dq, dr, dl, dm, dn)
1358
-
        let dO = (dM - dL)
1359
-
        if ((dO == 0))
1360
-
            then eq
1361
-
            else {
1362
-
                let er = {
1363
-
                    let ad = r
1364
-
                    let ae = size(ad)
1365
-
                    let af = $Tuple4(false, 0, (ec + dL), 0)
1366
-
                    func ag (ah,ai) =                     if ((ai >= ae))
1367
-
                        then ah
1368
-
                        else aa(ah, ad[ai])
1369
-
1370
-
                    func aj (ah,ai) =                     if ((ai >= ae))
1371
-
                        then ah
1372
-
                        else throw("List size exceeds 64")
1373
-
1374
-
                    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64)
1375
-
                    }
1376
-
                let es = er._1
1377
-
                let et = er._2
1378
-
                let eu = er._3
1379
-
                let ev = er._4
1380
-
                if (!(es))
1381
-
                    then throw(("_withdraw: can't calculate targetAmount=" + toString(ev)))
1382
-
                    else ev
1383
-
                }
1354
+
        let er = {
1355
+
            let ad = r
1356
+
            let ae = size(ad)
1357
+
            let af = $Tuple4(false, 0, (ec + dN), 0)
1358
+
            func ag (ah,ai) =             if ((ai >= ae))
1359
+
                then ah
1360
+
                else aa(ah, ad[ai])
1361
+
1362
+
            func aj (ah,ai) =             if ((ai >= ae))
1363
+
                then ah
1364
+
                else throw("List size exceeds 64")
1365
+
1366
+
            aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64)
1367
+
            }
1368
+
        let es = er._1
1369
+
        let et = er._2
1370
+
        let eu = er._3
1371
+
        let ev = er._4
1372
+
        if (!(es))
1373
+
            then throw(("_withdraw: can't calculate targetAmount=" + toString(ev)))
1374
+
            else ev
1384
1375
 
        }
1385
1376
 
    let ew = bZ(dt, eg, eq)
1386
1377
 
    let ex = (du - eq)
1387
-
    let ey = if (cL(ew, ex, dt, du, dq, dr, dI))
1378
+
    let ey = if (cL(ew, ex, dt, du, dq, dr, dK))
1388
1379
 
        then cs(dt, du, ew, ex, dk, (dk - ec), dq, dr, dl, dm, dn)
1389
1380
 
        else false
1390
1381
 
    if ((ey == ey))
1391
1382
 
        then {
1392
-
            let ez = db((eg + 1), eq, dT, dU)
1383
+
            let ez = db((eg + 1), eq, (dI / 2), (dJ / 2))
1393
1384
 
            let dh = ez._1
1394
1385
 
            let di = ez._2
1395
1386
 
            let cZ = ez._3
1396
1387
 
            $Tuple5(eq, ew, dh, di, cZ)
1397
1388
 
            }
1398
1389
 
        else throw("Strict value is not equal to itself.")
1399
1390
 
    }
1400
1391
 
1401
1392
 
1402
1393
 
func eA (eB,eC,eD) = {
1403
1394
 
    let bq = aH()
1404
1395
 
    let eE = bq._1
1405
1396
 
    let eF = bv(toBase58String(eE))
1406
1397
 
    let dk = bq._3
1407
-
    let dT = bq._4
1408
-
    let dU = bq._5
1409
-
    let dI = bq._6
1398
+
    let dI = bq._4
1399
+
    let dJ = bq._5
1400
+
    let dK = bq._6
1410
1401
 
    let dl = bq._7
1411
1402
 
    let dm = bq._8
1412
1403
 
    let dn = bq._9
1413
1404
 
    let ed = aZ()
1414
1405
 
    let eG = aN()
1415
1406
 
    let dt = eG._1
1416
1407
 
    let du = eG._2
1417
1408
 
    let eH = aR()
1418
1409
 
    let dq = eH._1
1419
1410
 
    let dr = eH._2
1420
1411
 
    let dE = bX(dt, eB, eD)
1421
1412
 
    let dF = (du + eD)
1422
-
    let dL = cp(dt, du, dq, dr, dl, dm, dn)
1423
-
    let eh = (du - dL)
1413
+
    let dN = cp(dt, du, dq, dr, dl, dm, dn)
1414
+
    let eh = (du - dN)
1424
1415
 
    func aa (ab,ac) =     if (ab._1)
1425
1416
 
        then ab
1426
1417
 
        else {
1427
1418
 
            let ek = ab._2
1428
1419
 
            let el = ab._3
1429
1420
 
            let em = ((el + ek) / 2)
1430
1421
 
            let en = bZ(dE, eC, em)
1431
1422
 
            let eo = (dF - em)
1432
1423
 
            let ep = (eo - cp(en, eo, dq, dr, dl, dm, dn))
1433
-
            if (if ((ed > (ep - eh)))
1434
-
                then ((ep - eh) >= 0)
1424
+
            if (if (((ep - eh) > (-1 * ed)))
1425
+
                then (ed > (ep - eh))
1435
1426
 
                else false)
1436
1427
 
                then $Tuple4(true, ek, el, em)
1437
1428
 
                else if ((0 > (ep - eh)))
1438
-
                    then $Tuple4(false, ek, em, 0)
1439
-
                    else $Tuple4(false, em, el, 0)
1429
+
                    then $Tuple4(false, ek, em, em)
1430
+
                    else $Tuple4(false, em, el, em)
1440
1431
 
            }
1441
1432
 
1442
1433
 
    let eq = {
1443
1434
 
        let eq = eD
1444
1435
 
        let en = bZ(dE, eC, eq)
1445
1436
 
        let eo = (dF - eq)
1446
-
        let dM = cp(en, eo, dq, dr, dl, dm, dn)
1447
-
        let dO = (dM - dL)
1448
-
        if ((dO == 0))
1437
+
        let dO = cp(en, eo, dq, dr, dl, dm, dn)
1438
+
        let dQ = (dO - dN)
1439
+
        if ((dQ == 0))
1449
1440
 
            then eq
1450
1441
 
            else {
1451
1442
 
                let eI = {
1452
1443
 
                    let ad = r
1453
1444
 
                    let ae = size(ad)
1454
-
                    let af = $Tuple4(false, 0, (eD + dL), 0)
1445
+
                    let af = $Tuple4(false, 0, (eD + dN), 0)
1455
1446
 
                    func ag (ah,ai) =                     if ((ai >= ae))
1456
1447
 
                        then ah
1457
1448
 
                        else aa(ah, ad[ai])
1458
1449
 
1459
1450
 
                    func aj (ah,ai) =                     if ((ai >= ae))
1460
1451
 
                        then ah
1461
1452
 
                        else throw("List size exceeds 64")
1462
1453
 
1463
1454
 
                    aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64)
1464
1455
 
                    }
1465
1456
 
                let es = eI._1
1466
1457
 
                let et = eI._2
1467
1458
 
                let eu = eI._3
1468
1459
 
                let ev = eI._4
1469
1460
 
                if (!(es))
1470
1461
 
                    then throw(("_swap: can't calculate targetAmount=" + toString(ev)))
1471
1462
 
                    else ev
1472
1463
 
                }
1473
1464
 
        }
1474
1465
 
    let ew = bZ(dE, eC, eq)
1475
1466
 
    let ex = (dF - eq)
1476
-
    let ey = if (cL(ew, ex, dt, du, dq, dr, dI))
1467
+
    let ey = if (cL(ew, ex, dt, du, dq, dr, dK))
1477
1468
 
        then cB(dt, du, ew, ex, dq, dr, dl, dm, dn)
1478
1469
 
        else false
1479
1470
 
    if ((ey == ey))
1480
1471
 
        then {
1481
-
            let eJ = db((eC + 1), eq, dT, dU)
1472
+
            let eJ = db((eC + 1), eq, dI, dJ)
1482
1473
 
            let dh = eJ._1
1483
1474
 
            let di = eJ._2
1484
1475
 
            let cZ = eJ._3
1485
1476
 
            $Tuple5(eq, ew, dh, di, cZ)
1486
1477
 
            }
1487
1478
 
        else throw("Strict value is not equal to itself.")
1488
1479
 
    }
1489
1480
 
1490
1481
 
1491
1482
 
@Callable(eK)
1492
-
func init (al,bD,dd,de,eL,eM,eN,eO,cj,ck,cl,eP,eQ) = {
1493
-
    let bW = if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (bm(eK.caller))
1483
+
func init (al,bD,dd,de,eL,eM,eN,eO,cj,ck,cl,eP,eQ,aD) = {
1484
+
    let bW = if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (bm(eK.caller))
1494
1485
 
        then bp()
1495
1486
 
        else false)
1496
1487
 
        then bo()
1497
1488
 
        else false)
1498
1489
 
        then ak(al, "init: invalid assets")
1499
1490
 
        else false)
1500
-
        then Z(bD, 0, g, "init: invalid assetWeights")
1491
+
        then Z(bD, 1, g, "init: invalid assetWeights")
1501
1492
 
        else false)
1502
1493
 
        then am(size(al), size(bD), "init: invalid assetWeights size")
1503
1494
 
        else false)
1504
1495
 
        then P(dd, 0, d, "init: invalid lp fee")
1505
1496
 
        else false)
1506
1497
 
        then P(de, 0, d, "init: invalid protocol fee")
1507
1498
 
        else false)
1508
1499
 
        then an(eL, "init: invalid name")
1509
1500
 
        else false)
1510
1501
 
        then ao(eM, "init: invalid descr")
1511
1502
 
        else false)
1512
1503
 
        then ap(eN, "init: invalid decimals")
1513
1504
 
        else false)
1514
1505
 
        then P(eO, 0, e, "init: invalid maxAllocationAmplifier")
1515
1506
 
        else false)
1516
1507
 
        then P(cj, 0, eO, "init: invalid weightAmplifier")
1517
1508
 
        else false)
1518
1509
 
        then P(ck, 0, c, "init: invalid slippageRate")
1519
1510
 
        else false)
1520
1511
 
        then P(cl, 0, c, "init: invalid feeMaxRate")
1521
1512
 
        else false)
1522
1513
 
        then I(eP, "init: invalid protocolFeeContract")
1523
1514
 
        else false)
1524
-
        then P(eQ, 0, c, "init: invalid precision")
1515
+
        then P(eQ, 1, c, "init: invalid precision")
1516
+
        else false)
1517
+
        then I(aD, "init: invalid pauser")
1525
1518
 
        else false
1526
1519
 
    if ((bW == bW))
1527
1520
 
        then {
1528
1521
 
            let eR = bC(bD)
1529
1522
 
            let dq = eR._1
1530
1523
 
            let dr = eR._2
1531
1524
 
            let dE = bB(al)
1532
1525
 
            let eS = Issue(eL, eM, 0, eN, true)
1533
1526
 
            let eE = calculateAssetId(eS)
1534
1527
 
            let eT = $Tuple10(eE, true, 0, dd, de, eO, cj, ck, cl, addressFromStringValue(eP))
1535
-
            $Tuple2((((((([eS] ++ aJ(eT)) ++ aM(al)) ++ aP(dE)) ++ aT(dq)) ++ ba(eQ)) ++ bc(bb())), unit)
1528
+
            $Tuple2(((((((([eS] ++ aJ(eT)) ++ aM(al)) ++ aP(dE)) ++ aT(dq)) ++ ba(eQ)) ++ bc(bb())) ++ aC(addressFromStringValue(aD))), unit)
1536
1529
 
            }
1537
1530
 
        else throw("Strict value is not equal to itself.")
1538
1531
 
    }
1539
1532
 
1540
1533
 
1541
1534
 
1542
1535
 
@Callable(eK)
1543
1536
 
func depositAll (bx) = {
1544
1537
 
    let bW = if (if (br())
1545
1538
 
        then bs()
1546
1539
 
        else false)
1547
1540
 
        then P(bx, 0, c, "depositAll: invalid amount")
1548
1541
 
        else false
1549
1542
 
    if ((bW == bW))
1550
1543
 
        then {
1551
1544
 
            let bq = aH()
1552
1545
 
            let eE = bq._1
1553
1546
 
            let eF = bv(toBase58String(eE))
1554
1547
 
            let do = aL()
1555
1548
 
            let eU = dj(bx)
1556
1549
 
            let dC = eU._1
1557
1550
 
            let dy = eU._2
1558
1551
 
            let dE = eU._3
1559
1552
 
            func aa (ab,ac) =             {
1560
1553
 
                let bO = ab._1
1561
1554
 
                let bV = av(eK.payments[bO].assetId)
1562
1555
 
                let eV = bv(bV)
1563
1556
 
                let dw = dy[bO]
1564
1557
 
                let eW = bw(dw, eF, eV, CEILING)
1565
1558
 
                let ey = if ((bV != ac))
1566
1559
 
                    then throw(("depositAll: invalid payment: index=" + toString(bO)))
1567
1560
 
                    else if ((0 >= eW))
1568
1561
 
                        then throw("depositAll: too little amount required")
1569
1562
 
                        else unit
1570
1563
 
                if ((ey == ey))
1571
1564
 
                    then {
1572
1565
 
                        let eX = if ((eK.payments[bO].amount > eW))
1573
1566
 
                            then [ScriptTransfer(eK.caller, (eK.payments[bO].amount - eW), eK.payments[bO].assetId)]
1574
1567
 
                            else if ((eW > eK.payments[bO].amount))
1575
1568
 
                                then throw(((("depositAll: insufficient payment, index=" + toString(bO)) + ", required=") + toString(eW)))
1576
1569
 
                                else nil
1577
1570
 
                        $Tuple2((bO + 1), (ab._2 ++ eX))
1578
1571
 
                        }
1579
1572
 
                    else throw("Strict value is not equal to itself.")
1580
1573
 
                }
1581
1574
 
1582
1575
 
            let eY = {
1583
1576
 
                let ad = do
1584
1577
 
                let ae = size(ad)
1585
1578
 
                let af = $Tuple2(0, nil)
1586
1579
 
                func ag (ah,ai) =                 if ((ai >= ae))
1587
1580
 
                    then ah
1588
1581
 
                    else aa(ah, ad[ai])
1589
1582
 
1590
1583
 
                func aj (ah,ai) =                 if ((ai >= ae))
1591
1584
 
                    then ah
1592
1585
 
                    else throw("List size exceeds 10")
1593
1586
 
1594
1587
 
                aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1595
1588
 
                }
1596
1589
 
            let cT = eY._1
1597
1590
 
            let eZ = eY._2
1598
1591
 
            let eT = $Tuple10(bq._1, bq._2, (bq._3 + dC), bq._4, bq._5, bq._6, bq._7, bq._8, bq._9, bq._10)
1599
1592
 
            $Tuple2(((([Reissue(eE, dC, true), ScriptTransfer(eK.caller, dC, eE)] ++ aJ(eT)) ++ aP(dE)) ++ eZ), unit)
1600
1593
 
            }
1601
1594
 
        else throw("Strict value is not equal to itself.")
1602
1595
 
    }
1603
1596
 
1604
1597
 
1605
1598
 
1606
1599
 
@Callable(eK)
1607
1600
 
func deposit (fa) = {
1608
1601
 
    let bW = P(fa, 0, c, "deposit: invalid min lp amount")
1609
1602
 
    if ((bW == bW))
1610
1603
 
        then {
1611
1604
 
            let bq = aH()
1612
1605
 
            let eE = bq._1
1613
-
            let eF = bv(toBase58String(eE))
1606
+
            let fb = av(eE)
1607
+
            let eF = bv(fb)
1614
1608
 
            let ey = if (if (if (if (br())
1615
1609
 
                then bs()
1616
1610
 
                else false)
1617
1611
 
                then am(size(eK.payments), 1, "deposit: invalid payments size")
1618
1612
 
                else false)
1619
1613
 
                then at(aL(), av(eK.payments[0].assetId), "deposit: invalid payment asset")
1620
1614
 
                else false)
1621
-
                then P(eK.payments[0].amount, 0, c, "deposit: invalid payment amount")
1615
+
                then P(eK.payments[0].amount, 1, c, "deposit: invalid payment amount")
1622
1616
 
                else false
1623
1617
 
            if ((ey == ey))
1624
1618
 
                then {
1625
-
                    let fb = av(eK.payments[0].assetId)
1626
-
                    let bG = bv(fb)
1627
-
                    let fc = bw(eK.payments[0].amount, bG, eF, DOWN)
1628
-
                    let fd = dH(fb, fc)
1629
-
                    let dC = fd._1
1630
-
                    let dE = fd._2
1631
-
                    let dG = P(dC, fa, c, "deposit: less than min lp")
1619
+
                    let fc = av(eK.payments[0].assetId)
1620
+
                    let bG = bv(fc)
1621
+
                    let fd = bw(eK.payments[0].amount, bG, eF, DOWN)
1622
+
                    let fe = dH(fc, fd)
1623
+
                    let dC = fe._1
1624
+
                    let dE = fe._2
1625
+
                    let dh = fe._3
1626
+
                    let di = fe._4
1627
+
                    let cZ = fe._5
1628
+
                    let ff = ((dC - dh) - di)
1629
+
                    let dG = P(ff, fa, c, "deposit: less than min")
1632
1630
 
                    if ((dG == dG))
1633
1631
 
                        then {
1634
1632
 
                            let eT = $Tuple10(bq._1, bq._2, (bq._3 + dC), bq._4, bq._5, bq._6, bq._7, bq._8, bq._9, bq._10)
1635
-
                            $Tuple2((([Reissue(eE, dC, true), ScriptTransfer(eK.caller, dC, eE)] ++ aJ(eT)) ++ aP(dE)), unit)
1633
+
                            $Tuple2(((((([Reissue(eE, dC, true), ScriptTransfer(eK.caller, ff, eE)] ++ aJ(eT)) ++ aP(dE)) ++ aW(fb, (dh + aV(fb)))) ++ aY(fb, (di + aX(fb)))) ++ bc(cZ)), unit)
1636
1634
 
                            }
1637
1635
 
                        else throw("Strict value is not equal to itself.")
1638
1636
 
                    }
1639
1637
 
                else throw("Strict value is not equal to itself.")
1640
1638
 
            }
1641
1639
 
        else throw("Strict value is not equal to itself.")
1642
1640
 
    }
1643
1641
 
1644
1642
 
1645
1643
 
1646
1644
 
@Callable(eK)
1647
1645
 
func withdrawAll () = {
1648
1646
 
    let bq = aH()
1649
1647
 
    let eE = bq._1
1650
-
    let fe = toBase58String(eE)
1651
-
    let eF = bv(fe)
1648
+
    let fb = toBase58String(eE)
1649
+
    let eF = bv(fb)
1652
1650
 
    let do = aL()
1653
1651
 
    let bW = if (if (if (if (br())
1654
1652
 
        then bs()
1655
1653
 
        else false)
1656
1654
 
        then am(size(eK.payments), 1, "withdrawAll: invalid payments size")
1657
1655
 
        else false)
1658
-
        then V(fe, av(eK.payments[0].assetId), "withdrawAll: invalid payment asset")
1659
-
        else false)
1660
-
        then P(eK.payments[0].amount, 0, c, "withdrawAll: invalid payment amount")
1656
+
        then V(fb, av(eK.payments[0].assetId), "withdrawAll: invalid payment asset")
1657
+
        else false)
1658
+
        then P(eK.payments[0].amount, 1, c, "withdrawAll: invalid payment amount")
1661
1659
 
        else false
1662
1660
 
    if ((bW == bW))
1663
1661
 
        then {
1664
-
            let ff = dS(eK.payments[0].amount)
1665
-
            let dY = ff._1
1666
-
            let ea = ff._2
1667
-
            let dE = ff._3
1668
-
            let dh = ff._4
1669
-
            let di = ff._5
1670
-
            let cZ = ff._6
1671
-
            let fg = ce(do, ea, eK.caller, eF)
1662
+
            let fg = dV(eK.payments[0].amount)
1663
+
            let dY = fg._1
1664
+
            let ea = fg._2
1665
+
            let dE = fg._3
1666
+
            let fh = ce(do, ea, eK.caller, eF)
1672
1667
 
            let eT = $Tuple10(bq._1, bq._2, (bq._3 - dY), bq._4, bq._5, bq._6, bq._7, bq._8, bq._9, bq._10)
1673
-
            $Tuple2((((((([Burn(eE, dY)] ++ fg) ++ aJ(eT)) ++ aP(dE)) ++ aW(fe, (dh + aV(fe)))) ++ aY(fe, (di + aX(fe)))) ++ bc(cZ)), unit)
1668
+
            $Tuple2(((([Burn(eE, dY)] ++ fh) ++ aJ(eT)) ++ aP(dE)), unit)
1674
1669
 
            }
1675
1670
 
        else throw("Strict value is not equal to itself.")
1676
1671
 
    }
1677
1672
 
1678
1673
 
1679
1674
 
1680
1675
 
@Callable(eK)
1681
-
func withdraw (O,fh) = {
1676
+
func withdraw (O,fi) = {
1682
1677
 
    let bq = aH()
1683
1678
 
    let eE = bq._1
1684
-
    let fe = toBase58String(eE)
1685
-
    let eF = bv(fe)
1679
+
    let fb = toBase58String(eE)
1680
+
    let eF = bv(fb)
1686
1681
 
    let do = aL()
1687
1682
 
    let bW = if (if (if (if (if (if (br())
1688
1683
 
        then bs()
1689
1684
 
        else false)
1690
1685
 
        then am(size(eK.payments), 1, "withdraw: invalid payments size")
1691
1686
 
        else false)
1692
-
        then V(fe, av(eK.payments[0].assetId), "withdraw: invalid payment asset")
1693
-
        else false)
1694
-
        then P(eK.payments[0].amount, 0, c, "withdraw: invalid payment amount")
1687
+
        then V(fb, av(eK.payments[0].assetId), "withdraw: invalid payment asset")
1688
+
        else false)
1689
+
        then P(eK.payments[0].amount, 1, c, "withdraw: invalid payment amount")
1695
1690
 
        else false)
1696
1691
 
        then at(do, O, "withdraw: invalid assetId")
1697
1692
 
        else false)
1698
-
        then P(fh, 0, c, "withdraw: invalid minAmount")
1693
+
        then P(fi, 0, c, "withdraw: invalid minAmount")
1699
1694
 
        else false
1700
1695
 
    if ((bW == bW))
1701
1696
 
        then {
1702
-
            let fi = eb(O, eK.payments[0].amount)
1703
-
            let fj = fi._1
1704
-
            let ew = fi._2
1705
-
            let dh = fi._3
1706
-
            let di = fi._4
1707
-
            let cZ = fi._5
1708
-
            let fk = ((fj - dh) - di)
1709
-
            let fl = bv(O)
1710
-
            let fm = bw(fk, eF, fl, DOWN)
1711
-
            let ey = P(fm, fh, c, "withdraw: insufficient final amount")
1697
+
            let fj = eb(O, eK.payments[0].amount)
1698
+
            let fk = fj._1
1699
+
            let ew = fj._2
1700
+
            let dh = fj._3
1701
+
            let di = fj._4
1702
+
            let cZ = fj._5
1703
+
            let fl = ((fk - dh) - di)
1704
+
            let fm = bv(O)
1705
+
            let fn = bw(fl, eF, fm, DOWN)
1706
+
            let ey = P(fn, fi, c, "withdraw: less than min")
1712
1707
 
            if ((ey == ey))
1713
1708
 
                then {
1714
1709
 
                    let eT = $Tuple10(bq._1, bq._2, (bq._3 - eK.payments[0].amount), bq._4, bq._5, bq._6, bq._7, bq._8, bq._9, bq._10)
1715
-
                    $Tuple2(((((([Burn(eE, eK.payments[0].amount), ScriptTransfer(eK.caller, fm, ax(O))] ++ aJ(eT)) ++ aP(ew)) ++ aW(O, (dh + aV(O)))) ++ aY(O, (di + aX(O)))) ++ bc(cZ)), unit)
1710
+
                    $Tuple2(((((([Burn(eE, eK.payments[0].amount), ScriptTransfer(eK.caller, fn, ax(O))] ++ aJ(eT)) ++ aP(ew)) ++ aW(O, (dh + aV(O)))) ++ aY(O, (di + aX(O)))) ++ bc(cZ)), unit)
1716
1711
 
                    }
1717
1712
 
                else throw("Strict value is not equal to itself.")
1718
1713
 
            }
1719
1714
 
        else throw("Strict value is not equal to itself.")
1720
1715
 
    }
1721
1716
 
1722
1717
 
1723
1718
 
1724
1719
 
@Callable(eK)
1725
-
func swap (fn,fh) = {
1720
+
func swap (fo,fi) = {
1726
1721
 
    let bq = aH()
1727
1722
 
    let eE = bq._1
1728
1723
 
    let eF = bv(toBase58String(eE))
1729
1724
 
    let do = aL()
1730
-
    let fo = av(eK.payments[0].assetId)
1731
-
    let fp = bw(eK.payments[0].amount, bv(fo), eF, DOWN)
1732
-
    let fq = valueOrErrorMessage(indexOf(do, fo), "swap: invalid source asset")
1733
-
    if ((fq == fq))
1734
-
        then {
1735
-
            let eg = valueOrErrorMessage(indexOf(do, fn), "swap: invalid target asset")
1725
+
    let fp = av(eK.payments[0].assetId)
1726
+
    let fq = bw(eK.payments[0].amount, bv(fp), eF, DOWN)
1727
+
    let fr = valueOrErrorMessage(indexOf(do, fp), "swap: invalid source asset")
1728
+
    if ((fr == fr))
1729
+
        then {
1730
+
            let eg = valueOrErrorMessage(indexOf(do, fo), "swap: invalid target asset")
1736
1731
 
            if ((eg == eg))
1737
1732
 
                then {
1738
1733
 
                    let bW = if (if (if (if (if (br())
1739
1734
 
                        then bs()
1740
1735
 
                        else false)
1741
-
                        then P(fh, 0, c, "swap: invalid min target amount")
1736
+
                        then P(fi, 0, c, "swap: invalid min target amount")
1742
1737
 
                        else false)
1743
-
                        then P(fp, 0, c, "swap: invalid source amount")
1738
+
                        then P(fq, 1, c, "swap: invalid source amount")
1744
1739
 
                        else false)
1745
-
                        then Y(fo, fn, "swap: same assets")
1740
+
                        then Y(fp, fo, "swap: same assets")
1746
1741
 
                        else false)
1747
1742
 
                        then am(size(eK.payments), 1, "swap: invalid payments size")
1748
1743
 
                        else false
1749
1744
 
                    if ((bW == bW))
1750
1745
 
                        then {
1751
-
                            let fr = eA(fq, eg, fp)
1752
-
                            let fj = fr._1
1753
-
                            let ew = fr._2
1754
-
                            let dh = fr._3
1755
-
                            let di = fr._4
1756
-
                            let cZ = fr._5
1757
-
                            let fk = ((fj - dh) - di)
1758
-
                            let fl = bv(fn)
1759
-
                            let fm = bw(fk, eF, fl, DOWN)
1760
-
                            let ey = P(fm, fh, c, "swap: insufficient final amount")
1746
+
                            let fs = eA(fr, eg, fq)
1747
+
                            let fk = fs._1
1748
+
                            let ew = fs._2
1749
+
                            let dh = fs._3
1750
+
                            let di = fs._4
1751
+
                            let cZ = fs._5
1752
+
                            let fl = ((fk - dh) - di)
1753
+
                            let fm = bv(fo)
1754
+
                            let fn = bw(fl, eF, fm, DOWN)
1755
+
                            let ey = P(fn, fi, c, "swap: less than min")
1761
1756
 
                            if ((ey == ey))
1762
-
                                then $Tuple2((((([ScriptTransfer(eK.caller, fm, ax(fn))] ++ aP(ew)) ++ aW(fn, (dh + aV(fn)))) ++ aY(fn, (di + aX(fn)))) ++ bc(cZ)), unit)
1757
+
                                then $Tuple2((((([ScriptTransfer(eK.caller, fn, ax(fo))] ++ aP(ew)) ++ aW(fo, (dh + aV(fo)))) ++ aY(fo, (di + aX(fo)))) ++ bc(cZ)), unit)
1763
1758
 
                                else throw("Strict value is not equal to itself.")
1764
1759
 
                            }
1765
1760
 
                        else throw("Strict value is not equal to itself.")
1766
1761
 
                    }
1767
1762
 
                else throw("Strict value is not equal to itself.")
1768
1763
 
            }
1769
1764
 
        else throw("Strict value is not equal to itself.")
1770
1765
 
    }
1771
1766
 
1772
1767
 
1773
1768
 
1774
1769
 
@Callable(eK)
1775
1770
 
func getDepositAll (ec) = {
1776
-
    let bW = P(ec, 0, c, "getDepositAll: invalid amount")
1771
+
    let bW = P(ec, 1, c, "getDepositAll: invalid amount")
1777
1772
 
    if ((bW == bW))
1778
1773
 
        then {
1779
-
            let fs = dj(ec)
1780
-
            let dC = fs._1
1781
-
            let dy = fs._2
1782
-
            let dE = fs._3
1774
+
            let ft = dj(ec)
1775
+
            let dC = ft._1
1776
+
            let dy = ft._2
1777
+
            let dE = ft._3
1783
1778
 
            $Tuple2(nil, $Tuple2(dC, dy))
1784
1779
 
            }
1785
1780
 
        else throw("Strict value is not equal to itself.")
1786
1781
 
    }
1787
1782
 
1788
1783
 
1789
1784
 
1790
1785
 
@Callable(eK)
1791
1786
 
func getDeposit (O,bx) = {
1792
1787
 
    let bW = if (at(aL(), O, "getDeposit: invalid asset"))
1793
-
        then P(bx, 0, c, "getDeposit: invalid amount")
1788
+
        then P(bx, 1, c, "getDeposit: invalid amount")
1794
1789
 
        else false
1795
1790
 
    if ((bW == bW))
1796
1791
 
        then {
1797
1792
 
            let bq = aH()
1798
1793
 
            let eE = bq._1
1799
1794
 
            let eF = bv(toBase58String(eE))
1800
1795
 
            let bG = bv(O)
1801
-
            let fc = bw(bx, bG, eF, DOWN)
1802
-
            let ft = dH(O, fc)
1803
-
            let dC = ft._1
1804
-
            let dE = ft._2
1805
-
            $Tuple2(nil, dC)
1796
+
            let fd = bw(bx, bG, eF, DOWN)
1797
+
            let fu = dH(O, fd)
1798
+
            let dC = fu._1
1799
+
            let dE = fu._2
1800
+
            let dh = fu._3
1801
+
            let di = fu._4
1802
+
            let cZ = fu._5
1803
+
            let ff = ((dC - dh) - di)
1804
+
            $Tuple2(nil, ff)
1806
1805
 
            }
1807
1806
 
        else throw("Strict value is not equal to itself.")
1808
1807
 
    }
1809
1808
 
1810
1809
 
1811
1810
 
1812
1811
 
@Callable(eK)
1813
1812
 
func getWithdrawAll (ec) = {
1814
1813
 
    let bW = P(ec, 0, c, "getWithdrawAll: invalid amount")
1815
1814
 
    if ((bW == bW))
1816
1815
 
        then {
1817
-
            let fu = dS(ec)
1818
-
            let dY = fu._1
1819
-
            let fv = fu._2
1820
-
            let dE = fu._3
1821
-
            let dh = fu._4
1822
-
            let di = fu._5
1823
-
            let cZ = fu._6
1824
-
            $Tuple2(nil, fv)
1816
+
            let fv = dV(ec)
1817
+
            let dY = fv._1
1818
+
            let fw = fv._2
1819
+
            let dE = fv._3
1820
+
            $Tuple2(nil, fw)
1825
1821
 
            }
1826
1822
 
        else throw("Strict value is not equal to itself.")
1827
1823
 
    }
1828
1824
 
1829
1825
 
1830
1826
 
1831
1827
 
@Callable(eK)
1832
1828
 
func getWithdraw (O,bx) = {
1833
1829
 
    let bW = if (at(aL(), O, "getWithdraw: invalid asset"))
1834
-
        then P(bx, 0, c, "getWithdraw: invalid amount")
1830
+
        then P(bx, 1, c, "getWithdraw: invalid amount")
1835
1831
 
        else false
1836
1832
 
    if ((bW == bW))
1837
1833
 
        then {
1838
1834
 
            let bq = aH()
1839
1835
 
            let eE = bq._1
1840
1836
 
            let eF = bv(toBase58String(eE))
1841
-
            let fw = eb(O, bx)
1842
-
            let fj = fw._1
1843
-
            let dE = fw._2
1844
-
            let dh = fw._3
1845
-
            let di = fw._4
1846
-
            let cZ = fw._5
1847
-
            let fk = ((fj - dh) - di)
1848
-
            let fl = bv(O)
1849
-
            let fm = bw(fk, eF, fl, DOWN)
1850
-
            $Tuple2(nil, fm)
1837
+
            let fx = eb(O, bx)
1838
+
            let fk = fx._1
1839
+
            let dE = fx._2
1840
+
            let dh = fx._3
1841
+
            let di = fx._4
1842
+
            let cZ = fx._5
1843
+
            let fl = ((fk - dh) - di)
1844
+
            let fm = bv(O)
1845
+
            let fn = bw(fl, eF, fm, DOWN)
1846
+
            $Tuple2(nil, fn)
1851
1847
 
            }
1852
1848
 
        else throw("Strict value is not equal to itself.")
1853
1849
 
    }
1854
1850
 
1855
1851
 
1856
1852
 
1857
1853
 
@Callable(eK)
1858
-
func getSwap (fx,fn,eD) = {
1854
+
func getSwap (fy,fo,eD) = {
1859
1855
 
    let bq = aH()
1860
1856
 
    let eE = bq._1
1861
1857
 
    let eF = bv(toBase58String(eE))
1862
1858
 
    let do = aL()
1863
-
    let fq = valueOrErrorMessage(indexOf(do, fx), "swap: invalid source asset")
1864
-
    if ((fq == fq))
1865
-
        then {
1866
-
            let eg = valueOrErrorMessage(indexOf(do, fn), "swap: invalid target asset")
1859
+
    let fr = valueOrErrorMessage(indexOf(do, fy), "swap: invalid source asset")
1860
+
    if ((fr == fr))
1861
+
        then {
1862
+
            let eg = valueOrErrorMessage(indexOf(do, fo), "swap: invalid target asset")
1867
1863
 
            if ((eg == eg))
1868
1864
 
                then {
1869
-
                    let fp = bw(eD, bv(fx), eF, DOWN)
1870
-
                    let bW = if (P(fp, 0, c, "swap: invalid source amount"))
1871
-
                        then Y(fx, fn, "swap: same assets")
1865
+
                    let fq = bw(eD, bv(fy), eF, DOWN)
1866
+
                    let bW = if (P(fq, 1, c, "swap: invalid source amount"))
1867
+
                        then Y(fy, fo, "swap: same assets")
1872
1868
 
                        else false
1873
1869
 
                    if ((bW == bW))
1874
1870
 
                        then {
1875
-
                            let fy = eA(fq, eg, fp)
1876
-
                            let fj = fy._1
1877
-
                            let ew = fy._2
1878
-
                            let dh = fy._3
1879
-
                            let di = fy._4
1880
-
                            let cZ = fy._5
1881
-
                            let fk = ((fj - dh) - di)
1882
-
                            let fl = bv(fn)
1883
-
                            let fm = bw(fk, eF, fl, DOWN)
1884
-
                            $Tuple2(nil, fm)
1871
+
                            let fz = eA(fr, eg, fq)
1872
+
                            let fk = fz._1
1873
+
                            let ew = fz._2
1874
+
                            let dh = fz._3
1875
+
                            let di = fz._4
1876
+
                            let cZ = fz._5
1877
+
                            let fl = ((fk - dh) - di)
1878
+
                            let fm = bv(fo)
1879
+
                            let fn = bw(fl, eF, fm, DOWN)
1880
+
                            $Tuple2(nil, fn)
1885
1881
 
                            }
1886
1882
 
                        else throw("Strict value is not equal to itself.")
1887
1883
 
                    }
1888
1884
 
                else throw("Strict value is not equal to itself.")
1889
1885
 
            }
1890
1886
 
        else throw("Strict value is not equal to itself.")
1891
1887
 
    }
1892
1888
 
1893
1889
 
1894
1890
 
1895
1891
 
@Callable(eK)
1896
1892
 
func getClaim (be) = {
1897
-
    let fz = if ((size(be) > 0))
1893
+
    let fA = if ((size(be) > 0))
1898
1894
 
        then valueOrErrorMessage(addressFromString(be), "getClaim: invalid user")
1899
1895
 
        else eK.caller
1900
-
    let fA = cM(fz)
1901
-
    let fB = fA._1
1902
-
    let cO = fA._2
1896
+
    let fB = cM(fA)
1897
+
    let fC = fB._1
1898
+
    let cO = fB._2
1903
1899
 
    $Tuple2(nil, cO)
1904
1900
 
    }
1905
1901
 
1906
1902
 
1907
1903
 
1908
1904
 
@Callable(eK)
1909
1905
 
func getUtilFunc () = {
1910
1906
 
    let bq = aH()
1911
1907
 
    let dk = bq._3
1912
1908
 
    let dl = bq._7
1913
1909
 
    let dm = bq._8
1914
1910
 
    let dn = bq._9
1915
-
    let fC = aN()
1916
-
    let dE = fC._1
1917
-
    let dF = fC._2
1918
-
    let fD = aR()
1919
-
    let dq = fD._1
1920
-
    let dr = fD._2
1921
-
    let dM = cp(dE, dF, dq, dr, dl, dm, dn)
1922
-
    let ep = (dF - dM)
1911
+
    let fD = aN()
1912
+
    let dE = fD._1
1913
+
    let dF = fD._2
1914
+
    let fE = aR()
1915
+
    let dq = fE._1
1916
+
    let dr = fE._2
1917
+
    let dO = cp(dE, dF, dq, dr, dl, dm, dn)
1918
+
    let ep = (dF - dO)
1923
1919
 
    $Tuple2(nil, $Tuple2(ep, dk))
1920
+
    }
1921
+
1922
+
1923
+
1924
+
@Callable(eK)
1925
+
func getFeeFunc () = {
1926
+
    let bq = aH()
1927
+
    let dl = bq._7
1928
+
    let dm = bq._8
1929
+
    let dn = bq._9
1930
+
    let fF = aN()
1931
+
    let dE = fF._1
1932
+
    let dF = fF._2
1933
+
    let fG = aR()
1934
+
    let dq = fG._1
1935
+
    let dr = fG._2
1936
+
    let dO = cp(dE, dF, dq, dr, dl, dm, dn)
1937
+
    $Tuple2(nil, dO)
1924
1938
 
    }
1925
1939
 
1926
1940
 
1927
1941
 
1928
1942
 
@Callable(eK)
1929
1943
 
func checkpoint (be) = {
1930
1944
 
    let bW = if (br())
1931
1945
 
        then bs()
1932
1946
 
        else false
1933
1947
 
    if ((bW == bW))
1934
1948
 
        then {
1935
-
            let fz = if ((size(be) > 0))
1949
+
            let fA = if ((size(be) > 0))
1936
1950
 
                then valueOrErrorMessage(addressFromString(be), "checkpoint: invalid user")
1937
1951
 
                else eK.caller
1938
-
            cM(fz)
1952
+
            cM(fA)
1939
1953
 
            }
1940
1954
 
        else throw("Strict value is not equal to itself.")
1941
1955
 
    }
1942
1956
 
1943
1957
 
1944
1958
 
1945
1959
 
@Callable(eK)
1946
1960
 
func stake () = {
1947
1961
 
    let bW = if (br())
1948
1962
 
        then bs()
1949
1963
 
        else false
1950
1964
 
    if ((bW == bW))
1951
1965
 
        then {
1952
1966
 
            let bq = aH()
1953
-
            let fe = av(bq._1)
1967
+
            let fb = av(bq._1)
1954
1968
 
            let ey = if (if (am(size(eK.payments), 1, "stake: invalid payments size"))
1955
-
                then V(fe, av(eK.payments[0].assetId), "stake: invalid payment asset")
1969
+
                then V(fb, av(eK.payments[0].assetId), "stake: invalid payment asset")
1956
1970
 
                else false)
1957
1971
 
                then P(eK.payments[0].amount, 0, c, "stake: invalid payment amount")
1958
1972
 
                else false
1959
1973
 
            if ((ey == ey))
1960
1974
 
                then {
1961
-
                    let fE = cM(eK.caller)
1962
-
                    let fB = fE._1
1963
-
                    let cO = fE._2
1964
-
                    $Tuple2(((fB ++ bh(eK.caller, (bg(eK.caller) + eK.payments[0].amount))) ++ bj((bi() + eK.payments[0].amount))), unit)
1975
+
                    let fH = cM(eK.caller)
1976
+
                    let fC = fH._1
1977
+
                    let cO = fH._2
1978
+
                    $Tuple2(((fC ++ bh(eK.caller, (bg(eK.caller) + eK.payments[0].amount))) ++ bj((bi() + eK.payments[0].amount))), unit)
1965
1979
 
                    }
1966
1980
 
                else throw("Strict value is not equal to itself.")
1967
1981
 
            }
1968
1982
 
        else throw("Strict value is not equal to itself.")
1969
1983
 
    }
1970
1984
 
1971
1985
 
1972
1986
 
1973
1987
 
@Callable(eK)
1974
1988
 
func unstake (bx) = {
1975
1989
 
    let bW = if (br())
1976
1990
 
        then bs()
1977
1991
 
        else false
1978
1992
 
    if ((bW == bW))
1979
1993
 
        then {
1980
1994
 
            let bq = aH()
1981
1995
 
            let eE = bq._1
1982
1996
 
            let cN = bg(eK.caller)
1983
1997
 
            let ey = P(bx, 0, cN, "unstake: invalid amount")
1984
1998
 
            if ((ey == ey))
1985
1999
 
                then {
1986
-
                    let fF = cM(eK.caller)
1987
-
                    let fB = fF._1
1988
-
                    let cO = fF._2
1989
-
                    $Tuple2(((([ScriptTransfer(eK.caller, bx, eE)] ++ fB) ++ bh(eK.caller, (cN - bx))) ++ bj((bi() - bx))), unit)
2000
+
                    let fI = cM(eK.caller)
2001
+
                    let fC = fI._1
2002
+
                    let cO = fI._2
2003
+
                    $Tuple2(((([ScriptTransfer(eK.caller, bx, eE)] ++ fC) ++ bh(eK.caller, (cN - bx))) ++ bj((bi() - bx))), unit)
1990
2004
 
                    }
1991
2005
 
                else throw("Strict value is not equal to itself.")
1992
2006
 
            }
1993
2007
 
        else throw("Strict value is not equal to itself.")
1994
2008
 
    }
1995
2009
 
1996
2010
 
1997
2011
 
1998
2012
 
@Callable(eK)
1999
-
func claim (be,al) = {
2000
-
    let bW = if (if (br())
2013
+
func claim (be) = {
2014
+
    let bW = if (br())
2001
2015
 
        then bs()
2002
-
        else false)
2003
-
        then P(size(al), 1, 10, "claim: invalid assets size")
2004
2016
 
        else false
2005
2017
 
    if ((bW == bW))
2006
2018
 
        then {
2007
-
            let fz = if ((size(be) > 0))
2019
+
            let fA = if ((size(be) > 0))
2008
2020
 
                then valueOrErrorMessage(addressFromString(be), "claim: invalid user")
2009
2021
 
                else eK.caller
2010
2022
 
            let bq = aH()
2011
2023
 
            let eE = bq._1
2012
-
            let fe = av(eE)
2013
-
            let do = [fe, aL()]
2014
-
            let fG = (size(do) - 1)
2015
-
            let cN = bg(fz)
2016
-
            let fH = cM(fz)
2017
-
            let fB = fH._1
2018
-
            let cO = fH._2
2019
-
            func aa (ab,fI) =             {
2024
+
            let fb = av(eE)
2025
+
            let do = [fb, aL()]
2026
+
            let fJ = (size(do) - 1)
2027
+
            let cN = bg(fA)
2028
+
            let fK = cM(fA)
2029
+
            let fC = fK._1
2030
+
            let cO = fK._2
2031
+
            func aa (ab,fL) =             {
2020
2032
 
                let bO = ab._1
2021
-
                if ((bO > fG))
2022
-
                    then $Tuple3((bO + 1), (ab._2 :+ fI), ab._3)
2023
-
                    else {
2024
-
                        let fJ = do[bO]
2025
-
                        if (containsElement(al, fJ))
2026
-
                            then $Tuple3((bO + 1), (ab._2 :+ 0), (ab._3 :+ ScriptTransfer(fz, fI, ax(fJ))))
2027
-
                            else $Tuple3((bO + 1), (ab._2 :+ fI), ab._3)
2033
+
                if (if ((fJ >= bO))
2034
+
                    then (fL > 0)
2035
+
                    else false)
2036
+
                    then {
2037
+
                        let fM = do[bO]
2038
+
                        $Tuple3((bO + 1), (ab._2 :+ 0), (ab._3 :+ ScriptTransfer(fA, fL, ax(fM))))
2028
2039
 
                        }
2040
+
                    else $Tuple3((bO + 1), (ab._2 :+ fL), ab._3)
2029
2041
 
                }
2030
2042
 
2031
-
            let fK = {
2043
+
            let fN = {
2032
2044
 
                let ad = cO
2033
2045
 
                let ae = size(ad)
2034
2046
 
                let af = $Tuple3(0, nil, nil)
2035
2047
 
                func ag (ah,ai) =                 if ((ai >= ae))
2036
2048
 
                    then ah
2037
2049
 
                    else aa(ah, ad[ai])
2038
2050
 
2039
2051
 
                func aj (ah,ai) =                 if ((ai >= ae))
2040
2052
 
                    then ah
2041
2053
 
                    else throw("List size exceeds 11")
2042
2054
 
2043
2055
 
                aj(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(ag(af, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
2044
2056
 
                }
2045
-
            let cT = fK._1
2046
-
            let fL = fK._2
2047
-
            let fM = fK._3
2048
-
            $Tuple2(((fM ++ removeByIndex(fB, 0)) ++ bl(fz, fL)), unit)
2057
+
            let cT = fN._1
2058
+
            let fO = fN._2
2059
+
            let fP = fN._3
2060
+
            $Tuple2(((fP ++ removeByIndex(fC, 0)) ++ bl(fA, fO)), unit)
2049
2061
 
            }
2050
2062
 
        else throw("Strict value is not equal to itself.")
2051
2063
 
    }
2052
2064
 
2053
2065
 
2054
2066
 
2055
2067
 
@Callable(eK)
2056
2068
 
func pause () = {
2057
2069
 
    let bW = if (if (bu(eK.caller))
2058
2070
 
        then br()
2059
2071
 
        else false)
2060
2072
 
        then bs()
2061
2073
 
        else false
2062
2074
 
    if ((bW == bW))
2063
2075
 
        then $Tuple2(az(true), unit)
2064
2076
 
        else throw("Strict value is not equal to itself.")
2065
2077
 
    }
2066
2078
 
2067
2079
 
2068
2080
 
2069
2081
 
@Callable(eK)
2070
2082
 
func unpause () = {
2071
2083
 
    let bW = if (if (bu(eK.caller))
2072
2084
 
        then br()
2073
2085
 
        else false)
2074
2086
 
        then bt()
2075
2087
 
        else false
2076
2088
 
    if ((bW == bW))
2077
2089
 
        then $Tuple2(az(false), unit)
2078
2090
 
        else throw("Strict value is not equal to itself.")
2079
2091
 
    }
2080
2092
 
2081
2093
 
2082
2094
 
2083
2095
 
@Callable(eK)
2084
2096
 
func updatePauser (aD) = {
2085
2097
 
    let bW = if (if (bm(eK.caller))
2086
2098
 
        then br()
2087
2099
 
        else false)
2088
2100
 
        then I(aD, "updatePauser: invalid pauser")
2089
2101
 
        else false
2090
2102
 
    if ((bW == bW))
2091
2103
 
        then $Tuple2(aC(addressFromStringValue(aD)), unit)
2092
2104
 
        else throw("Strict value is not equal to itself.")
2093
2105
 
    }
2094
2106
 
2095
2107
 
2096
2108
 
2097
2109
 
@Callable(eK)
2098
2110
 
func setMultisig (aG) = {
2099
2111
 
    let bW = if (bm(eK.caller))
2100
2112
 
        then I(aG, "setMultisig: invalid multisig")
2101
2113
 
        else false
2102
2114
 
    if ((bW == bW))
2103
2115
 
        then $Tuple2(aF(addressFromStringValue(aG)), unit)
2104
2116
 
        else throw("Strict value is not equal to itself.")
2105
2117
 
    }
2106
2118
 
2107
2119
 
2108
-
@Verifier(fN)
2109
-
func fO () = {
2120
+
@Verifier(fQ)
2121
+
func fR () = {
2110
2122
 
    let L = getString(s)
2111
2123
 
    if ($isInstanceOf(L, "String"))
2112
2124
 
        then {
2113
-
            let fP = L
2114
-
            valueOrElse(getBoolean(addressFromStringValue(fP), makeString([t, toString(this), toBase58String(fN.id)], a)), false)
2115
-
            }
2116
-
        else sigVerify(fN.bodyBytes, fN.proofs[0], fN.senderPublicKey)
2125
+
            let fS = L
2126
+
            valueOrElse(getBoolean(addressFromStringValue(fS), makeString([t, toString(this), toBase58String(fQ.id)], a)), false)
2127
+
            }
2128
+
        else sigVerify(fQ.bodyBytes, fQ.proofs[0], fQ.senderPublicKey)
2117
2129
 
    }
2118
2130