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 RATE_FACTOR = 1000000
23
23
 
24
-
let PERCENT_FACTOR = toBigInt(1000000000000)
24
+
let PERCENT_FACTOR = toBigInt(1000000000000000000)
25
25
 
26
26
 
let ZERO_INT_LIST_10 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
27
27
 
960
960
 
        let newAssetsRate = fraction((assetTotalSupply_ - _calculateFee(assetBalances_, assetTotalSupply_, assetWeights_, sigmaWeight_, weightAmplifier_, slippageRate_, feeMaxRate_)), RATE_FACTOR, lpTotalSupply_)
961
961
 
        let diff = (newAssetsRate - prevAssetsRate)
962
962
 
        if (if ((0 >= diff))
963
-
            then ((-1 * RATE_FACTOR) > diff)
963
+
            then ((-1 * _loadPrecision()) > diff)
964
964
 
            else false)
965
965
 
            then throw(("_validateLiquidityInvariant: revert: diff=" + toString(diff)))
966
966
 
            else true
972
972
 
    let newUtil = (assetTotalSupply_ - _calculateFee(assetBalances_, assetTotalSupply_, assetWeights_, sigmaWeight_, weightAmplifier_, slippageRate_, feeMaxRate_))
973
973
 
    let diff = (newUtil - prevUtil)
974
974
 
    if (if ((0 >= diff))
975
-
        then ((-1 * RATE_FACTOR) > diff)
975
+
        then ((-1 * _loadPrecision()) > diff)
976
976
 
        else false)
977
977
 
        then throw(("_validateSwapInvariant: revert: diff=" + toString(diff)))
978
978
 
        else true
997
997
 
        else if ((maxAllocation > balance_))
998
998
 
            then if ((prevBalance_ > prevMaxAllocation))
999
999
 
                then throw("_validateAssetAllocation: new down")
1000
-
                else if (((prevMaxAllocation - prevBalance_) > (maxAllocation - balance_)))
1000
+
                else if (((maxAllocation - balance_) > (prevMaxAllocation - prevBalance_)))
1001
1001
 
                    then throw("_validateAssetAllocation: still down")
1002
1002
 
                    else true
1003
1003
 
            else true
1041
1041
 
        $Tuple2((index + 1), (acc._2 :+ profitUpdated))
1042
1042
 
        }
1043
1043
 
1044
-
    let $t02458924662 = {
1044
+
    let $t02460524678 = {
1045
1045
 
        let $l = ZERO_INT_LIST_11
1046
1046
 
        let $s = size($l)
1047
1047
 
        let $acc0 = $Tuple2(0, nil)
1055
1055
 
1056
1056
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
1057
1057
 
        }
1058
-
    let idx = $t02458924662._1
1059
-
    let profitsUpdated = $t02458924662._2
1058
+
    let idx = $t02460524678._1
1059
+
    let profitsUpdated = $t02460524678._2
1060
1060
 
    $Tuple2((_saveUserProfits(user_, profitsUpdated) ++ _saveUserSigmaFeePerLp(user_, sigmaFeePerLp)), profitsUpdated)
1061
1061
 
    }
1062
1062
 
1070
1070
 
        $Tuple2((index + 1), (acc._2 :+ sigmaFeePerLpUpdated))
1071
1071
 
        }
1072
1072
 
1073
-
    let $t02531225391 = {
1073
+
    let $t02532825407 = {
1074
1074
 
        let $l = ZERO_INT_LIST_11
1075
1075
 
        let $s = size($l)
1076
1076
 
        let $acc0 = $Tuple2(0, nil)
1084
1084
 
1085
1085
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
1086
1086
 
        }
1087
-
    let idx = $t02531225391._1
1088
-
    let sigmaFeePerLpUpdated = $t02531225391._2
1087
+
    let idx = $t02532825407._1
1088
+
    let sigmaFeePerLpUpdated = $t02532825407._2
1089
1089
 
    sigmaFeePerLpUpdated
1090
1090
 
    }
1091
1091
 
1093
1093
 
func _calculateLpAndProtocolFees (assetIndex_,amount_,lpFeeRate_,protocolFeeRate_) = {
1094
1094
 
    let sigmaFeePerLp = _loadSigmaFeePerLp()
1095
1095
 
    let totalLp = _loadTotalLp()
1096
-
    let $t02561225887 = if ((totalLp == 0))
1096
+
    let $t02562825903 = if ((totalLp == 0))
1097
1097
 
        then $Tuple2(0, fraction(amount_, protocolFeeRate_, MAX_FEE))
1098
1098
 
        else $Tuple2(fraction(amount_, lpFeeRate_, MAX_FEE), fraction(amount_, protocolFeeRate_, MAX_FEE))
1099
-
    let lpFee = $t02561225887._1
1100
-
    let protocolFee = $t02561225887._2
1099
+
    let lpFee = $t02562825903._1
1100
+
    let protocolFee = $t02562825903._2
1101
1101
 
    let sigmaFeePerLpUpdated = if ((lpFee == 0))
1102
1102
 
        then sigmaFeePerLp
1103
1103
 
        else _updateSigmaFeePerLp(sigmaFeePerLp, totalLp, assetIndex_, lpFee)
1112
1112
 
    let slippageRate = storage._8
1113
1113
 
    let feeMaxRate = storage._9
1114
1114
 
    let assets = _loadAssets()
1115
-
    let $t02639626449 = _loadAssetWeights()
1116
-
    let assetWeights = $t02639626449._1
1117
-
    let sigmaWeight = $t02639626449._2
1118
-
    let $t02645426522 = _loadAssetBalances()
1119
-
    let prevAssetBalances = $t02645426522._1
1120
-
    let prevAssetTotalSupply = $t02645426522._2
1121
-
    let $t02652827758 = if ((prevAssetTotalSupply == 0))
1115
+
    let $t02641226465 = _loadAssetWeights()
1116
+
    let assetWeights = $t02641226465._1
1117
+
    let sigmaWeight = $t02641226465._2
1118
+
    let $t02647026538 = _loadAssetBalances()
1119
+
    let prevAssetBalances = $t02647026538._1
1120
+
    let prevAssetTotalSupply = $t02647026538._2
1121
+
    let $t02654427774 = if ((prevAssetTotalSupply == 0))
1122
1122
 
        then {
1123
1123
 
            func foldFunc (acc,elem) =             {
1124
1124
 
                let index = acc._1
1126
1126
 
                $Tuple2((index + 1), (acc._2 :+ requiredAmountNormalized))
1127
1127
 
                }
1128
1128
 
1129
-
            let $t02697027044 = {
1129
+
            let $t02698627060 = {
1130
1130
 
                let $l = assets
1131
1131
 
                let $s = size($l)
1132
1132
 
                let $acc0 = $Tuple2(0, nil)
1140
1140
 
1141
1141
 
                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1142
1142
 
                }
1143
-
            let idx = $t02697027044._1
1144
-
            let requiredAmountsNormalized = $t02697027044._2
1143
+
            let idx = $t02698627060._1
1144
+
            let requiredAmountsNormalized = $t02698627060._2
1145
1145
 
            $Tuple2(amount_, requiredAmountsNormalized)
1146
1146
 
            }
1147
1147
 
        else {
1152
1152
 
                $Tuple2((index + 1), (acc._2 :+ requiredAmountNormalized))
1153
1153
 
                }
1154
1154
 
1155
-
            let $t02758727662 = {
1155
+
            let $t02760327678 = {
1156
1156
 
                let $l = assets
1157
1157
 
                let $s = size($l)
1158
1158
 
                let $acc0 = $Tuple2(0, nil)
1166
1166
 
1167
1167
 
                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1168
1168
 
                }
1169
-
            let idx = $t02758727662._1
1170
-
            let requiredAmountsNormalized = $t02758727662._2
1169
+
            let idx = $t02760327678._1
1170
+
            let requiredAmountsNormalized = $t02760327678._2
1171
1171
 
            $Tuple2(fraction(amount_, lpTotalSupply, prevAssetTotalSupply), requiredAmountsNormalized)
1172
1172
 
            }
1173
-
    let lpTokensToMint = $t02652827758._1
1174
-
    let requiredAmountsNormalized = $t02652827758._2
1175
-
    let $t02776427877 = _incrementBalancesByAmounts(prevAssetBalances, requiredAmountsNormalized)
1176
-
    let assetBalances = $t02776427877._1
1177
-
    let assetTotalSupply = $t02776427877._2
1173
+
    let lpTokensToMint = $t02654427774._1
1174
+
    let requiredAmountsNormalized = $t02654427774._2
1175
+
    let $t02778027893 = _incrementBalancesByAmounts(prevAssetBalances, requiredAmountsNormalized)
1176
+
    let assetBalances = $t02778027893._1
1177
+
    let assetTotalSupply = $t02778027893._2
1178
1178
 
    let err2 = _validateLiquidityInvariant(prevAssetBalances, prevAssetTotalSupply, assetBalances, assetTotalSupply, lpTotalSupply, (lpTotalSupply + lpTokensToMint), assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1179
1179
 
    if ((err2 == err2))
1180
1180
 
        then $Tuple3(lpTokensToMint, requiredAmountsNormalized, assetBalances)
1185
1185
 
func _deposit (assetId_,amount_) = {
1186
1186
 
    let storage = _loadStorage()
1187
1187
 
    let lpTotalSupply = storage._3
1188
+
    let lpFeeRate = storage._4
1189
+
    let protocolFeeRate = storage._5
1188
1190
 
    let maxAllocAmplifier = storage._6
1189
1191
 
    let weightAmplifier = storage._7
1190
1192
 
    let slippageRate = storage._8
1191
1193
 
    let feeMaxRate = storage._9
1192
1194
 
    let assets = _loadAssets()
1193
-
    let $t02857228625 = _loadAssetWeights()
1194
-
    let assetWeights = $t02857228625._1
1195
-
    let sigmaWeight = $t02857228625._2
1196
-
    let $t02863028744 = _loadAssetBalances()
1197
-
    let prevAssetBalances = $t02863028744._1
1198
-
    let prevAssetTotalSupply = $t02863028744._2
1195
+
    let $t02865628709 = _loadAssetWeights()
1196
+
    let assetWeights = $t02865628709._1
1197
+
    let sigmaWeight = $t02865628709._2
1198
+
    let $t02871428828 = _loadAssetBalances()
1199
+
    let prevAssetBalances = $t02871428828._1
1200
+
    let prevAssetTotalSupply = $t02871428828._2
1199
1201
 
    let assetBalances = _incrementBalanceByIndex(prevAssetBalances, value(indexOf(assets, assetId_)), amount_)
1200
1202
 
    let assetTotalSupply = (prevAssetTotalSupply + amount_)
1201
1203
 
    let err2 = _validateAllocation(assetBalances, assetTotalSupply, prevAssetBalances, prevAssetTotalSupply, assetWeights, sigmaWeight, maxAllocAmplifier)
1204
1206
 
            let prevFee = _calculateFee(prevAssetBalances, prevAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1205
1207
 
            let fee = _calculateFee(assetBalances, assetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1206
1208
 
            let lpTokensToMint = if ((lpTotalSupply == 0))
1207
-
                then (assetTotalSupply - fee)
1209
+
                then throw("_deposit: empty pool")
1208
1210
 
                else {
1209
1211
 
                    let assetDiff = (assetTotalSupply - prevAssetTotalSupply)
1210
1212
 
                    let feeDiff = (fee - prevFee)
1215
1217
 
                        then lpTokensToMintInner
1216
1218
 
                        else throw("Strict value is not equal to itself.")
1217
1219
 
                    }
1218
-
            $Tuple2(lpTokensToMint, assetBalances)
1220
+
            let $t03049030621 = _calculateLpAndProtocolFees(0, lpTokensToMint, (lpFeeRate / 2), (protocolFeeRate / 2))
1221
+
            let lpFee = $t03049030621._1
1222
+
            let protocolFee = $t03049030621._2
1223
+
            let sigmaFeePerLpUpdated = $t03049030621._3
1224
+
            $Tuple5(lpTokensToMint, assetBalances, lpFee, protocolFee, sigmaFeePerLpUpdated)
1219
1225
 
            }
1220
1226
 
        else throw("Strict value is not equal to itself.")
1221
1227
 
    }
1224
1230
 
func _withdrawAll (amount_) = {
1225
1231
 
    let storage = _loadStorage()
1226
1232
 
    let lpTotalSupply = storage._3
1227
-
    let lpFeeRate = storage._4
1228
-
    let protocolFeeRate = storage._5
1229
1233
 
    let maxAllocAmplifier = storage._6
1230
1234
 
    let weightAmplifier = storage._7
1231
1235
 
    let slippageRate = storage._8
1232
1236
 
    let feeMaxRate = storage._9
1233
-
    let $t03067130739 = _loadAssetBalances()
1234
-
    let prevAssetBalances = $t03067130739._1
1235
-
    let prevAssetTotalSupply = $t03067130739._2
1236
-
    let $t03074430797 = _loadAssetWeights()
1237
-
    let assetWeights = $t03074430797._1
1238
-
    let sigmaWeight = $t03074430797._2
1239
-
    let $t03080330919 = _calculateLpAndProtocolFees(0, amount_, lpFeeRate, protocolFeeRate)
1240
-
    let lpFee = $t03080330919._1
1241
-
    let protocolFee = $t03080330919._2
1242
-
    let sigmaFeePerLpUpdated = $t03080330919._3
1243
-
    let lpTokensToBurn = ((amount_ - lpFee) - protocolFee)
1237
+
    let $t03095531023 = _loadAssetBalances()
1238
+
    let prevAssetBalances = $t03095531023._1
1239
+
    let prevAssetTotalSupply = $t03095531023._2
1240
+
    let $t03102831081 = _loadAssetWeights()
1241
+
    let assetWeights = $t03102831081._1
1242
+
    let sigmaWeight = $t03102831081._2
1243
+
    let lpTokensToBurn = amount_
1244
1244
 
    let err = _validateInt(lpTokensToBurn, 0, MAX_INT, "_withdrawAll: lpTokensToBurn less than 0")
1245
1245
 
    if ((err == err))
1246
1246
 
        then {
1247
-
            let $t03108231215 = _decrementBalancesByLpAmount(prevAssetBalances, lpTokensToBurn, lpTotalSupply)
1248
-
            let assetBalances = $t03108231215._1
1249
-
            let assetTotalSupply = $t03108231215._2
1250
-
            let balancesToPay = $t03108231215._3
1247
+
            let $t03122331356 = _decrementBalancesByLpAmount(prevAssetBalances, lpTokensToBurn, lpTotalSupply)
1248
+
            let assetBalances = $t03122331356._1
1249
+
            let assetTotalSupply = $t03122331356._2
1250
+
            let balancesToPay = $t03122331356._3
1251
1251
 
            let err2 = _validateLiquidityInvariant(prevAssetBalances, prevAssetTotalSupply, assetBalances, assetTotalSupply, lpTotalSupply, (lpTotalSupply - lpTokensToBurn), assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1252
1252
 
            if ((err2 == err2))
1253
-
                then $Tuple6(lpTokensToBurn, balancesToPay, assetBalances, lpFee, protocolFee, sigmaFeePerLpUpdated)
1253
+
                then $Tuple3(lpTokensToBurn, balancesToPay, assetBalances)
1254
1254
 
                else throw("Strict value is not equal to itself.")
1255
1255
 
            }
1256
1256
 
        else throw("Strict value is not equal to itself.")
1268
1268
 
    let feeMaxRate = storage._9
1269
1269
 
    let precision = _loadPrecision()
1270
1270
 
    let assets = _loadAssets()
1271
-
    let $t03204932117 = _loadAssetBalances()
1272
-
    let prevAssetBalances = $t03204932117._1
1273
-
    let prevAssetTotalSupply = $t03204932117._2
1274
-
    let $t03212232175 = _loadAssetWeights()
1275
-
    let assetWeights = $t03212232175._1
1276
-
    let sigmaWeight = $t03212232175._2
1271
+
    let $t03214832216 = _loadAssetBalances()
1272
+
    let prevAssetBalances = $t03214832216._1
1273
+
    let prevAssetTotalSupply = $t03214832216._2
1274
+
    let $t03222132274 = _loadAssetWeights()
1275
+
    let assetWeights = $t03222132274._1
1276
+
    let sigmaWeight = $t03222132274._2
1277
1277
 
    let targetAssetIndex = value(indexOf(assets, assetId_))
1278
1278
 
    let prevFee = _calculateFee(prevAssetBalances, prevAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1279
1279
 
    let prevUtilValue = (prevAssetTotalSupply - prevFee)
1288
1288
 
            let tempAssetBalances = _decrementBalanceByIndex(prevAssetBalances, targetAssetIndex, currentAmount)
1289
1289
 
            let tempAssetTotalSupply = (prevAssetTotalSupply - currentAmount)
1290
1290
 
            let utilValue = (tempAssetTotalSupply - _calculateFee(tempAssetBalances, tempAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate))
1291
-
            if (if ((precision > (utilValue - prevUtilValueWithK)))
1292
-
                then ((utilValue - prevUtilValueWithK) >= 0)
1291
+
            if (if (((utilValue - prevUtilValueWithK) > (-1 * precision)))
1292
+
                then (precision > (utilValue - prevUtilValueWithK))
1293
1293
 
                else false)
1294
1294
 
                then $Tuple4(true, startInner, stopInner, currentAmount)
1295
1295
 
                else if ((0 > (utilValue - prevUtilValueWithK)))
1296
-
                    then $Tuple4(false, startInner, currentAmount, 0)
1297
-
                    else $Tuple4(false, currentAmount, stopInner, 0)
1296
+
                    then $Tuple4(false, startInner, currentAmount, currentAmount)
1297
+
                    else $Tuple4(false, currentAmount, stopInner, currentAmount)
1298
1298
 
            }
1299
1299
 
1300
1300
 
    let targetAmount = {
1301
-
        let targetAmount = lpAmount_
1302
-
        let tempAssetBalances = _decrementBalanceByIndex(prevAssetBalances, targetAssetIndex, targetAmount)
1303
-
        let tempAssetTotalSupply = (prevAssetTotalSupply - targetAmount)
1304
-
        let fee = _calculateFee(tempAssetBalances, tempAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1305
-
        let feeDiff = (fee - prevFee)
1306
-
        if ((feeDiff == 0))
1307
-
            then targetAmount
1308
-
            else {
1309
-
                let $t03414034255 = {
1310
-
                    let $l = LIST_64
1311
-
                    let $s = size($l)
1312
-
                    let $acc0 = $Tuple4(false, 0, (lpAmount_ + prevFee), 0)
1313
-
                    func $f0_1 ($a,$i) =                     if (($i >= $s))
1314
-
                        then $a
1315
-
                        else foldFunc($a, $l[$i])
1316
-
1317
-
                    func $f0_2 ($a,$i) =                     if (($i >= $s))
1318
-
                        then $a
1319
-
                        else throw("List size exceeds 64")
1320
-
1321
-
                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 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)
1322
-
                    }
1323
-
                let success = $t03414034255._1
1324
-
                let startOut = $t03414034255._2
1325
-
                let stopOut = $t03414034255._3
1326
-
                let targetAmountOut = $t03414034255._4
1327
-
                if (!(success))
1328
-
                    then throw(("_withdraw: can't calculate targetAmount=" + toString(targetAmountOut)))
1329
-
                    else targetAmountOut
1330
-
                }
1301
+
        let $t03380933924 = {
1302
+
            let $l = LIST_64
1303
+
            let $s = size($l)
1304
+
            let $acc0 = $Tuple4(false, 0, (lpAmount_ + prevFee), 0)
1305
+
            func $f0_1 ($a,$i) =             if (($i >= $s))
1306
+
                then $a
1307
+
                else foldFunc($a, $l[$i])
1308
+
1309
+
            func $f0_2 ($a,$i) =             if (($i >= $s))
1310
+
                then $a
1311
+
                else throw("List size exceeds 64")
1312
+
1313
+
            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 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)
1314
+
            }
1315
+
        let success = $t03380933924._1
1316
+
        let startOut = $t03380933924._2
1317
+
        let stopOut = $t03380933924._3
1318
+
        let targetAmountOut = $t03380933924._4
1319
+
        if (!(success))
1320
+
            then throw(("_withdraw: can't calculate targetAmount=" + toString(targetAmountOut)))
1321
+
            else targetAmountOut
1331
1322
 
        }
1332
1323
 
    let finalAssetBalances = _decrementBalanceByIndex(prevAssetBalances, targetAssetIndex, targetAmount)
1333
1324
 
    let finalAssetTotalSupply = (prevAssetTotalSupply - targetAmount)
1336
1327
 
        else false
1337
1328
 
    if ((err1 == err1))
1338
1329
 
        then {
1339
-
            let $t03514235282 = _calculateLpAndProtocolFees((targetAssetIndex + 1), targetAmount, lpFeeRate, protocolFeeRate)
1340
-
            let lpFee = $t03514235282._1
1341
-
            let protocolFee = $t03514235282._2
1342
-
            let sigmaFeePerLpUpdated = $t03514235282._3
1330
+
            let $t03488235030 = _calculateLpAndProtocolFees((targetAssetIndex + 1), targetAmount, (lpFeeRate / 2), (protocolFeeRate / 2))
1331
+
            let lpFee = $t03488235030._1
1332
+
            let protocolFee = $t03488235030._2
1333
+
            let sigmaFeePerLpUpdated = $t03488235030._3
1343
1334
 
            $Tuple5(targetAmount, finalAssetBalances, lpFee, protocolFee, sigmaFeePerLpUpdated)
1344
1335
 
            }
1345
1336
 
        else throw("Strict value is not equal to itself.")
1358
1349
 
    let slippageRate = storage._8
1359
1350
 
    let feeMaxRate = storage._9
1360
1351
 
    let precision = _loadPrecision()
1361
-
    let $t03586435932 = _loadAssetBalances()
1362
-
    let prevAssetBalances = $t03586435932._1
1363
-
    let prevAssetTotalSupply = $t03586435932._2
1364
-
    let $t03593735990 = _loadAssetWeights()
1365
-
    let assetWeights = $t03593735990._1
1366
-
    let sigmaWeight = $t03593735990._2
1352
+
    let $t03561235680 = _loadAssetBalances()
1353
+
    let prevAssetBalances = $t03561235680._1
1354
+
    let prevAssetTotalSupply = $t03561235680._2
1355
+
    let $t03568535738 = _loadAssetWeights()
1356
+
    let assetWeights = $t03568535738._1
1357
+
    let sigmaWeight = $t03568535738._2
1367
1358
 
    let assetBalances = _incrementBalanceByIndex(prevAssetBalances, sourceAssetIndex_, sourceAmount_)
1368
1359
 
    let assetTotalSupply = (prevAssetTotalSupply + sourceAmount_)
1369
1360
 
    let prevFee = _calculateFee(prevAssetBalances, prevAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1377
1368
 
            let tempAssetBalances = _decrementBalanceByIndex(assetBalances, targetAssetIndex_, currentAmount)
1378
1369
 
            let tempAssetTotalSupply = (assetTotalSupply - currentAmount)
1379
1370
 
            let utilValue = (tempAssetTotalSupply - _calculateFee(tempAssetBalances, tempAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate))
1380
-
            if (if ((precision > (utilValue - prevUtilValue)))
1381
-
                then ((utilValue - prevUtilValue) >= 0)
1371
+
            if (if (((utilValue - prevUtilValue) > (-1 * precision)))
1372
+
                then (precision > (utilValue - prevUtilValue))
1382
1373
 
                else false)
1383
1374
 
                then $Tuple4(true, startInner, stopInner, currentAmount)
1384
1375
 
                else if ((0 > (utilValue - prevUtilValue)))
1385
-
                    then $Tuple4(false, startInner, currentAmount, 0)
1386
-
                    else $Tuple4(false, currentAmount, stopInner, 0)
1376
+
                    then $Tuple4(false, startInner, currentAmount, currentAmount)
1377
+
                    else $Tuple4(false, currentAmount, stopInner, currentAmount)
1387
1378
 
            }
1388
1379
 
1389
1380
 
    let targetAmount = {
1395
1386
 
        if ((feeDiff == 0))
1396
1387
 
            then targetAmount
1397
1388
 
            else {
1398
-
                let $t03784137960 = {
1389
+
                let $t03762537744 = {
1399
1390
 
                    let $l = LIST_64
1400
1391
 
                    let $s = size($l)
1401
1392
 
                    let $acc0 = $Tuple4(false, 0, (sourceAmount_ + prevFee), 0)
1409
1400
 
1410
1401
 
                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 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)
1411
1402
 
                    }
1412
-
                let success = $t03784137960._1
1413
-
                let startOut = $t03784137960._2
1414
-
                let stopOut = $t03784137960._3
1415
-
                let targetAmountOut = $t03784137960._4
1403
+
                let success = $t03762537744._1
1404
+
                let startOut = $t03762537744._2
1405
+
                let stopOut = $t03762537744._3
1406
+
                let targetAmountOut = $t03762537744._4
1416
1407
 
                if (!(success))
1417
1408
 
                    then throw(("_swap: can't calculate targetAmount=" + toString(targetAmountOut)))
1418
1409
 
                    else targetAmountOut
1425
1416
 
        else false
1426
1417
 
    if ((err1 == err1))
1427
1418
 
        then {
1428
-
            let $t03877338914 = _calculateLpAndProtocolFees((targetAssetIndex_ + 1), targetAmount, lpFeeRate, protocolFeeRate)
1429
-
            let lpFee = $t03877338914._1
1430
-
            let protocolFee = $t03877338914._2
1431
-
            let sigmaFeePerLpUpdated = $t03877338914._3
1419
+
            let $t03855738698 = _calculateLpAndProtocolFees((targetAssetIndex_ + 1), targetAmount, lpFeeRate, protocolFeeRate)
1420
+
            let lpFee = $t03855738698._1
1421
+
            let protocolFee = $t03855738698._2
1422
+
            let sigmaFeePerLpUpdated = $t03855738698._3
1432
1423
 
            $Tuple5(targetAmount, finalAssetBalances, lpFee, protocolFee, sigmaFeePerLpUpdated)
1433
1424
 
            }
1434
1425
 
        else throw("Strict value is not equal to itself.")
1436
1427
 
1437
1428
 
1438
1429
 
@Callable(i)
1439
-
func init (assets_,assetWeights_,lpFeeRate_,protocolFeeRate_,lpTokenName_,lpTokenDescr_,lpTokenDecimals_,maxAllocationAmplifier_,weightAmplifier_,slippageRate_,feeMaxRate_,protocolFeeContract_,precision_) = {
1440
-
    let err = if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (_onlyThisContract(i.caller))
1430
+
func init (assets_,assetWeights_,lpFeeRate_,protocolFeeRate_,lpTokenName_,lpTokenDescr_,lpTokenDecimals_,maxAllocationAmplifier_,weightAmplifier_,slippageRate_,feeMaxRate_,protocolFeeContract_,precision_,pauser_) = {
1431
+
    let err = if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (_onlyThisContract(i.caller))
1441
1432
 
        then _whenNotInitialized()
1442
1433
 
        else false)
1443
1434
 
        then _whenMultisigSet()
1444
1435
 
        else false)
1445
1436
 
        then _validateAssets(assets_, "init: invalid assets")
1446
1437
 
        else false)
1447
-
        then _validateIntList(assetWeights_, 0, MAX_WEIGHT, "init: invalid assetWeights")
1438
+
        then _validateIntList(assetWeights_, 1, MAX_WEIGHT, "init: invalid assetWeights")
1448
1439
 
        else false)
1449
1440
 
        then _validateIntEquals(size(assets_), size(assetWeights_), "init: invalid assetWeights size")
1450
1441
 
        else false)
1468
1459
 
        else false)
1469
1460
 
        then _validateAddress(protocolFeeContract_, "init: invalid protocolFeeContract")
1470
1461
 
        else false)
1471
-
        then _validateInt(precision_, 0, MAX_INT, "init: invalid precision")
1462
+
        then _validateInt(precision_, 1, MAX_INT, "init: invalid precision")
1463
+
        else false)
1464
+
        then _validateAddress(pauser_, "init: invalid pauser")
1472
1465
 
        else false
1473
1466
 
    if ((err == err))
1474
1467
 
        then {
1475
-
            let $t04069540764 = _prepareAssetWeights(assetWeights_)
1476
-
            let assetWeights = $t04069540764._1
1477
-
            let sigmaWeight = $t04069540764._2
1468
+
            let $t04056140630 = _prepareAssetWeights(assetWeights_)
1469
+
            let assetWeights = $t04056140630._1
1470
+
            let sigmaWeight = $t04056140630._2
1478
1471
 
            let assetBalances = _prepareAssetBalances(assets_)
1479
1472
 
            let issue = Issue(lpTokenName_, lpTokenDescr_, 0, lpTokenDecimals_, true)
1480
1473
 
            let lpAssetId = calculateAssetId(issue)
1481
1474
 
            let storageUpdated = $Tuple10(lpAssetId, true, 0, lpFeeRate_, protocolFeeRate_, maxAllocationAmplifier_, weightAmplifier_, slippageRate_, feeMaxRate_, addressFromStringValue(protocolFeeContract_))
1482
-
            $Tuple2((((((([issue] ++ _saveStorage(storageUpdated)) ++ _saveAssets(assets_)) ++ _saveAssetBalances(assetBalances)) ++ _saveAssetWeights(assetWeights)) ++ _savePrecision(precision_)) ++ _saveSigmaFeePerLp(_loadSigmaFeePerLp())), unit)
1475
+
            $Tuple2(((((((([issue] ++ _saveStorage(storageUpdated)) ++ _saveAssets(assets_)) ++ _saveAssetBalances(assetBalances)) ++ _saveAssetWeights(assetWeights)) ++ _savePrecision(precision_)) ++ _saveSigmaFeePerLp(_loadSigmaFeePerLp())) ++ _savePauser(addressFromStringValue(pauser_))), unit)
1483
1476
 
            }
1484
1477
 
        else throw("Strict value is not equal to itself.")
1485
1478
 
    }
1499
1492
 
            let lpAssetId = storage._1
1500
1493
 
            let lpDecimals = _getDecimals(toBase58String(lpAssetId))
1501
1494
 
            let assets = _loadAssets()
1502
-
            let $t04245742542 = _depositAll(amount_)
1503
-
            let lpTokensToMint = $t04245742542._1
1504
-
            let requiredAmountsNormalized = $t04245742542._2
1505
-
            let assetBalances = $t04245742542._3
1495
+
            let $t04238042465 = _depositAll(amount_)
1496
+
            let lpTokensToMint = $t04238042465._1
1497
+
            let requiredAmountsNormalized = $t04238042465._2
1498
+
            let assetBalances = $t04238042465._3
1506
1499
 
            func foldFunc (acc,elem) =             {
1507
1500
 
                let index = acc._1
1508
1501
 
                let paymentAssetStr = _assetToStr(i.payments[index].assetId)
1526
1519
 
                    else throw("Strict value is not equal to itself.")
1527
1520
 
                }
1528
1521
 
1529
-
            let $t04368543747 = {
1522
+
            let $t04360843670 = {
1530
1523
 
                let $l = assets
1531
1524
 
                let $s = size($l)
1532
1525
 
                let $acc0 = $Tuple2(0, nil)
1540
1533
 
1541
1534
 
                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1542
1535
 
                }
1543
-
            let idx = $t04368543747._1
1544
-
            let changeActions = $t04368543747._2
1536
+
            let idx = $t04360843670._1
1537
+
            let changeActions = $t04360843670._2
1545
1538
 
            let storageUpdated = $Tuple10(storage._1, storage._2, (storage._3 + lpTokensToMint), storage._4, storage._5, storage._6, storage._7, storage._8, storage._9, storage._10)
1546
1539
 
            $Tuple2(((([Reissue(lpAssetId, lpTokensToMint, true), ScriptTransfer(i.caller, lpTokensToMint, lpAssetId)] ++ _saveStorage(storageUpdated)) ++ _saveAssetBalances(assetBalances)) ++ changeActions), unit)
1547
1540
 
            }
1557
1550
 
        then {
1558
1551
 
            let storage = _loadStorage()
1559
1552
 
            let lpAssetId = storage._1
1560
-
            let lpDecimals = _getDecimals(toBase58String(lpAssetId))
1553
+
            let lpAssetIdStr = _assetToStr(lpAssetId)
1554
+
            let lpDecimals = _getDecimals(lpAssetIdStr)
1561
1555
 
            let err1 = if (if (if (if (_whenInitialized())
1562
1556
 
                then _whenNotPaused()
1563
1557
 
                else false)
1565
1559
 
                else false)
1566
1560
 
                then _validateListContains(_loadAssets(), _assetToStr(i.payments[0].assetId), "deposit: invalid payment asset")
1567
1561
 
                else false)
1568
-
                then _validateInt(i.payments[0].amount, 0, MAX_INT, "deposit: invalid payment amount")
1562
+
                then _validateInt(i.payments[0].amount, 1, MAX_INT, "deposit: invalid payment amount")
1569
1563
 
                else false
1570
1564
 
            if ((err1 == err1))
1571
1565
 
                then {
1572
1566
 
                    let assetStr = _assetToStr(i.payments[0].assetId)
1573
1567
 
                    let assetDecimals = _getDecimals(assetStr)
1574
1568
 
                    let amountNormalized = _normalizeDecimals(i.payments[0].amount, assetDecimals, lpDecimals, DOWN)
1575
-
                    let $t04512645200 = _deposit(assetStr, amountNormalized)
1576
-
                    let lpTokensToMint = $t04512645200._1
1577
-
                    let assetBalances = $t04512645200._2
1578
-
                    let err2 = _validateInt(lpTokensToMint, minLpAmount_, MAX_INT, "deposit: less than min lp")
1569
+
                    let $t04508245198 = _deposit(assetStr, amountNormalized)
1570
+
                    let lpTokensToMint = $t04508245198._1
1571
+
                    let assetBalances = $t04508245198._2
1572
+
                    let lpFee = $t04508245198._3
1573
+
                    let protocolFee = $t04508245198._4
1574
+
                    let sigmaFeePerLpUpdated = $t04508245198._5
1575
+
                    let lpTokensToSend = ((lpTokensToMint - lpFee) - protocolFee)
1576
+
                    let err2 = _validateInt(lpTokensToSend, minLpAmount_, MAX_INT, "deposit: less than min")
1579
1577
 
                    if ((err2 == err2))
1580
1578
 
                        then {
1581
1579
 
                            let storageUpdated = $Tuple10(storage._1, storage._2, (storage._3 + lpTokensToMint), storage._4, storage._5, storage._6, storage._7, storage._8, storage._9, storage._10)
1582
-
                            $Tuple2((([Reissue(lpAssetId, lpTokensToMint, true), ScriptTransfer(i.caller, lpTokensToMint, lpAssetId)] ++ _saveStorage(storageUpdated)) ++ _saveAssetBalances(assetBalances)), unit)
1580
+
                            $Tuple2(((((([Reissue(lpAssetId, lpTokensToMint, true), ScriptTransfer(i.caller, lpTokensToSend, lpAssetId)] ++ _saveStorage(storageUpdated)) ++ _saveAssetBalances(assetBalances)) ++ _saveLpFee(lpAssetIdStr, (lpFee + _loadLpFee(lpAssetIdStr)))) ++ _saveProtocolFee(lpAssetIdStr, (protocolFee + _loadProtocolFee(lpAssetIdStr)))) ++ _saveSigmaFeePerLp(sigmaFeePerLpUpdated)), unit)
1583
1581
 
                            }
1584
1582
 
                        else throw("Strict value is not equal to itself.")
1585
1583
 
                    }
1604
1602
 
        else false)
1605
1603
 
        then _validateStringEqual(lpAssetIdStr, _assetToStr(i.payments[0].assetId), "withdrawAll: invalid payment asset")
1606
1604
 
        else false)
1607
-
        then _validateInt(i.payments[0].amount, 0, MAX_INT, "withdrawAll: invalid payment amount")
1605
+
        then _validateInt(i.payments[0].amount, 1, MAX_INT, "withdrawAll: invalid payment amount")
1608
1606
 
        else false
1609
1607
 
    if ((err == err))
1610
1608
 
        then {
1611
-
            let $t04642146550 = _withdrawAll(i.payments[0].amount)
1612
-
            let lpTokensToBurn = $t04642146550._1
1613
-
            let balancesToPay = $t04642146550._2
1614
-
            let assetBalances = $t04642146550._3
1615
-
            let lpFee = $t04642146550._4
1616
-
            let protocolFee = $t04642146550._5
1617
-
            let sigmaFeePerLpUpdated = $t04642146550._6
1609
+
            let $t04668746774 = _withdrawAll(i.payments[0].amount)
1610
+
            let lpTokensToBurn = $t04668746774._1
1611
+
            let balancesToPay = $t04668746774._2
1612
+
            let assetBalances = $t04668746774._3
1618
1613
 
            let paymentActions = _getPaymentsFromBalances(assets, balancesToPay, i.caller, lpDecimals)
1619
1614
 
            let storageUpdated = $Tuple10(storage._1, storage._2, (storage._3 - lpTokensToBurn), storage._4, storage._5, storage._6, storage._7, storage._8, storage._9, storage._10)
1620
-
            $Tuple2((((((([Burn(lpAssetId, lpTokensToBurn)] ++ paymentActions) ++ _saveStorage(storageUpdated)) ++ _saveAssetBalances(assetBalances)) ++ _saveLpFee(lpAssetIdStr, (lpFee + _loadLpFee(lpAssetIdStr)))) ++ _saveProtocolFee(lpAssetIdStr, (protocolFee + _loadProtocolFee(lpAssetIdStr)))) ++ _saveSigmaFeePerLp(sigmaFeePerLpUpdated)), unit)
1615
+
            $Tuple2(((([Burn(lpAssetId, lpTokensToBurn)] ++ paymentActions) ++ _saveStorage(storageUpdated)) ++ _saveAssetBalances(assetBalances)), unit)
1621
1616
 
            }
1622
1617
 
        else throw("Strict value is not equal to itself.")
1623
1618
 
    }
1638
1633
 
        else false)
1639
1634
 
        then _validateStringEqual(lpAssetIdStr, _assetToStr(i.payments[0].assetId), "withdraw: invalid payment asset")
1640
1635
 
        else false)
1641
-
        then _validateInt(i.payments[0].amount, 0, MAX_INT, "withdraw: invalid payment amount")
1636
+
        then _validateInt(i.payments[0].amount, 1, MAX_INT, "withdraw: invalid payment amount")
1642
1637
 
        else false)
1643
1638
 
        then _validateListContains(assets, assetId_, "withdraw: invalid assetId")
1644
1639
 
        else false)
1646
1641
 
        else false
1647
1642
 
    if ((err == err))
1648
1643
 
        then {
1649
-
            let $t04808648220 = _withdraw(assetId_, i.payments[0].amount)
1650
-
            let targetAmountNormalized = $t04808648220._1
1651
-
            let finalAssetBalances = $t04808648220._2
1652
-
            let lpFee = $t04808648220._3
1653
-
            let protocolFee = $t04808648220._4
1654
-
            let sigmaFeePerLpUpdated = $t04808648220._5
1644
+
            let $t04810048234 = _withdraw(assetId_, i.payments[0].amount)
1645
+
            let targetAmountNormalized = $t04810048234._1
1646
+
            let finalAssetBalances = $t04810048234._2
1647
+
            let lpFee = $t04810048234._3
1648
+
            let protocolFee = $t04810048234._4
1649
+
            let sigmaFeePerLpUpdated = $t04810048234._5
1655
1650
 
            let finalAmountNormalized = ((targetAmountNormalized - lpFee) - protocolFee)
1656
1651
 
            let targetDecimals = _getDecimals(assetId_)
1657
1652
 
            let finalAmount = _normalizeDecimals(finalAmountNormalized, lpDecimals, targetDecimals, DOWN)
1658
-
            let err1 = _validateInt(finalAmount, minAmount_, MAX_INT, "withdraw: insufficient final amount")
1653
+
            let err1 = _validateInt(finalAmount, minAmount_, MAX_INT, "withdraw: less than min")
1659
1654
 
            if ((err1 == err1))
1660
1655
 
                then {
1661
1656
 
                    let storageUpdated = $Tuple10(storage._1, storage._2, (storage._3 - i.payments[0].amount), storage._4, storage._5, storage._6, storage._7, storage._8, storage._9, storage._10)
1687
1682
 
                        else false)
1688
1683
 
                        then _validateInt(minAmount_, 0, MAX_INT, "swap: invalid min target amount")
1689
1684
 
                        else false)
1690
-
                        then _validateInt(sourceAmountNormalized, 0, MAX_INT, "swap: invalid source amount")
1685
+
                        then _validateInt(sourceAmountNormalized, 1, MAX_INT, "swap: invalid source amount")
1691
1686
 
                        else false)
1692
1687
 
                        then _validateStringNotEq(sourceAssetStr, targetAssetId_, "swap: same assets")
1693
1688
 
                        else false)
1695
1690
 
                        else false
1696
1691
 
                    if ((err == err))
1697
1692
 
                        then {
1698
-
                            let $t05031750475 = _swap(sourceAssetIndex, targetAssetIndex, sourceAmountNormalized)
1699
-
                            let targetAmountNormalized = $t05031750475._1
1700
-
                            let finalAssetBalances = $t05031750475._2
1701
-
                            let lpFee = $t05031750475._3
1702
-
                            let protocolFee = $t05031750475._4
1703
-
                            let sigmaFeePerLpUpdated = $t05031750475._5
1693
+
                            let $t05031950477 = _swap(sourceAssetIndex, targetAssetIndex, sourceAmountNormalized)
1694
+
                            let targetAmountNormalized = $t05031950477._1
1695
+
                            let finalAssetBalances = $t05031950477._2
1696
+
                            let lpFee = $t05031950477._3
1697
+
                            let protocolFee = $t05031950477._4
1698
+
                            let sigmaFeePerLpUpdated = $t05031950477._5
1704
1699
 
                            let finalAmountNormalized = ((targetAmountNormalized - lpFee) - protocolFee)
1705
1700
 
                            let targetDecimals = _getDecimals(targetAssetId_)
1706
1701
 
                            let finalAmount = _normalizeDecimals(finalAmountNormalized, lpDecimals, targetDecimals, DOWN)
1707
-
                            let err1 = _validateInt(finalAmount, minAmount_, MAX_INT, "swap: insufficient final amount")
1702
+
                            let err1 = _validateInt(finalAmount, minAmount_, MAX_INT, "swap: less than min")
1708
1703
 
                            if ((err1 == err1))
1709
1704
 
                                then $Tuple2((((([ScriptTransfer(i.caller, finalAmount, _strToAsset(targetAssetId_))] ++ _saveAssetBalances(finalAssetBalances)) ++ _saveLpFee(targetAssetId_, (lpFee + _loadLpFee(targetAssetId_)))) ++ _saveProtocolFee(targetAssetId_, (protocolFee + _loadProtocolFee(targetAssetId_)))) ++ _saveSigmaFeePerLp(sigmaFeePerLpUpdated)), unit)
1710
1705
 
                                else throw("Strict value is not equal to itself.")
1720
1715
 
1721
1716
 
@Callable(i)
1722
1717
 
func getDepositAll (lpAmount_) = {
1723
-
    let err = _validateInt(lpAmount_, 0, MAX_INT, "getDepositAll: invalid amount")
1718
+
    let err = _validateInt(lpAmount_, 1, MAX_INT, "getDepositAll: invalid amount")
1724
1719
 
    if ((err == err))
1725
1720
 
        then {
1726
-
            let $t05160751694 = _depositAll(lpAmount_)
1727
-
            let lpTokensToMint = $t05160751694._1
1728
-
            let requiredAmountsNormalized = $t05160751694._2
1729
-
            let assetBalances = $t05160751694._3
1721
+
            let $t05159751684 = _depositAll(lpAmount_)
1722
+
            let lpTokensToMint = $t05159751684._1
1723
+
            let requiredAmountsNormalized = $t05159751684._2
1724
+
            let assetBalances = $t05159751684._3
1730
1725
 
            $Tuple2(nil, $Tuple2(lpTokensToMint, requiredAmountsNormalized))
1731
1726
 
            }
1732
1727
 
        else throw("Strict value is not equal to itself.")
1737
1732
 
@Callable(i)
1738
1733
 
func getDeposit (assetId_,amount_) = {
1739
1734
 
    let err = if (_validateListContains(_loadAssets(), assetId_, "getDeposit: invalid asset"))
1740
-
        then _validateInt(amount_, 0, MAX_INT, "getDeposit: invalid amount")
1735
+
        then _validateInt(amount_, 1, MAX_INT, "getDeposit: invalid amount")
1741
1736
 
        else false
1742
1737
 
    if ((err == err))
1743
1738
 
        then {
1746
1741
 
            let lpDecimals = _getDecimals(toBase58String(lpAssetId))
1747
1742
 
            let assetDecimals = _getDecimals(assetId_)
1748
1743
 
            let amountNormalized = _normalizeDecimals(amount_, assetDecimals, lpDecimals, DOWN)
1749
-
            let $t05245352527 = _deposit(assetId_, amountNormalized)
1750
-
            let lpTokensToMint = $t05245352527._1
1751
-
            let assetBalances = $t05245352527._2
1752
-
            $Tuple2(nil, lpTokensToMint)
1744
+
            let $t05244352559 = _deposit(assetId_, amountNormalized)
1745
+
            let lpTokensToMint = $t05244352559._1
1746
+
            let assetBalances = $t05244352559._2
1747
+
            let lpFee = $t05244352559._3
1748
+
            let protocolFee = $t05244352559._4
1749
+
            let sigmaFeePerLpUpdated = $t05244352559._5
1750
+
            let lpTokensToSend = ((lpTokensToMint - lpFee) - protocolFee)
1751
+
            $Tuple2(nil, lpTokensToSend)
1753
1752
 
            }
1754
1753
 
        else throw("Strict value is not equal to itself.")
1755
1754
 
    }
1761
1760
 
    let err = _validateInt(lpAmount_, 0, MAX_INT, "getWithdrawAll: invalid amount")
1762
1761
 
    if ((err == err))
1763
1762
 
        then {
1764
-
            let $t05290453022 = _withdrawAll(lpAmount_)
1765
-
            let lpTokensToBurn = $t05290453022._1
1766
-
            let balancesToGet = $t05290453022._2
1767
-
            let assetBalances = $t05290453022._3
1768
-
            let lpFee = $t05290453022._4
1769
-
            let protocolFee = $t05290453022._5
1770
-
            let sigmaFeePerLpUpdated = $t05290453022._6
1763
+
            let $t05299853074 = _withdrawAll(lpAmount_)
1764
+
            let lpTokensToBurn = $t05299853074._1
1765
+
            let balancesToGet = $t05299853074._2
1766
+
            let assetBalances = $t05299853074._3
1771
1767
 
            $Tuple2(nil, balancesToGet)
1772
1768
 
            }
1773
1769
 
        else throw("Strict value is not equal to itself.")
1778
1774
 
@Callable(i)
1779
1775
 
func getWithdraw (assetId_,amount_) = {
1780
1776
 
    let err = if (_validateListContains(_loadAssets(), assetId_, "getWithdraw: invalid asset"))
1781
-
        then _validateInt(amount_, 0, MAX_INT, "getWithdraw: invalid amount")
1777
+
        then _validateInt(amount_, 1, MAX_INT, "getWithdraw: invalid amount")
1782
1778
 
        else false
1783
1779
 
    if ((err == err))
1784
1780
 
        then {
1785
1781
 
            let storage = _loadStorage()
1786
1782
 
            let lpAssetId = storage._1
1787
1783
 
            let lpDecimals = _getDecimals(toBase58String(lpAssetId))
1788
-
            let $t05367353789 = _withdraw(assetId_, amount_)
1789
-
            let targetAmountNormalized = $t05367353789._1
1790
-
            let assetBalances = $t05367353789._2
1791
-
            let lpFee = $t05367353789._3
1792
-
            let protocolFee = $t05367353789._4
1793
-
            let sigmaFeePerLpUpdated = $t05367353789._5
1784
+
            let $t05372553841 = _withdraw(assetId_, amount_)
1785
+
            let targetAmountNormalized = $t05372553841._1
1786
+
            let assetBalances = $t05372553841._2
1787
+
            let lpFee = $t05372553841._3
1788
+
            let protocolFee = $t05372553841._4
1789
+
            let sigmaFeePerLpUpdated = $t05372553841._5
1794
1790
 
            let finalAmountNormalized = ((targetAmountNormalized - lpFee) - protocolFee)
1795
1791
 
            let targetDecimals = _getDecimals(assetId_)
1796
1792
 
            let finalAmount = _normalizeDecimals(finalAmountNormalized, lpDecimals, targetDecimals, DOWN)
1814
1810
 
            if ((targetAssetIndex == targetAssetIndex))
1815
1811
 
                then {
1816
1812
 
                    let sourceAmountNormalized = _normalizeDecimals(sourceAmount_, _getDecimals(sourceAssetId_), lpDecimals, DOWN)
1817
-
                    let err = if (_validateInt(sourceAmountNormalized, 0, MAX_INT, "swap: invalid source amount"))
1813
+
                    let err = if (_validateInt(sourceAmountNormalized, 1, MAX_INT, "swap: invalid source amount"))
1818
1814
 
                        then _validateStringNotEq(sourceAssetId_, targetAssetId_, "swap: same assets")
1819
1815
 
                        else false
1820
1816
 
                    if ((err == err))
1821
1817
 
                        then {
1822
-
                            let $t05520355361 = _swap(sourceAssetIndex, targetAssetIndex, sourceAmountNormalized)
1823
-
                            let targetAmountNormalized = $t05520355361._1
1824
-
                            let finalAssetBalances = $t05520355361._2
1825
-
                            let lpFee = $t05520355361._3
1826
-
                            let protocolFee = $t05520355361._4
1827
-
                            let sigmaFeePerLpUpdated = $t05520355361._5
1818
+
                            let $t05525555413 = _swap(sourceAssetIndex, targetAssetIndex, sourceAmountNormalized)
1819
+
                            let targetAmountNormalized = $t05525555413._1
1820
+
                            let finalAssetBalances = $t05525555413._2
1821
+
                            let lpFee = $t05525555413._3
1822
+
                            let protocolFee = $t05525555413._4
1823
+
                            let sigmaFeePerLpUpdated = $t05525555413._5
1828
1824
 
                            let finalAmountNormalized = ((targetAmountNormalized - lpFee) - protocolFee)
1829
1825
 
                            let targetDecimals = _getDecimals(targetAssetId_)
1830
1826
 
                            let finalAmount = _normalizeDecimals(finalAmountNormalized, lpDecimals, targetDecimals, DOWN)
1844
1840
 
    let user = if ((size(user_) > 0))
1845
1841
 
        then valueOrErrorMessage(addressFromString(user_), "getClaim: invalid user")
1846
1842
 
        else i.caller
1847
-
    let $t05600356059 = _checkpoint(user)
1848
-
    let checkpointActions = $t05600356059._1
1849
-
    let userProfits = $t05600356059._2
1843
+
    let $t05605556111 = _checkpoint(user)
1844
+
    let checkpointActions = $t05605556111._1
1845
+
    let userProfits = $t05605556111._2
1850
1846
 
    $Tuple2(nil, userProfits)
1851
1847
 
    }
1852
1848
 
1859
1855
 
    let weightAmplifier = storage._7
1860
1856
 
    let slippageRate = storage._8
1861
1857
 
    let feeMaxRate = storage._9
1862
-
    let $t05639256452 = _loadAssetBalances()
1863
-
    let assetBalances = $t05639256452._1
1864
-
    let assetTotalSupply = $t05639256452._2
1865
-
    let $t05645756510 = _loadAssetWeights()
1866
-
    let assetWeights = $t05645756510._1
1867
-
    let sigmaWeight = $t05645756510._2
1858
+
    let $t05644456504 = _loadAssetBalances()
1859
+
    let assetBalances = $t05644456504._1
1860
+
    let assetTotalSupply = $t05644456504._2
1861
+
    let $t05650956562 = _loadAssetWeights()
1862
+
    let assetWeights = $t05650956562._1
1863
+
    let sigmaWeight = $t05650956562._2
1868
1864
 
    let fee = _calculateFee(assetBalances, assetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1869
1865
 
    let utilValue = (assetTotalSupply - fee)
1870
1866
 
    $Tuple2(nil, $Tuple2(utilValue, lpTotalSupply))
1867
+
    }
1868
+
1869
+
1870
+
1871
+
@Callable(i)
1872
+
func getFeeFunc () = {
1873
+
    let storage = _loadStorage()
1874
+
    let weightAmplifier = storage._7
1875
+
    let slippageRate = storage._8
1876
+
    let feeMaxRate = storage._9
1877
+
    let $t05699457054 = _loadAssetBalances()
1878
+
    let assetBalances = $t05699457054._1
1879
+
    let assetTotalSupply = $t05699457054._2
1880
+
    let $t05705957112 = _loadAssetWeights()
1881
+
    let assetWeights = $t05705957112._1
1882
+
    let sigmaWeight = $t05705957112._2
1883
+
    let fee = _calculateFee(assetBalances, assetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1884
+
    $Tuple2(nil, fee)
1871
1885
 
    }
1872
1886
 
1873
1887
 
1905
1919
 
                else false
1906
1920
 
            if ((err1 == err1))
1907
1921
 
                then {
1908
-
                    let $t05758357643 = _checkpoint(i.caller)
1909
-
                    let checkpointActions = $t05758357643._1
1910
-
                    let userProfits = $t05758357643._2
1922
+
                    let $t05812058180 = _checkpoint(i.caller)
1923
+
                    let checkpointActions = $t05812058180._1
1924
+
                    let userProfits = $t05812058180._2
1911
1925
 
                    $Tuple2(((checkpointActions ++ _saveUserLp(i.caller, (_loadUserLp(i.caller) + i.payments[0].amount))) ++ _saveTotalLp((_loadTotalLp() + i.payments[0].amount))), unit)
1912
1926
 
                    }
1913
1927
 
                else throw("Strict value is not equal to itself.")
1930
1944
 
            let err1 = _validateInt(amount_, 0, userLp, "unstake: invalid amount")
1931
1945
 
            if ((err1 == err1))
1932
1946
 
                then {
1933
-
                    let $t05815458214 = _checkpoint(i.caller)
1934
-
                    let checkpointActions = $t05815458214._1
1935
-
                    let userProfits = $t05815458214._2
1947
+
                    let $t05869158751 = _checkpoint(i.caller)
1948
+
                    let checkpointActions = $t05869158751._1
1949
+
                    let userProfits = $t05869158751._2
1936
1950
 
                    $Tuple2(((([ScriptTransfer(i.caller, amount_, lpAssetId)] ++ checkpointActions) ++ _saveUserLp(i.caller, (userLp - amount_))) ++ _saveTotalLp((_loadTotalLp() - amount_))), unit)
1937
1951
 
                    }
1938
1952
 
                else throw("Strict value is not equal to itself.")
1943
1957
 
1944
1958
 
1945
1959
 
@Callable(i)
1946
-
func claim (user_,assets_) = {
1947
-
    let err = if (if (_whenInitialized())
1960
+
func claim (user_) = {
1961
+
    let err = if (_whenInitialized())
1948
1962
 
        then _whenNotPaused()
1949
-
        else false)
1950
-
        then _validateInt(size(assets_), 1, 10, "claim: invalid assets size")
1951
1963
 
        else false
1952
1964
 
    if ((err == err))
1953
1965
 
        then {
1960
1972
 
            let assets = [lpAssetIdStr, _loadAssets()]
1961
1973
 
            let maxIndex = (size(assets) - 1)
1962
1974
 
            let userLp = _loadUserLp(user)
1963
-
            let $t05903759093 = _checkpoint(user)
1964
-
            let checkpointActions = $t05903759093._1
1965
-
            let userProfits = $t05903759093._2
1975
+
            let $t05947459530 = _checkpoint(user)
1976
+
            let checkpointActions = $t05947459530._1
1977
+
            let userProfits = $t05947459530._2
1966
1978
 
            func foldFunc (acc,profit) =             {
1967
1979
 
                let index = acc._1
1968
-
                if ((index > maxIndex))
1969
-
                    then $Tuple3((index + 1), (acc._2 :+ profit), acc._3)
1970
-
                    else {
1980
+
                if (if ((maxIndex >= index))
1981
+
                    then (profit > 0)
1982
+
                    else false)
1983
+
                    then {
1971
1984
 
                        let asset = assets[index]
1972
-
                        if (containsElement(assets_, asset))
1973
-
                            then $Tuple3((index + 1), (acc._2 :+ 0), (acc._3 :+ ScriptTransfer(user, profit, _strToAsset(asset))))
1974
-
                            else $Tuple3((index + 1), (acc._2 :+ profit), acc._3)
1985
+
                        $Tuple3((index + 1), (acc._2 :+ 0), (acc._3 :+ ScriptTransfer(user, profit, _strToAsset(asset))))
1975
1986
 
                        }
1987
+
                    else $Tuple3((index + 1), (acc._2 :+ profit), acc._3)
1976
1988
 
                }
1977
1989
 
1978
-
            let $t05958259673 = {
1990
+
            let $t05990859999 = {
1979
1991
 
                let $l = userProfits
1980
1992
 
                let $s = size($l)
1981
1993
 
                let $acc0 = $Tuple3(0, nil, nil)
1989
2001
 
1990
2002
 
                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
1991
2003
 
                }
1992
-
            let idx = $t05958259673._1
1993
-
            let userProfitsUpdated = $t05958259673._2
1994
-
            let profitActions = $t05958259673._3
2004
+
            let idx = $t05990859999._1
2005
+
            let userProfitsUpdated = $t05990859999._2
2006
+
            let profitActions = $t05990859999._3
1995
2007
 
            $Tuple2(((profitActions ++ removeByIndex(checkpointActions, 0)) ++ _saveUserProfits(user, userProfitsUpdated)), unit)
1996
2008
 
            }
1997
2009
 
        else throw("Strict value is not equal to itself.")
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let SEP = "__"
5
5
 
6
6
 
let WAVES = "waves"
7
7
 
8
8
 
let MAX_INT = 9223372036854775807
9
9
 
10
10
 
let MAX_FEE = 1000000
11
11
 
12
12
 
let MAX_AMPLIFIER = 1000000
13
13
 
14
14
 
let MAX_WEIGHT_AMPLIFIER = 1000000
15
15
 
16
16
 
let MAX_WEIGHT = 1000000
17
17
 
18
18
 
let SLIPPAGE_RATE_FACTOR = 1000000
19
19
 
20
20
 
let FEE_RATE_FACTOR = 1000000
21
21
 
22
22
 
let RATE_FACTOR = 1000000
23
23
 
24
-
let PERCENT_FACTOR = toBigInt(1000000000000)
24
+
let PERCENT_FACTOR = toBigInt(1000000000000000000)
25
25
 
26
26
 
let ZERO_INT_LIST_10 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
27
27
 
28
28
 
let ZERO_INT_LIST_11 = (ZERO_INT_LIST_10 :+ 0)
29
29
 
30
30
 
let ZERO_BIGINT = toBigInt(0)
31
31
 
32
32
 
let ZERO_BIGINT_LIST_11 = [ZERO_BIGINT, ZERO_BIGINT, ZERO_BIGINT, ZERO_BIGINT, ZERO_BIGINT, ZERO_BIGINT, ZERO_BIGINT, ZERO_BIGINT, ZERO_BIGINT, ZERO_BIGINT, ZERO_BIGINT]
33
33
 
34
34
 
let INT_DECIMALS = 8
35
35
 
36
36
 
let BIGINT_DECIMALS = 18
37
37
 
38
38
 
let LIST_64 = 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 KEY_MULTISIG = "MULTISIG"
41
41
 
42
42
 
let KEY_STATUS = "STATUS"
43
43
 
44
44
 
let KEY_PAUSED = "PAUSED"
45
45
 
46
46
 
let KEY_PAUSER = "PAUSER"
47
47
 
48
48
 
let KEY_STORAGE = "STORAGE"
49
49
 
50
50
 
let KEY_ASSETS = "ASSETS"
51
51
 
52
52
 
let KEY_ASSET_BALANCES = "ASSET_BALANCES"
53
53
 
54
54
 
let KEY_ASSET_WEIGHTS = "ASSET_WEIGHTS"
55
55
 
56
56
 
let KEY_LP_FEE = "LP_FEE"
57
57
 
58
58
 
let KEY_PROTOCOL_FEE = "PROTOCOL_FEE"
59
59
 
60
60
 
let KEY_PRECISION = "PRECISION"
61
61
 
62
62
 
let KEY_SIGMA_FEE_PER_LP = "SIGMA_FEE_PER_LP"
63
63
 
64
64
 
let KEY_USER_SIGMA_FEE_PER_LP = "USER_SIGMA_FEE_PER_LP"
65
65
 
66
66
 
let KEY_USER_LP = "USER_LP"
67
67
 
68
68
 
let KEY_TOTAL_LP = "TOTAL_LP"
69
69
 
70
70
 
let KEY_USER_PROFITS = "USER_PROFITS"
71
71
 
72
72
 
func _validateAddress (address_,err_) = match addressFromString(address_) {
73
73
 
    case a: Address => 
74
74
 
        true
75
75
 
    case _ => 
76
76
 
        throw(err_)
77
77
 
}
78
78
 
79
79
 
80
80
 
func _validateAsset (assetId_,err_) = if ((assetId_ == WAVES))
81
81
 
    then true
82
82
 
    else     match assetInfo(fromBase58String(assetId_)) {
83
83
 
        case a: Asset => 
84
84
 
            true
85
85
 
        case _ => 
86
86
 
            throw(err_)
87
87
 
    }
88
88
 
89
89
 
90
90
 
func _validateInt (val_,lowerBoundary_,upperBoundary_,err_) = if (if ((lowerBoundary_ > val_))
91
91
 
    then true
92
92
 
    else (val_ > upperBoundary_))
93
93
 
    then throw(err_)
94
94
 
    else true
95
95
 
96
96
 
97
97
 
func _validateBool (val_,target_,err_) = if ((val_ != target_))
98
98
 
    then throw(err_)
99
99
 
    else true
100
100
 
101
101
 
102
102
 
func _validateStringEqual (val1_,val2_,err_) = if ((val1_ != val2_))
103
103
 
    then throw(err_)
104
104
 
    else true
105
105
 
106
106
 
107
107
 
func _validateStringNotEq (val1_,val2_,err_) = if ((val1_ == val2_))
108
108
 
    then throw(err_)
109
109
 
    else true
110
110
 
111
111
 
112
112
 
func _validateIntList (val_,lowerBoundary_,upperBoundary_,err_) = {
113
113
 
    func foldFunc (acc,elem) =         match parseInt(elem) {
114
114
 
        case a: Int => 
115
115
 
            if (acc)
116
116
 
                then _validateInt(a, lowerBoundary_, upperBoundary_, err_)
117
117
 
                else false
118
118
 
        case _ => 
119
119
 
            throw(err_)
120
120
 
    }
121
121
 
122
122
 
    let $l = val_
123
123
 
    let $s = size($l)
124
124
 
    let $acc0 = true
125
125
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
126
126
 
        then $a
127
127
 
        else foldFunc($a, $l[$i])
128
128
 
129
129
 
    func $f0_2 ($a,$i) =     if (($i >= $s))
130
130
 
        then $a
131
131
 
        else throw("List size exceeds 10")
132
132
 
133
133
 
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
134
134
 
    }
135
135
 
136
136
 
137
137
 
func _validateAssets (assets_,err_) = {
138
138
 
    func foldFunc (acc,elem) =     if (acc)
139
139
 
        then _validateAsset(elem, err_)
140
140
 
        else false
141
141
 
142
142
 
    let $l = assets_
143
143
 
    let $s = size($l)
144
144
 
    let $acc0 = true
145
145
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
146
146
 
        then $a
147
147
 
        else foldFunc($a, $l[$i])
148
148
 
149
149
 
    func $f0_2 ($a,$i) =     if (($i >= $s))
150
150
 
        then $a
151
151
 
        else throw("List size exceeds 10")
152
152
 
153
153
 
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
154
154
 
    }
155
155
 
156
156
 
157
157
 
func _validateIntEquals (val1_,val2_,err_) = if ((val1_ != val2_))
158
158
 
    then throw(err_)
159
159
 
    else true
160
160
 
161
161
 
162
162
 
func _validateTokenName (val_,err_) = if (if ((4 > size(val_)))
163
163
 
    then true
164
164
 
    else (size(val_) > 16))
165
165
 
    then throw(err_)
166
166
 
    else true
167
167
 
168
168
 
169
169
 
func _validateTokenDescr (val_,err_) = if ((size(val_) > 1000))
170
170
 
    then throw(err_)
171
171
 
    else true
172
172
 
173
173
 
174
174
 
func _validateDecimals (val_,err_) = if (if ((0 > val_))
175
175
 
    then true
176
176
 
    else (val_ > 8))
177
177
 
    then throw(err_)
178
178
 
    else true
179
179
 
180
180
 
181
181
 
func _validatePayment (payment_,assetId_,requiredAmount_,err_) = match payment_.assetId {
182
182
 
    case a: ByteVector => 
183
183
 
        if ((assetId_ != toBase58String(a)))
184
184
 
            then throw((err_ + ": asset"))
185
185
 
            else if ((requiredAmount_ > payment_.amount))
186
186
 
                then throw((err_ + ": amount"))
187
187
 
                else true
188
188
 
    case _ => 
189
189
 
        throw((err_ + ": asset"))
190
190
 
}
191
191
 
192
192
 
193
193
 
func _validateListContains (list_,val_,err_) = if (!(containsElement(list_, val_)))
194
194
 
    then throw(err_)
195
195
 
    else true
196
196
 
197
197
 
198
198
 
func _assetToStr (asset_) = match asset_ {
199
199
 
    case a: ByteVector => 
200
200
 
        toBase58String(a)
201
201
 
    case _ => 
202
202
 
        WAVES
203
203
 
}
204
204
 
205
205
 
206
206
 
func _strToAsset (asset_) = if (if ((asset_ == WAVES))
207
207
 
    then true
208
208
 
    else (asset_ == ""))
209
209
 
    then unit
210
210
 
    else fromBase58String(asset_)
211
211
 
212
212
 
213
213
 
func _loadPause () = match getBoolean(KEY_PAUSED) {
214
214
 
    case a: Boolean => 
215
215
 
        a
216
216
 
    case _ => 
217
217
 
        false
218
218
 
}
219
219
 
220
220
 
221
221
 
func _savePause (isPaused_) = [BooleanEntry(KEY_PAUSED, isPaused_)]
222
222
 
223
223
 
224
224
 
func _loadPauser () = match getString(KEY_PAUSER) {
225
225
 
    case a: String => 
226
226
 
        addressFromStringValue(a)
227
227
 
    case _ => 
228
228
 
        Address(base58'')
229
229
 
}
230
230
 
231
231
 
232
232
 
func _savePauser (pauser_) = [StringEntry(KEY_PAUSER, toString(pauser_))]
233
233
 
234
234
 
235
235
 
func _loadMultisig () = match getString(KEY_MULTISIG) {
236
236
 
    case a: String => 
237
237
 
        addressFromStringValue(a)
238
238
 
    case _ => 
239
239
 
        Address(base58'')
240
240
 
}
241
241
 
242
242
 
243
243
 
func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
244
244
 
245
245
 
246
246
 
func _loadStorage () = match getString(KEY_STORAGE) {
247
247
 
    case a: String => 
248
248
 
        let struct = split(a, SEP)
249
249
 
        $Tuple10(fromBase58String(struct[0]), (struct[1] == "1"), parseIntValue(struct[2]), parseIntValue(struct[3]), parseIntValue(struct[4]), parseIntValue(struct[5]), parseIntValue(struct[6]), parseIntValue(struct[7]), parseIntValue(struct[8]), addressFromStringValue(struct[9]))
250
250
 
    case _ => 
251
251
 
        $Tuple10(base58'', false, 0, 0, 0, 0, 0, 0, 0, Address(base58''))
252
252
 
}
253
253
 
254
254
 
255
255
 
func _saveStorage (storage_) = [StringEntry(KEY_STORAGE, makeString([toBase58String(storage_._1), if (storage_._2)
256
256
 
    then "1"
257
257
 
    else "0", toString(storage_._3), toString(storage_._4), toString(storage_._5), toString(storage_._6), toString(storage_._7), toString(storage_._8), toString(storage_._9), toString(storage_._10)], SEP))]
258
258
 
259
259
 
260
260
 
func _loadAssets () = match getString(KEY_ASSETS) {
261
261
 
    case a: String => 
262
262
 
        if ((size(a) > 0))
263
263
 
            then split_51C(a, SEP)
264
264
 
            else nil
265
265
 
    case _ => 
266
266
 
        nil
267
267
 
}
268
268
 
269
269
 
270
270
 
func _saveAssets (assets_) = [StringEntry(KEY_ASSETS, makeString_11C(assets_, SEP))]
271
271
 
272
272
 
273
273
 
func _loadAssetBalances () = {
274
274
 
    func foldFunc (acc,elem) =     {
275
275
 
        let balance = parseIntValue(elem)
276
276
 
        $Tuple2((acc._1 :+ balance), (acc._2 + balance))
277
277
 
        }
278
278
 
279
279
 
    match getString(KEY_ASSET_BALANCES) {
280
280
 
        case a: String => 
281
281
 
            if ((size(a) > 0))
282
282
 
                then {
283
283
 
                    let $l = split_51C(a, SEP)
284
284
 
                    let $s = size($l)
285
285
 
                    let $acc0 = $Tuple2(nil, 0)
286
286
 
                    func $f0_1 ($a,$i) =                     if (($i >= $s))
287
287
 
                        then $a
288
288
 
                        else foldFunc($a, $l[$i])
289
289
 
290
290
 
                    func $f0_2 ($a,$i) =                     if (($i >= $s))
291
291
 
                        then $a
292
292
 
                        else throw("List size exceeds 10")
293
293
 
294
294
 
                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
295
295
 
                    }
296
296
 
                else $Tuple2(ZERO_INT_LIST_10, 0)
297
297
 
        case _ => 
298
298
 
            $Tuple2(ZERO_INT_LIST_10, 0)
299
299
 
    }
300
300
 
    }
301
301
 
302
302
 
303
303
 
func _saveAssetBalances (balances_) = {
304
304
 
    func foldFunc (acc,elem) =     (acc :+ toString(elem))
305
305
 
306
306
 
[StringEntry(KEY_ASSET_BALANCES, makeString_11C({
307
307
 
        let $l = balances_
308
308
 
        let $s = size($l)
309
309
 
        let $acc0 = nil
310
310
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
311
311
 
            then $a
312
312
 
            else foldFunc($a, $l[$i])
313
313
 
314
314
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
315
315
 
            then $a
316
316
 
            else throw("List size exceeds 10")
317
317
 
318
318
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
319
319
 
        }, SEP))]
320
320
 
    }
321
321
 
322
322
 
323
323
 
func _loadAssetWeights () = {
324
324
 
    func foldFunc (acc,elem) =     {
325
325
 
        let weight = parseIntValue(elem)
326
326
 
        $Tuple2((acc._1 :+ weight), (acc._2 + weight))
327
327
 
        }
328
328
 
329
329
 
    match getString(KEY_ASSET_WEIGHTS) {
330
330
 
        case a: String => 
331
331
 
            if ((size(a) > 0))
332
332
 
                then {
333
333
 
                    let $l = split_51C(a, SEP)
334
334
 
                    let $s = size($l)
335
335
 
                    let $acc0 = $Tuple2(nil, 0)
336
336
 
                    func $f0_1 ($a,$i) =                     if (($i >= $s))
337
337
 
                        then $a
338
338
 
                        else foldFunc($a, $l[$i])
339
339
 
340
340
 
                    func $f0_2 ($a,$i) =                     if (($i >= $s))
341
341
 
                        then $a
342
342
 
                        else throw("List size exceeds 10")
343
343
 
344
344
 
                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
345
345
 
                    }
346
346
 
                else $Tuple2(ZERO_INT_LIST_10, 0)
347
347
 
        case _ => 
348
348
 
            $Tuple2(ZERO_INT_LIST_10, 0)
349
349
 
    }
350
350
 
    }
351
351
 
352
352
 
353
353
 
func _saveAssetWeights (weights_) = {
354
354
 
    func foldFunc (acc,elem) =     (acc :+ toString(elem))
355
355
 
356
356
 
[StringEntry(KEY_ASSET_WEIGHTS, makeString_11C({
357
357
 
        let $l = weights_
358
358
 
        let $s = size($l)
359
359
 
        let $acc0 = nil
360
360
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
361
361
 
            then $a
362
362
 
            else foldFunc($a, $l[$i])
363
363
 
364
364
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
365
365
 
            then $a
366
366
 
            else throw("List size exceeds 10")
367
367
 
368
368
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
369
369
 
        }, SEP))]
370
370
 
    }
371
371
 
372
372
 
373
373
 
func _loadLpFee (assetId_) = match getInteger(makeString([KEY_LP_FEE, assetId_], SEP)) {
374
374
 
    case a: Int => 
375
375
 
        a
376
376
 
    case _ => 
377
377
 
        0
378
378
 
}
379
379
 
380
380
 
381
381
 
func _saveLpFee (assetId_,val_) = [IntegerEntry(makeString([KEY_LP_FEE, assetId_], SEP), val_)]
382
382
 
383
383
 
384
384
 
func _loadProtocolFee (assetId_) = match getInteger(makeString([KEY_PROTOCOL_FEE, assetId_], SEP)) {
385
385
 
    case a: Int => 
386
386
 
        a
387
387
 
    case _ => 
388
388
 
        0
389
389
 
}
390
390
 
391
391
 
392
392
 
func _saveProtocolFee (assetId_,val_) = [IntegerEntry(makeString([KEY_PROTOCOL_FEE, assetId_], SEP), val_)]
393
393
 
394
394
 
395
395
 
func _loadPrecision () = match getInteger(KEY_PRECISION) {
396
396
 
    case a: Int => 
397
397
 
        a
398
398
 
    case _ => 
399
399
 
        0
400
400
 
}
401
401
 
402
402
 
403
403
 
func _savePrecision (val_) = [IntegerEntry(KEY_PRECISION, val_)]
404
404
 
405
405
 
406
406
 
func _loadSigmaFeePerLp () = {
407
407
 
    func foldFunc (acc,elem) =     (acc :+ parseBigIntValue(elem))
408
408
 
409
409
 
    match getString(KEY_SIGMA_FEE_PER_LP) {
410
410
 
        case a: String => 
411
411
 
            if ((size(a) > 0))
412
412
 
                then {
413
413
 
                    let $l = split_51C(a, SEP)
414
414
 
                    let $s = size($l)
415
415
 
                    let $acc0 = nil
416
416
 
                    func $f0_1 ($a,$i) =                     if (($i >= $s))
417
417
 
                        then $a
418
418
 
                        else foldFunc($a, $l[$i])
419
419
 
420
420
 
                    func $f0_2 ($a,$i) =                     if (($i >= $s))
421
421
 
                        then $a
422
422
 
                        else throw("List size exceeds 11")
423
423
 
424
424
 
                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
425
425
 
                    }
426
426
 
                else ZERO_BIGINT_LIST_11
427
427
 
        case _ => 
428
428
 
            ZERO_BIGINT_LIST_11
429
429
 
    }
430
430
 
    }
431
431
 
432
432
 
433
433
 
func _saveSigmaFeePerLp (val_) = {
434
434
 
    func foldFunc (acc,elem) =     (acc :+ toString(elem))
435
435
 
436
436
 
[StringEntry(KEY_SIGMA_FEE_PER_LP, makeString_11C({
437
437
 
        let $l = val_
438
438
 
        let $s = size($l)
439
439
 
        let $acc0 = nil
440
440
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
441
441
 
            then $a
442
442
 
            else foldFunc($a, $l[$i])
443
443
 
444
444
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
445
445
 
            then $a
446
446
 
            else throw("List size exceeds 11")
447
447
 
448
448
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
449
449
 
        }, SEP))]
450
450
 
    }
451
451
 
452
452
 
453
453
 
func _loadUserSigmaFeePerLp (user_) = {
454
454
 
    func foldFunc (acc,elem) =     (acc :+ parseBigIntValue(elem))
455
455
 
456
456
 
    match getString(makeString([KEY_USER_SIGMA_FEE_PER_LP, toString(user_)], SEP)) {
457
457
 
        case a: String => 
458
458
 
            if ((size(a) > 0))
459
459
 
                then {
460
460
 
                    let $l = split_51C(a, SEP)
461
461
 
                    let $s = size($l)
462
462
 
                    let $acc0 = nil
463
463
 
                    func $f0_1 ($a,$i) =                     if (($i >= $s))
464
464
 
                        then $a
465
465
 
                        else foldFunc($a, $l[$i])
466
466
 
467
467
 
                    func $f0_2 ($a,$i) =                     if (($i >= $s))
468
468
 
                        then $a
469
469
 
                        else throw("List size exceeds 11")
470
470
 
471
471
 
                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
472
472
 
                    }
473
473
 
                else ZERO_BIGINT_LIST_11
474
474
 
        case _ => 
475
475
 
            ZERO_BIGINT_LIST_11
476
476
 
    }
477
477
 
    }
478
478
 
479
479
 
480
480
 
func _saveUserSigmaFeePerLp (user_,val_) = {
481
481
 
    func foldFunc (acc,elem) =     (acc :+ toString(elem))
482
482
 
483
483
 
[StringEntry(makeString([KEY_USER_SIGMA_FEE_PER_LP, toString(user_)], SEP), makeString_11C({
484
484
 
        let $l = val_
485
485
 
        let $s = size($l)
486
486
 
        let $acc0 = nil
487
487
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
488
488
 
            then $a
489
489
 
            else foldFunc($a, $l[$i])
490
490
 
491
491
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
492
492
 
            then $a
493
493
 
            else throw("List size exceeds 11")
494
494
 
495
495
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
496
496
 
        }, SEP))]
497
497
 
    }
498
498
 
499
499
 
500
500
 
func _loadUserLp (address_) = match getInteger(makeString([KEY_USER_LP, toString(address_)], SEP)) {
501
501
 
    case a: Int => 
502
502
 
        a
503
503
 
    case _ => 
504
504
 
        0
505
505
 
}
506
506
 
507
507
 
508
508
 
func _saveUserLp (address_,val_) = [IntegerEntry(makeString([KEY_USER_LP, toString(address_)], SEP), val_)]
509
509
 
510
510
 
511
511
 
func _loadTotalLp () = match getInteger(KEY_TOTAL_LP) {
512
512
 
    case a: Int => 
513
513
 
        a
514
514
 
    case _ => 
515
515
 
        0
516
516
 
}
517
517
 
518
518
 
519
519
 
func _saveTotalLp (val_) = [IntegerEntry(KEY_TOTAL_LP, val_)]
520
520
 
521
521
 
522
522
 
func _loadUserProfits (user_) = {
523
523
 
    func foldFunc (acc,elem) =     (acc :+ parseIntValue(elem))
524
524
 
525
525
 
    match getString(makeString([KEY_USER_PROFITS, toString(user_)], SEP)) {
526
526
 
        case a: String => 
527
527
 
            if ((size(a) > 0))
528
528
 
                then {
529
529
 
                    let $l = split_51C(a, SEP)
530
530
 
                    let $s = size($l)
531
531
 
                    let $acc0 = nil
532
532
 
                    func $f0_1 ($a,$i) =                     if (($i >= $s))
533
533
 
                        then $a
534
534
 
                        else foldFunc($a, $l[$i])
535
535
 
536
536
 
                    func $f0_2 ($a,$i) =                     if (($i >= $s))
537
537
 
                        then $a
538
538
 
                        else throw("List size exceeds 11")
539
539
 
540
540
 
                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
541
541
 
                    }
542
542
 
                else ZERO_INT_LIST_11
543
543
 
        case _ => 
544
544
 
            ZERO_INT_LIST_11
545
545
 
    }
546
546
 
    }
547
547
 
548
548
 
549
549
 
func _saveUserProfits (user_,val_) = {
550
550
 
    func foldFunc (acc,elem) =     (acc :+ toString(elem))
551
551
 
552
552
 
[StringEntry(makeString([KEY_USER_PROFITS, toString(user_)], SEP), makeString_11C({
553
553
 
        let $l = val_
554
554
 
        let $s = size($l)
555
555
 
        let $acc0 = nil
556
556
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
557
557
 
            then $a
558
558
 
            else foldFunc($a, $l[$i])
559
559
 
560
560
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
561
561
 
            then $a
562
562
 
            else throw("List size exceeds 11")
563
563
 
564
564
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
565
565
 
        }, SEP))]
566
566
 
    }
567
567
 
568
568
 
569
569
 
func _onlyThisContract (caller_) = if ((caller_ != this))
570
570
 
    then throw("_onlyThisContract: revert")
571
571
 
    else true
572
572
 
573
573
 
574
574
 
func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
575
575
 
    then throw("_whenMultisigSet: revert")
576
576
 
    else true
577
577
 
578
578
 
579
579
 
func _whenNotInitialized () = {
580
580
 
    let storage = _loadStorage()
581
581
 
    if ((storage._1 != base58''))
582
582
 
        then throw("_whenNotInitialized: revert")
583
583
 
        else true
584
584
 
    }
585
585
 
586
586
 
587
587
 
func _whenInitialized () = {
588
588
 
    let storage = _loadStorage()
589
589
 
    if ((storage._1 == base58''))
590
590
 
        then throw("_whenInitialized: revert")
591
591
 
        else true
592
592
 
    }
593
593
 
594
594
 
595
595
 
func _whenNotPaused () = if (_loadPause())
596
596
 
    then throw("_whenNotPaused: revert")
597
597
 
    else true
598
598
 
599
599
 
600
600
 
func _whenPaused () = if (!(_loadPause()))
601
601
 
    then throw("_whenPaused: revert")
602
602
 
    else true
603
603
 
604
604
 
605
605
 
func _onlyPauser (caller_) = if ((caller_ != _loadPauser()))
606
606
 
    then throw("_onlyPauser: revert")
607
607
 
    else true
608
608
 
609
609
 
610
610
 
func _getDecimals (assetId_) = match assetInfo(fromBase58String(assetId_)) {
611
611
 
    case a: Asset => 
612
612
 
        a.decimals
613
613
 
    case _ => 
614
614
 
        throw(("_getDecimals: no asset=" + assetId_))
615
615
 
}
616
616
 
617
617
 
618
618
 
func _normalizeDecimals (amount_,sourceDecimals_,targetDecimals_,round_) = if ((sourceDecimals_ >= targetDecimals_))
619
619
 
    then fraction(amount_, 1, pow(10, 0, (sourceDecimals_ - targetDecimals_), 0, 0, DOWN), round_)
620
620
 
    else (amount_ * pow(10, 0, (targetDecimals_ - sourceDecimals_), 0, 0, DOWN))
621
621
 
622
622
 
623
623
 
func _prepareAssetBalances (assets_) = {
624
624
 
    func foldFunc (acc,elem) =     (acc :+ 0)
625
625
 
626
626
 
    let $l = assets_
627
627
 
    let $s = size($l)
628
628
 
    let $acc0 = nil
629
629
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
630
630
 
        then $a
631
631
 
        else foldFunc($a, $l[$i])
632
632
 
633
633
 
    func $f0_2 ($a,$i) =     if (($i >= $s))
634
634
 
        then $a
635
635
 
        else throw("List size exceeds 10")
636
636
 
637
637
 
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
638
638
 
    }
639
639
 
640
640
 
641
641
 
func _prepareAssetWeights (assetWeights_) = {
642
642
 
    func foldFunc (acc,elem) =     {
643
643
 
        let weight = parseIntValue(elem)
644
644
 
        $Tuple2((acc._1 :+ weight), (acc._2 + weight))
645
645
 
        }
646
646
 
647
647
 
    let $l = assetWeights_
648
648
 
    let $s = size($l)
649
649
 
    let $acc0 = $Tuple2(nil, 0)
650
650
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
651
651
 
        then $a
652
652
 
        else foldFunc($a, $l[$i])
653
653
 
654
654
 
    func $f0_2 ($a,$i) =     if (($i >= $s))
655
655
 
        then $a
656
656
 
        else throw("List size exceeds 10")
657
657
 
658
658
 
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
659
659
 
    }
660
660
 
661
661
 
662
662
 
func _getAssetBalances (assets_,decimals_) = {
663
663
 
    func foldFunc (acc,elem) =     {
664
664
 
        let assetDecimals = _getDecimals(elem)
665
665
 
        let balance = _normalizeDecimals(assetBalance(this, fromBase58String(elem)), assetDecimals, decimals_, DOWN)
666
666
 
        $Tuple2((acc._1 :+ balance), (acc._2 + balance))
667
667
 
        }
668
668
 
669
669
 
    let $l = assets_
670
670
 
    let $s = size($l)
671
671
 
    let $acc0 = $Tuple2(nil, 0)
672
672
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
673
673
 
        then $a
674
674
 
        else foldFunc($a, $l[$i])
675
675
 
676
676
 
    func $f0_2 ($a,$i) =     if (($i >= $s))
677
677
 
        then $a
678
678
 
        else throw("List size exceeds 10")
679
679
 
680
680
 
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
681
681
 
    }
682
682
 
683
683
 
684
684
 
func _listIntToString (assets_) = {
685
685
 
    func foldFunc (acc,elem) =     (acc :+ toString(elem))
686
686
 
687
687
 
    makeString({
688
688
 
        let $l = assets_
689
689
 
        let $s = size($l)
690
690
 
        let $acc0 = nil
691
691
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
692
692
 
            then $a
693
693
 
            else foldFunc($a, $l[$i])
694
694
 
695
695
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
696
696
 
            then $a
697
697
 
            else throw("List size exceeds 11")
698
698
 
699
699
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
700
700
 
        }, SEP)
701
701
 
    }
702
702
 
703
703
 
704
704
 
func _listBigIntToString (assets_) = {
705
705
 
    func foldFunc (acc,elem) =     (acc :+ toString(elem))
706
706
 
707
707
 
    makeString({
708
708
 
        let $l = assets_
709
709
 
        let $s = size($l)
710
710
 
        let $acc0 = nil
711
711
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
712
712
 
            then $a
713
713
 
            else foldFunc($a, $l[$i])
714
714
 
715
715
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
716
716
 
            then $a
717
717
 
            else throw("List size exceeds 11")
718
718
 
719
719
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
720
720
 
        }, SEP)
721
721
 
    }
722
722
 
723
723
 
724
724
 
func _getEquilibriums (sigmaBalances_,weights_,sigmaWeight_) = {
725
725
 
    func foldFunc (acc,elem) =     (acc :+ fraction(sigmaBalances_, elem, sigmaWeight_))
726
726
 
727
727
 
    let $l = weights_
728
728
 
    let $s = size($l)
729
729
 
    let $acc0 = nil
730
730
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
731
731
 
        then $a
732
732
 
        else foldFunc($a, $l[$i])
733
733
 
734
734
 
    func $f0_2 ($a,$i) =     if (($i >= $s))
735
735
 
        then $a
736
736
 
        else throw("List size exceeds 10")
737
737
 
738
738
 
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
739
739
 
    }
740
740
 
741
741
 
742
742
 
func _incrementBalancesByAmounts (balances_,amounts_) = {
743
743
 
    func foldFunc (acc,elem) =     {
744
744
 
        let index = acc._1
745
745
 
        let amount = amounts_[index]
746
746
 
        let newBalance = (elem + amount)
747
747
 
        $Tuple3((index + 1), (acc._2 :+ newBalance), (acc._3 + newBalance))
748
748
 
        }
749
749
 
750
750
 
    let result = {
751
751
 
        let $l = balances_
752
752
 
        let $s = size($l)
753
753
 
        let $acc0 = $Tuple3(0, nil, 0)
754
754
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
755
755
 
            then $a
756
756
 
            else foldFunc($a, $l[$i])
757
757
 
758
758
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
759
759
 
            then $a
760
760
 
            else throw("List size exceeds 10")
761
761
 
762
762
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
763
763
 
        }
764
764
 
    $Tuple2(result._2, result._3)
765
765
 
    }
766
766
 
767
767
 
768
768
 
func _incrementBalancesByPayments (balances_,payments_,assets_,decimals_,err_) = {
769
769
 
    func foldFunc (acc,elem) =     {
770
770
 
        let index = acc._1
771
771
 
        let payment = payments_[index]
772
772
 
        let paymentAssetStr = _assetToStr(payment.assetId)
773
773
 
        let err = if ((paymentAssetStr != assets_[index]))
774
774
 
            then throw(((err_ + ": index=") + toString(index)))
775
775
 
            else unit
776
776
 
        if ((err == err))
777
777
 
            then {
778
778
 
                let assetDecimals = _getDecimals(paymentAssetStr)
779
779
 
                let newBalance = (elem + _normalizeDecimals(payments_[index].amount, assetDecimals, decimals_, DOWN))
780
780
 
                $Tuple3((index + 1), (acc._2 :+ newBalance), (acc._3 + newBalance))
781
781
 
                }
782
782
 
            else throw("Strict value is not equal to itself.")
783
783
 
        }
784
784
 
785
785
 
    let result = {
786
786
 
        let $l = balances_
787
787
 
        let $s = size($l)
788
788
 
        let $acc0 = $Tuple3(0, nil, 0)
789
789
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
790
790
 
            then $a
791
791
 
            else foldFunc($a, $l[$i])
792
792
 
793
793
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
794
794
 
            then $a
795
795
 
            else throw("List size exceeds 10")
796
796
 
797
797
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
798
798
 
        }
799
799
 
    $Tuple2(result._2, result._3)
800
800
 
    }
801
801
 
802
802
 
803
803
 
func _incrementBalanceByIndex (balances_,index_,amount_) = {
804
804
 
    func foldFunc (acc,elem) =     {
805
805
 
        let index = acc._1
806
806
 
        if ((index == index_))
807
807
 
            then $Tuple2((index + 1), (acc._2 :+ (elem + amount_)))
808
808
 
            else $Tuple2((index + 1), (acc._2 :+ elem))
809
809
 
        }
810
810
 
811
811
 
    let result = {
812
812
 
        let $l = balances_
813
813
 
        let $s = size($l)
814
814
 
        let $acc0 = $Tuple2(0, nil)
815
815
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
816
816
 
            then $a
817
817
 
            else foldFunc($a, $l[$i])
818
818
 
819
819
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
820
820
 
            then $a
821
821
 
            else throw("List size exceeds 10")
822
822
 
823
823
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
824
824
 
        }
825
825
 
    result._2
826
826
 
    }
827
827
 
828
828
 
829
829
 
func _decrementBalanceByIndex (balances_,index_,amount_) = {
830
830
 
    func foldFunc (acc,elem) =     {
831
831
 
        let index = acc._1
832
832
 
        if ((index == index_))
833
833
 
            then $Tuple2((index + 1), (acc._2 :+ (elem - amount_)))
834
834
 
            else $Tuple2((index + 1), (acc._2 :+ elem))
835
835
 
        }
836
836
 
837
837
 
    let result = {
838
838
 
        let $l = balances_
839
839
 
        let $s = size($l)
840
840
 
        let $acc0 = $Tuple2(0, nil)
841
841
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
842
842
 
            then $a
843
843
 
            else foldFunc($a, $l[$i])
844
844
 
845
845
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
846
846
 
            then $a
847
847
 
            else throw("List size exceeds 10")
848
848
 
849
849
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
850
850
 
        }
851
851
 
    result._2
852
852
 
    }
853
853
 
854
854
 
855
855
 
func _decrementBalancesByLpAmount (balances_,amount_,lpTotalSupply_) = {
856
856
 
    let rate = fraction((lpTotalSupply_ - amount_), RATE_FACTOR, lpTotalSupply_, CEILING)
857
857
 
    func foldFunc (acc,elem) =     {
858
858
 
        let newBalance = fraction(elem, rate, RATE_FACTOR, CEILING)
859
859
 
        let deltaBalance = (elem - newBalance)
860
860
 
        $Tuple3((acc._1 :+ newBalance), (acc._2 + newBalance), (acc._3 :+ deltaBalance))
861
861
 
        }
862
862
 
863
863
 
    let $l = balances_
864
864
 
    let $s = size($l)
865
865
 
    let $acc0 = $Tuple3(nil, 0, nil)
866
866
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
867
867
 
        then $a
868
868
 
        else foldFunc($a, $l[$i])
869
869
 
870
870
 
    func $f0_2 ($a,$i) =     if (($i >= $s))
871
871
 
        then $a
872
872
 
        else throw("List size exceeds 10")
873
873
 
874
874
 
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
875
875
 
    }
876
876
 
877
877
 
878
878
 
func _getPaymentsFromBalances (assets_,balances_,recipient_,sourceDecimals_) = {
879
879
 
    func foldFunc (acc,elem) =     {
880
880
 
        let index = acc._1
881
881
 
        $Tuple2((index + 1), (acc._2 :+ ScriptTransfer(recipient_, _normalizeDecimals(balances_[index], sourceDecimals_, _getDecimals(elem), DOWN), _strToAsset(elem))))
882
882
 
        }
883
883
 
884
884
 
    let result = {
885
885
 
        let $l = assets_
886
886
 
        let $s = size($l)
887
887
 
        let $acc0 = $Tuple2(0, nil)
888
888
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
889
889
 
            then $a
890
890
 
            else foldFunc($a, $l[$i])
891
891
 
892
892
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
893
893
 
            then $a
894
894
 
            else throw("List size exceeds 10")
895
895
 
896
896
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
897
897
 
        }
898
898
 
    result._2
899
899
 
    }
900
900
 
901
901
 
902
902
 
func _calculateMicroFee (balance_,equilibrium_,weightAmplifier_,slippageRate_,feeMaxRate_) = if ((equilibrium_ > balance_))
903
903
 
    then {
904
904
 
        let threshold = fraction(equilibrium_, (MAX_WEIGHT_AMPLIFIER - weightAmplifier_), MAX_WEIGHT_AMPLIFIER)
905
905
 
        if ((threshold > balance_))
906
906
 
            then {
907
907
 
                let maxDeviation = (threshold - balance_)
908
908
 
                let feeRate = fraction(fraction(maxDeviation, slippageRate_, SLIPPAGE_RATE_FACTOR), FEE_RATE_FACTOR, equilibrium_)
909
909
 
                if ((feeRate > feeMaxRate_))
910
910
 
                    then fraction(maxDeviation, feeMaxRate_, FEE_RATE_FACTOR)
911
911
 
                    else fraction(maxDeviation, feeRate, FEE_RATE_FACTOR)
912
912
 
                }
913
913
 
            else 0
914
914
 
        }
915
915
 
    else {
916
916
 
        let threshold = fraction(equilibrium_, (MAX_WEIGHT_AMPLIFIER + weightAmplifier_), MAX_WEIGHT_AMPLIFIER)
917
917
 
        if ((balance_ > threshold))
918
918
 
            then {
919
919
 
                let maxDeviation = (balance_ - threshold)
920
920
 
                let feeRate = fraction(fraction(maxDeviation, slippageRate_, SLIPPAGE_RATE_FACTOR), FEE_RATE_FACTOR, equilibrium_)
921
921
 
                if ((feeRate > feeMaxRate_))
922
922
 
                    then fraction(maxDeviation, feeMaxRate_, FEE_RATE_FACTOR)
923
923
 
                    else fraction(maxDeviation, feeRate, FEE_RATE_FACTOR)
924
924
 
                }
925
925
 
            else 0
926
926
 
        }
927
927
 
928
928
 
929
929
 
func _calculateFee (balances_,assetsTotalSupply_,weights_,sigmaWeight_,weightAmplifier_,slippageRate_,feeMaxRate_) = {
930
930
 
    func foldFunc (acc,balance) =     {
931
931
 
        let index = acc._1
932
932
 
        let equilibrium = fraction(assetsTotalSupply_, weights_[index], sigmaWeight_)
933
933
 
        $Tuple2((index + 1), (acc._2 + _calculateMicroFee(balance, equilibrium, weightAmplifier_, slippageRate_, feeMaxRate_)))
934
934
 
        }
935
935
 
936
936
 
    let result = {
937
937
 
        let $l = balances_
938
938
 
        let $s = size($l)
939
939
 
        let $acc0 = $Tuple2(0, 0)
940
940
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
941
941
 
            then $a
942
942
 
            else foldFunc($a, $l[$i])
943
943
 
944
944
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
945
945
 
            then $a
946
946
 
            else throw("List size exceeds 10")
947
947
 
948
948
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
949
949
 
        }
950
950
 
    result._2
951
951
 
    }
952
952
 
953
953
 
954
954
 
func _validateLiquidityInvariant (prevAssetBalances_,prevAssetTotalSupply_,assetBalances_,assetTotalSupply_,prevLpTotalSupply_,lpTotalSupply_,assetWeights_,sigmaWeight_,weightAmplifier_,slippageRate_,feeMaxRate_) = if (if ((prevLpTotalSupply_ == 0))
955
955
 
    then true
956
956
 
    else (lpTotalSupply_ == 0))
957
957
 
    then true
958
958
 
    else {
959
959
 
        let prevAssetsRate = fraction((prevAssetTotalSupply_ - _calculateFee(prevAssetBalances_, prevAssetTotalSupply_, assetWeights_, sigmaWeight_, weightAmplifier_, slippageRate_, feeMaxRate_)), RATE_FACTOR, prevLpTotalSupply_)
960
960
 
        let newAssetsRate = fraction((assetTotalSupply_ - _calculateFee(assetBalances_, assetTotalSupply_, assetWeights_, sigmaWeight_, weightAmplifier_, slippageRate_, feeMaxRate_)), RATE_FACTOR, lpTotalSupply_)
961
961
 
        let diff = (newAssetsRate - prevAssetsRate)
962
962
 
        if (if ((0 >= diff))
963
-
            then ((-1 * RATE_FACTOR) > diff)
963
+
            then ((-1 * _loadPrecision()) > diff)
964
964
 
            else false)
965
965
 
            then throw(("_validateLiquidityInvariant: revert: diff=" + toString(diff)))
966
966
 
            else true
967
967
 
        }
968
968
 
969
969
 
970
970
 
func _validateSwapInvariant (prevAssetBalances_,prevAssetTotalSupply_,assetBalances_,assetTotalSupply_,assetWeights_,sigmaWeight_,weightAmplifier_,slippageRate_,feeMaxRate_) = {
971
971
 
    let prevUtil = (prevAssetTotalSupply_ - _calculateFee(prevAssetBalances_, prevAssetTotalSupply_, assetWeights_, sigmaWeight_, weightAmplifier_, slippageRate_, feeMaxRate_))
972
972
 
    let newUtil = (assetTotalSupply_ - _calculateFee(assetBalances_, assetTotalSupply_, assetWeights_, sigmaWeight_, weightAmplifier_, slippageRate_, feeMaxRate_))
973
973
 
    let diff = (newUtil - prevUtil)
974
974
 
    if (if ((0 >= diff))
975
-
        then ((-1 * RATE_FACTOR) > diff)
975
+
        then ((-1 * _loadPrecision()) > diff)
976
976
 
        else false)
977
977
 
        then throw(("_validateSwapInvariant: revert: diff=" + toString(diff)))
978
978
 
        else true
979
979
 
    }
980
980
 
981
981
 
982
982
 
func _validateAssetAllocation (balance_,assetTotalSupply_,prevBalance_,prevAssetTotalSupply_,weight_,sigmaWeight_,maxAllocAmp_) = {
983
983
 
    let equilibrium = fraction(assetTotalSupply_, weight_, sigmaWeight_)
984
984
 
    let maxAllocationAmp = if ((balance_ > equilibrium))
985
985
 
        then (MAX_AMPLIFIER + maxAllocAmp_)
986
986
 
        else (MAX_AMPLIFIER - maxAllocAmp_)
987
987
 
    let maxAllocation = fraction(equilibrium, maxAllocationAmp, MAX_AMPLIFIER)
988
988
 
    let prevMaxAllocation = fraction(fraction(prevAssetTotalSupply_, weight_, sigmaWeight_), maxAllocationAmp, MAX_AMPLIFIER)
989
989
 
    if ((balance_ > equilibrium))
990
990
 
        then if ((balance_ > maxAllocation))
991
991
 
            then if ((prevMaxAllocation > prevBalance_))
992
992
 
                then throw("_validateAssetAllocation: new up")
993
993
 
                else if (((balance_ - maxAllocation) > (prevBalance_ - prevMaxAllocation)))
994
994
 
                    then throw("_validateAssetAllocation: still up")
995
995
 
                    else true
996
996
 
            else true
997
997
 
        else if ((maxAllocation > balance_))
998
998
 
            then if ((prevBalance_ > prevMaxAllocation))
999
999
 
                then throw("_validateAssetAllocation: new down")
1000
-
                else if (((prevMaxAllocation - prevBalance_) > (maxAllocation - balance_)))
1000
+
                else if (((maxAllocation - balance_) > (prevMaxAllocation - prevBalance_)))
1001
1001
 
                    then throw("_validateAssetAllocation: still down")
1002
1002
 
                    else true
1003
1003
 
            else true
1004
1004
 
    }
1005
1005
 
1006
1006
 
1007
1007
 
func _validateAllocation (assetBalances_,assetTotalSupply_,prevAssetBalances_,prevAssetTotalSupply_,assetWeights_,sigmaWeight_,maxAllocAmp_) = {
1008
1008
 
    func foldFunc (acc,elem) =     {
1009
1009
 
        let index = acc._1
1010
1010
 
        $Tuple2((index + 1), if (acc._2)
1011
1011
 
            then _validateAssetAllocation(elem, assetTotalSupply_, prevAssetBalances_[index], prevAssetTotalSupply_, assetWeights_[index], sigmaWeight_, maxAllocAmp_)
1012
1012
 
            else false)
1013
1013
 
        }
1014
1014
 
1015
1015
 
    let result = {
1016
1016
 
        let $l = assetBalances_
1017
1017
 
        let $s = size($l)
1018
1018
 
        let $acc0 = $Tuple2(0, true)
1019
1019
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
1020
1020
 
            then $a
1021
1021
 
            else foldFunc($a, $l[$i])
1022
1022
 
1023
1023
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
1024
1024
 
            then $a
1025
1025
 
            else throw("List size exceeds 10")
1026
1026
 
1027
1027
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1028
1028
 
        }
1029
1029
 
    result._2
1030
1030
 
    }
1031
1031
 
1032
1032
 
1033
1033
 
func _checkpoint (user_) = {
1034
1034
 
    let userLp = _loadUserLp(user_)
1035
1035
 
    let userProfits = _loadUserProfits(user_)
1036
1036
 
    let sigmaFeePerLp = _loadSigmaFeePerLp()
1037
1037
 
    let userSigmaFeePerLp = _loadUserSigmaFeePerLp(user_)
1038
1038
 
    func foldFunc (acc,elem) =     {
1039
1039
 
        let index = acc._1
1040
1040
 
        let profitUpdated = (userProfits[index] + toInt(fraction(toBigInt(userLp), (sigmaFeePerLp[index] - userSigmaFeePerLp[index]), PERCENT_FACTOR)))
1041
1041
 
        $Tuple2((index + 1), (acc._2 :+ profitUpdated))
1042
1042
 
        }
1043
1043
 
1044
-
    let $t02458924662 = {
1044
+
    let $t02460524678 = {
1045
1045
 
        let $l = ZERO_INT_LIST_11
1046
1046
 
        let $s = size($l)
1047
1047
 
        let $acc0 = $Tuple2(0, nil)
1048
1048
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
1049
1049
 
            then $a
1050
1050
 
            else foldFunc($a, $l[$i])
1051
1051
 
1052
1052
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
1053
1053
 
            then $a
1054
1054
 
            else throw("List size exceeds 11")
1055
1055
 
1056
1056
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
1057
1057
 
        }
1058
-
    let idx = $t02458924662._1
1059
-
    let profitsUpdated = $t02458924662._2
1058
+
    let idx = $t02460524678._1
1059
+
    let profitsUpdated = $t02460524678._2
1060
1060
 
    $Tuple2((_saveUserProfits(user_, profitsUpdated) ++ _saveUserSigmaFeePerLp(user_, sigmaFeePerLp)), profitsUpdated)
1061
1061
 
    }
1062
1062
 
1063
1063
 
1064
1064
 
func _updateSigmaFeePerLp (sigmaFeePerLp_,totalLp_,index_,lpFee_) = {
1065
1065
 
    func foldFunc (acc,elem) =     {
1066
1066
 
        let index = acc._1
1067
1067
 
        let sigmaFeePerLpUpdated = if ((index_ == index))
1068
1068
 
            then (sigmaFeePerLp_[index] + fraction(toBigInt(lpFee_), PERCENT_FACTOR, toBigInt(totalLp_)))
1069
1069
 
            else sigmaFeePerLp_[index]
1070
1070
 
        $Tuple2((index + 1), (acc._2 :+ sigmaFeePerLpUpdated))
1071
1071
 
        }
1072
1072
 
1073
-
    let $t02531225391 = {
1073
+
    let $t02532825407 = {
1074
1074
 
        let $l = ZERO_INT_LIST_11
1075
1075
 
        let $s = size($l)
1076
1076
 
        let $acc0 = $Tuple2(0, nil)
1077
1077
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
1078
1078
 
            then $a
1079
1079
 
            else foldFunc($a, $l[$i])
1080
1080
 
1081
1081
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
1082
1082
 
            then $a
1083
1083
 
            else throw("List size exceeds 11")
1084
1084
 
1085
1085
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
1086
1086
 
        }
1087
-
    let idx = $t02531225391._1
1088
-
    let sigmaFeePerLpUpdated = $t02531225391._2
1087
+
    let idx = $t02532825407._1
1088
+
    let sigmaFeePerLpUpdated = $t02532825407._2
1089
1089
 
    sigmaFeePerLpUpdated
1090
1090
 
    }
1091
1091
 
1092
1092
 
1093
1093
 
func _calculateLpAndProtocolFees (assetIndex_,amount_,lpFeeRate_,protocolFeeRate_) = {
1094
1094
 
    let sigmaFeePerLp = _loadSigmaFeePerLp()
1095
1095
 
    let totalLp = _loadTotalLp()
1096
-
    let $t02561225887 = if ((totalLp == 0))
1096
+
    let $t02562825903 = if ((totalLp == 0))
1097
1097
 
        then $Tuple2(0, fraction(amount_, protocolFeeRate_, MAX_FEE))
1098
1098
 
        else $Tuple2(fraction(amount_, lpFeeRate_, MAX_FEE), fraction(amount_, protocolFeeRate_, MAX_FEE))
1099
-
    let lpFee = $t02561225887._1
1100
-
    let protocolFee = $t02561225887._2
1099
+
    let lpFee = $t02562825903._1
1100
+
    let protocolFee = $t02562825903._2
1101
1101
 
    let sigmaFeePerLpUpdated = if ((lpFee == 0))
1102
1102
 
        then sigmaFeePerLp
1103
1103
 
        else _updateSigmaFeePerLp(sigmaFeePerLp, totalLp, assetIndex_, lpFee)
1104
1104
 
    $Tuple3(lpFee, protocolFee, sigmaFeePerLpUpdated)
1105
1105
 
    }
1106
1106
 
1107
1107
 
1108
1108
 
func _depositAll (amount_) = {
1109
1109
 
    let storage = _loadStorage()
1110
1110
 
    let lpTotalSupply = storage._3
1111
1111
 
    let weightAmplifier = storage._7
1112
1112
 
    let slippageRate = storage._8
1113
1113
 
    let feeMaxRate = storage._9
1114
1114
 
    let assets = _loadAssets()
1115
-
    let $t02639626449 = _loadAssetWeights()
1116
-
    let assetWeights = $t02639626449._1
1117
-
    let sigmaWeight = $t02639626449._2
1118
-
    let $t02645426522 = _loadAssetBalances()
1119
-
    let prevAssetBalances = $t02645426522._1
1120
-
    let prevAssetTotalSupply = $t02645426522._2
1121
-
    let $t02652827758 = if ((prevAssetTotalSupply == 0))
1115
+
    let $t02641226465 = _loadAssetWeights()
1116
+
    let assetWeights = $t02641226465._1
1117
+
    let sigmaWeight = $t02641226465._2
1118
+
    let $t02647026538 = _loadAssetBalances()
1119
+
    let prevAssetBalances = $t02647026538._1
1120
+
    let prevAssetTotalSupply = $t02647026538._2
1121
+
    let $t02654427774 = if ((prevAssetTotalSupply == 0))
1122
1122
 
        then {
1123
1123
 
            func foldFunc (acc,elem) =             {
1124
1124
 
                let index = acc._1
1125
1125
 
                let requiredAmountNormalized = fraction(assetWeights[index], amount_, sigmaWeight)
1126
1126
 
                $Tuple2((index + 1), (acc._2 :+ requiredAmountNormalized))
1127
1127
 
                }
1128
1128
 
1129
-
            let $t02697027044 = {
1129
+
            let $t02698627060 = {
1130
1130
 
                let $l = assets
1131
1131
 
                let $s = size($l)
1132
1132
 
                let $acc0 = $Tuple2(0, nil)
1133
1133
 
                func $f0_1 ($a,$i) =                 if (($i >= $s))
1134
1134
 
                    then $a
1135
1135
 
                    else foldFunc($a, $l[$i])
1136
1136
 
1137
1137
 
                func $f0_2 ($a,$i) =                 if (($i >= $s))
1138
1138
 
                    then $a
1139
1139
 
                    else throw("List size exceeds 10")
1140
1140
 
1141
1141
 
                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1142
1142
 
                }
1143
-
            let idx = $t02697027044._1
1144
-
            let requiredAmountsNormalized = $t02697027044._2
1143
+
            let idx = $t02698627060._1
1144
+
            let requiredAmountsNormalized = $t02698627060._2
1145
1145
 
            $Tuple2(amount_, requiredAmountsNormalized)
1146
1146
 
            }
1147
1147
 
        else {
1148
1148
 
            let ratio = fraction(toBigInt(amount_), PERCENT_FACTOR, toBigInt(prevAssetTotalSupply))
1149
1149
 
            func foldFunc1 (acc,elem) =             {
1150
1150
 
                let index = acc._1
1151
1151
 
                let requiredAmountNormalized = toInt(fraction(ratio, toBigInt(prevAssetBalances[index]), PERCENT_FACTOR))
1152
1152
 
                $Tuple2((index + 1), (acc._2 :+ requiredAmountNormalized))
1153
1153
 
                }
1154
1154
 
1155
-
            let $t02758727662 = {
1155
+
            let $t02760327678 = {
1156
1156
 
                let $l = assets
1157
1157
 
                let $s = size($l)
1158
1158
 
                let $acc0 = $Tuple2(0, nil)
1159
1159
 
                func $f0_1 ($a,$i) =                 if (($i >= $s))
1160
1160
 
                    then $a
1161
1161
 
                    else foldFunc1($a, $l[$i])
1162
1162
 
1163
1163
 
                func $f0_2 ($a,$i) =                 if (($i >= $s))
1164
1164
 
                    then $a
1165
1165
 
                    else throw("List size exceeds 10")
1166
1166
 
1167
1167
 
                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1168
1168
 
                }
1169
-
            let idx = $t02758727662._1
1170
-
            let requiredAmountsNormalized = $t02758727662._2
1169
+
            let idx = $t02760327678._1
1170
+
            let requiredAmountsNormalized = $t02760327678._2
1171
1171
 
            $Tuple2(fraction(amount_, lpTotalSupply, prevAssetTotalSupply), requiredAmountsNormalized)
1172
1172
 
            }
1173
-
    let lpTokensToMint = $t02652827758._1
1174
-
    let requiredAmountsNormalized = $t02652827758._2
1175
-
    let $t02776427877 = _incrementBalancesByAmounts(prevAssetBalances, requiredAmountsNormalized)
1176
-
    let assetBalances = $t02776427877._1
1177
-
    let assetTotalSupply = $t02776427877._2
1173
+
    let lpTokensToMint = $t02654427774._1
1174
+
    let requiredAmountsNormalized = $t02654427774._2
1175
+
    let $t02778027893 = _incrementBalancesByAmounts(prevAssetBalances, requiredAmountsNormalized)
1176
+
    let assetBalances = $t02778027893._1
1177
+
    let assetTotalSupply = $t02778027893._2
1178
1178
 
    let err2 = _validateLiquidityInvariant(prevAssetBalances, prevAssetTotalSupply, assetBalances, assetTotalSupply, lpTotalSupply, (lpTotalSupply + lpTokensToMint), assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1179
1179
 
    if ((err2 == err2))
1180
1180
 
        then $Tuple3(lpTokensToMint, requiredAmountsNormalized, assetBalances)
1181
1181
 
        else throw("Strict value is not equal to itself.")
1182
1182
 
    }
1183
1183
 
1184
1184
 
1185
1185
 
func _deposit (assetId_,amount_) = {
1186
1186
 
    let storage = _loadStorage()
1187
1187
 
    let lpTotalSupply = storage._3
1188
+
    let lpFeeRate = storage._4
1189
+
    let protocolFeeRate = storage._5
1188
1190
 
    let maxAllocAmplifier = storage._6
1189
1191
 
    let weightAmplifier = storage._7
1190
1192
 
    let slippageRate = storage._8
1191
1193
 
    let feeMaxRate = storage._9
1192
1194
 
    let assets = _loadAssets()
1193
-
    let $t02857228625 = _loadAssetWeights()
1194
-
    let assetWeights = $t02857228625._1
1195
-
    let sigmaWeight = $t02857228625._2
1196
-
    let $t02863028744 = _loadAssetBalances()
1197
-
    let prevAssetBalances = $t02863028744._1
1198
-
    let prevAssetTotalSupply = $t02863028744._2
1195
+
    let $t02865628709 = _loadAssetWeights()
1196
+
    let assetWeights = $t02865628709._1
1197
+
    let sigmaWeight = $t02865628709._2
1198
+
    let $t02871428828 = _loadAssetBalances()
1199
+
    let prevAssetBalances = $t02871428828._1
1200
+
    let prevAssetTotalSupply = $t02871428828._2
1199
1201
 
    let assetBalances = _incrementBalanceByIndex(prevAssetBalances, value(indexOf(assets, assetId_)), amount_)
1200
1202
 
    let assetTotalSupply = (prevAssetTotalSupply + amount_)
1201
1203
 
    let err2 = _validateAllocation(assetBalances, assetTotalSupply, prevAssetBalances, prevAssetTotalSupply, assetWeights, sigmaWeight, maxAllocAmplifier)
1202
1204
 
    if ((err2 == err2))
1203
1205
 
        then {
1204
1206
 
            let prevFee = _calculateFee(prevAssetBalances, prevAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1205
1207
 
            let fee = _calculateFee(assetBalances, assetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1206
1208
 
            let lpTokensToMint = if ((lpTotalSupply == 0))
1207
-
                then (assetTotalSupply - fee)
1209
+
                then throw("_deposit: empty pool")
1208
1210
 
                else {
1209
1211
 
                    let assetDiff = (assetTotalSupply - prevAssetTotalSupply)
1210
1212
 
                    let feeDiff = (fee - prevFee)
1211
1213
 
                    let utilityChangeFactor = fraction((assetDiff - feeDiff), RATE_FACTOR, (prevAssetTotalSupply - prevFee))
1212
1214
 
                    let lpTokensToMintInner = fraction(lpTotalSupply, utilityChangeFactor, RATE_FACTOR)
1213
1215
 
                    let err3 = _validateLiquidityInvariant(prevAssetBalances, prevAssetTotalSupply, assetBalances, assetTotalSupply, lpTotalSupply, (lpTotalSupply + lpTokensToMintInner), assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1214
1216
 
                    if ((err3 == err3))
1215
1217
 
                        then lpTokensToMintInner
1216
1218
 
                        else throw("Strict value is not equal to itself.")
1217
1219
 
                    }
1218
-
            $Tuple2(lpTokensToMint, assetBalances)
1220
+
            let $t03049030621 = _calculateLpAndProtocolFees(0, lpTokensToMint, (lpFeeRate / 2), (protocolFeeRate / 2))
1221
+
            let lpFee = $t03049030621._1
1222
+
            let protocolFee = $t03049030621._2
1223
+
            let sigmaFeePerLpUpdated = $t03049030621._3
1224
+
            $Tuple5(lpTokensToMint, assetBalances, lpFee, protocolFee, sigmaFeePerLpUpdated)
1219
1225
 
            }
1220
1226
 
        else throw("Strict value is not equal to itself.")
1221
1227
 
    }
1222
1228
 
1223
1229
 
1224
1230
 
func _withdrawAll (amount_) = {
1225
1231
 
    let storage = _loadStorage()
1226
1232
 
    let lpTotalSupply = storage._3
1227
-
    let lpFeeRate = storage._4
1228
-
    let protocolFeeRate = storage._5
1229
1233
 
    let maxAllocAmplifier = storage._6
1230
1234
 
    let weightAmplifier = storage._7
1231
1235
 
    let slippageRate = storage._8
1232
1236
 
    let feeMaxRate = storage._9
1233
-
    let $t03067130739 = _loadAssetBalances()
1234
-
    let prevAssetBalances = $t03067130739._1
1235
-
    let prevAssetTotalSupply = $t03067130739._2
1236
-
    let $t03074430797 = _loadAssetWeights()
1237
-
    let assetWeights = $t03074430797._1
1238
-
    let sigmaWeight = $t03074430797._2
1239
-
    let $t03080330919 = _calculateLpAndProtocolFees(0, amount_, lpFeeRate, protocolFeeRate)
1240
-
    let lpFee = $t03080330919._1
1241
-
    let protocolFee = $t03080330919._2
1242
-
    let sigmaFeePerLpUpdated = $t03080330919._3
1243
-
    let lpTokensToBurn = ((amount_ - lpFee) - protocolFee)
1237
+
    let $t03095531023 = _loadAssetBalances()
1238
+
    let prevAssetBalances = $t03095531023._1
1239
+
    let prevAssetTotalSupply = $t03095531023._2
1240
+
    let $t03102831081 = _loadAssetWeights()
1241
+
    let assetWeights = $t03102831081._1
1242
+
    let sigmaWeight = $t03102831081._2
1243
+
    let lpTokensToBurn = amount_
1244
1244
 
    let err = _validateInt(lpTokensToBurn, 0, MAX_INT, "_withdrawAll: lpTokensToBurn less than 0")
1245
1245
 
    if ((err == err))
1246
1246
 
        then {
1247
-
            let $t03108231215 = _decrementBalancesByLpAmount(prevAssetBalances, lpTokensToBurn, lpTotalSupply)
1248
-
            let assetBalances = $t03108231215._1
1249
-
            let assetTotalSupply = $t03108231215._2
1250
-
            let balancesToPay = $t03108231215._3
1247
+
            let $t03122331356 = _decrementBalancesByLpAmount(prevAssetBalances, lpTokensToBurn, lpTotalSupply)
1248
+
            let assetBalances = $t03122331356._1
1249
+
            let assetTotalSupply = $t03122331356._2
1250
+
            let balancesToPay = $t03122331356._3
1251
1251
 
            let err2 = _validateLiquidityInvariant(prevAssetBalances, prevAssetTotalSupply, assetBalances, assetTotalSupply, lpTotalSupply, (lpTotalSupply - lpTokensToBurn), assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1252
1252
 
            if ((err2 == err2))
1253
-
                then $Tuple6(lpTokensToBurn, balancesToPay, assetBalances, lpFee, protocolFee, sigmaFeePerLpUpdated)
1253
+
                then $Tuple3(lpTokensToBurn, balancesToPay, assetBalances)
1254
1254
 
                else throw("Strict value is not equal to itself.")
1255
1255
 
            }
1256
1256
 
        else throw("Strict value is not equal to itself.")
1257
1257
 
    }
1258
1258
 
1259
1259
 
1260
1260
 
func _withdraw (assetId_,lpAmount_) = {
1261
1261
 
    let storage = _loadStorage()
1262
1262
 
    let lpTotalSupply = storage._3
1263
1263
 
    let lpFeeRate = storage._4
1264
1264
 
    let protocolFeeRate = storage._5
1265
1265
 
    let maxAllocAmplifier = storage._6
1266
1266
 
    let weightAmplifier = storage._7
1267
1267
 
    let slippageRate = storage._8
1268
1268
 
    let feeMaxRate = storage._9
1269
1269
 
    let precision = _loadPrecision()
1270
1270
 
    let assets = _loadAssets()
1271
-
    let $t03204932117 = _loadAssetBalances()
1272
-
    let prevAssetBalances = $t03204932117._1
1273
-
    let prevAssetTotalSupply = $t03204932117._2
1274
-
    let $t03212232175 = _loadAssetWeights()
1275
-
    let assetWeights = $t03212232175._1
1276
-
    let sigmaWeight = $t03212232175._2
1271
+
    let $t03214832216 = _loadAssetBalances()
1272
+
    let prevAssetBalances = $t03214832216._1
1273
+
    let prevAssetTotalSupply = $t03214832216._2
1274
+
    let $t03222132274 = _loadAssetWeights()
1275
+
    let assetWeights = $t03222132274._1
1276
+
    let sigmaWeight = $t03222132274._2
1277
1277
 
    let targetAssetIndex = value(indexOf(assets, assetId_))
1278
1278
 
    let prevFee = _calculateFee(prevAssetBalances, prevAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1279
1279
 
    let prevUtilValue = (prevAssetTotalSupply - prevFee)
1280
1280
 
    let k = fraction(toBigInt((lpTotalSupply - lpAmount_)), PERCENT_FACTOR, toBigInt(lpTotalSupply))
1281
1281
 
    let prevUtilValueWithK = toInt(fraction(toBigInt(prevUtilValue), k, PERCENT_FACTOR))
1282
1282
 
    func foldFunc (acc,elem) =     if (acc._1)
1283
1283
 
        then acc
1284
1284
 
        else {
1285
1285
 
            let startInner = acc._2
1286
1286
 
            let stopInner = acc._3
1287
1287
 
            let currentAmount = ((stopInner + startInner) / 2)
1288
1288
 
            let tempAssetBalances = _decrementBalanceByIndex(prevAssetBalances, targetAssetIndex, currentAmount)
1289
1289
 
            let tempAssetTotalSupply = (prevAssetTotalSupply - currentAmount)
1290
1290
 
            let utilValue = (tempAssetTotalSupply - _calculateFee(tempAssetBalances, tempAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate))
1291
-
            if (if ((precision > (utilValue - prevUtilValueWithK)))
1292
-
                then ((utilValue - prevUtilValueWithK) >= 0)
1291
+
            if (if (((utilValue - prevUtilValueWithK) > (-1 * precision)))
1292
+
                then (precision > (utilValue - prevUtilValueWithK))
1293
1293
 
                else false)
1294
1294
 
                then $Tuple4(true, startInner, stopInner, currentAmount)
1295
1295
 
                else if ((0 > (utilValue - prevUtilValueWithK)))
1296
-
                    then $Tuple4(false, startInner, currentAmount, 0)
1297
-
                    else $Tuple4(false, currentAmount, stopInner, 0)
1296
+
                    then $Tuple4(false, startInner, currentAmount, currentAmount)
1297
+
                    else $Tuple4(false, currentAmount, stopInner, currentAmount)
1298
1298
 
            }
1299
1299
 
1300
1300
 
    let targetAmount = {
1301
-
        let targetAmount = lpAmount_
1302
-
        let tempAssetBalances = _decrementBalanceByIndex(prevAssetBalances, targetAssetIndex, targetAmount)
1303
-
        let tempAssetTotalSupply = (prevAssetTotalSupply - targetAmount)
1304
-
        let fee = _calculateFee(tempAssetBalances, tempAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1305
-
        let feeDiff = (fee - prevFee)
1306
-
        if ((feeDiff == 0))
1307
-
            then targetAmount
1308
-
            else {
1309
-
                let $t03414034255 = {
1310
-
                    let $l = LIST_64
1311
-
                    let $s = size($l)
1312
-
                    let $acc0 = $Tuple4(false, 0, (lpAmount_ + prevFee), 0)
1313
-
                    func $f0_1 ($a,$i) =                     if (($i >= $s))
1314
-
                        then $a
1315
-
                        else foldFunc($a, $l[$i])
1316
-
1317
-
                    func $f0_2 ($a,$i) =                     if (($i >= $s))
1318
-
                        then $a
1319
-
                        else throw("List size exceeds 64")
1320
-
1321
-
                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 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)
1322
-
                    }
1323
-
                let success = $t03414034255._1
1324
-
                let startOut = $t03414034255._2
1325
-
                let stopOut = $t03414034255._3
1326
-
                let targetAmountOut = $t03414034255._4
1327
-
                if (!(success))
1328
-
                    then throw(("_withdraw: can't calculate targetAmount=" + toString(targetAmountOut)))
1329
-
                    else targetAmountOut
1330
-
                }
1301
+
        let $t03380933924 = {
1302
+
            let $l = LIST_64
1303
+
            let $s = size($l)
1304
+
            let $acc0 = $Tuple4(false, 0, (lpAmount_ + prevFee), 0)
1305
+
            func $f0_1 ($a,$i) =             if (($i >= $s))
1306
+
                then $a
1307
+
                else foldFunc($a, $l[$i])
1308
+
1309
+
            func $f0_2 ($a,$i) =             if (($i >= $s))
1310
+
                then $a
1311
+
                else throw("List size exceeds 64")
1312
+
1313
+
            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 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)
1314
+
            }
1315
+
        let success = $t03380933924._1
1316
+
        let startOut = $t03380933924._2
1317
+
        let stopOut = $t03380933924._3
1318
+
        let targetAmountOut = $t03380933924._4
1319
+
        if (!(success))
1320
+
            then throw(("_withdraw: can't calculate targetAmount=" + toString(targetAmountOut)))
1321
+
            else targetAmountOut
1331
1322
 
        }
1332
1323
 
    let finalAssetBalances = _decrementBalanceByIndex(prevAssetBalances, targetAssetIndex, targetAmount)
1333
1324
 
    let finalAssetTotalSupply = (prevAssetTotalSupply - targetAmount)
1334
1325
 
    let err1 = if (_validateAllocation(finalAssetBalances, finalAssetTotalSupply, prevAssetBalances, prevAssetTotalSupply, assetWeights, sigmaWeight, maxAllocAmplifier))
1335
1326
 
        then _validateLiquidityInvariant(prevAssetBalances, prevAssetTotalSupply, finalAssetBalances, finalAssetTotalSupply, lpTotalSupply, (lpTotalSupply - lpAmount_), assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1336
1327
 
        else false
1337
1328
 
    if ((err1 == err1))
1338
1329
 
        then {
1339
-
            let $t03514235282 = _calculateLpAndProtocolFees((targetAssetIndex + 1), targetAmount, lpFeeRate, protocolFeeRate)
1340
-
            let lpFee = $t03514235282._1
1341
-
            let protocolFee = $t03514235282._2
1342
-
            let sigmaFeePerLpUpdated = $t03514235282._3
1330
+
            let $t03488235030 = _calculateLpAndProtocolFees((targetAssetIndex + 1), targetAmount, (lpFeeRate / 2), (protocolFeeRate / 2))
1331
+
            let lpFee = $t03488235030._1
1332
+
            let protocolFee = $t03488235030._2
1333
+
            let sigmaFeePerLpUpdated = $t03488235030._3
1343
1334
 
            $Tuple5(targetAmount, finalAssetBalances, lpFee, protocolFee, sigmaFeePerLpUpdated)
1344
1335
 
            }
1345
1336
 
        else throw("Strict value is not equal to itself.")
1346
1337
 
    }
1347
1338
 
1348
1339
 
1349
1340
 
func _swap (sourceAssetIndex_,targetAssetIndex_,sourceAmount_) = {
1350
1341
 
    let storage = _loadStorage()
1351
1342
 
    let lpAssetId = storage._1
1352
1343
 
    let lpDecimals = _getDecimals(toBase58String(lpAssetId))
1353
1344
 
    let lpTotalSupply = storage._3
1354
1345
 
    let lpFeeRate = storage._4
1355
1346
 
    let protocolFeeRate = storage._5
1356
1347
 
    let maxAllocAmplifier = storage._6
1357
1348
 
    let weightAmplifier = storage._7
1358
1349
 
    let slippageRate = storage._8
1359
1350
 
    let feeMaxRate = storage._9
1360
1351
 
    let precision = _loadPrecision()
1361
-
    let $t03586435932 = _loadAssetBalances()
1362
-
    let prevAssetBalances = $t03586435932._1
1363
-
    let prevAssetTotalSupply = $t03586435932._2
1364
-
    let $t03593735990 = _loadAssetWeights()
1365
-
    let assetWeights = $t03593735990._1
1366
-
    let sigmaWeight = $t03593735990._2
1352
+
    let $t03561235680 = _loadAssetBalances()
1353
+
    let prevAssetBalances = $t03561235680._1
1354
+
    let prevAssetTotalSupply = $t03561235680._2
1355
+
    let $t03568535738 = _loadAssetWeights()
1356
+
    let assetWeights = $t03568535738._1
1357
+
    let sigmaWeight = $t03568535738._2
1367
1358
 
    let assetBalances = _incrementBalanceByIndex(prevAssetBalances, sourceAssetIndex_, sourceAmount_)
1368
1359
 
    let assetTotalSupply = (prevAssetTotalSupply + sourceAmount_)
1369
1360
 
    let prevFee = _calculateFee(prevAssetBalances, prevAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1370
1361
 
    let prevUtilValue = (prevAssetTotalSupply - prevFee)
1371
1362
 
    func foldFunc (acc,elem) =     if (acc._1)
1372
1363
 
        then acc
1373
1364
 
        else {
1374
1365
 
            let startInner = acc._2
1375
1366
 
            let stopInner = acc._3
1376
1367
 
            let currentAmount = ((stopInner + startInner) / 2)
1377
1368
 
            let tempAssetBalances = _decrementBalanceByIndex(assetBalances, targetAssetIndex_, currentAmount)
1378
1369
 
            let tempAssetTotalSupply = (assetTotalSupply - currentAmount)
1379
1370
 
            let utilValue = (tempAssetTotalSupply - _calculateFee(tempAssetBalances, tempAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate))
1380
-
            if (if ((precision > (utilValue - prevUtilValue)))
1381
-
                then ((utilValue - prevUtilValue) >= 0)
1371
+
            if (if (((utilValue - prevUtilValue) > (-1 * precision)))
1372
+
                then (precision > (utilValue - prevUtilValue))
1382
1373
 
                else false)
1383
1374
 
                then $Tuple4(true, startInner, stopInner, currentAmount)
1384
1375
 
                else if ((0 > (utilValue - prevUtilValue)))
1385
-
                    then $Tuple4(false, startInner, currentAmount, 0)
1386
-
                    else $Tuple4(false, currentAmount, stopInner, 0)
1376
+
                    then $Tuple4(false, startInner, currentAmount, currentAmount)
1377
+
                    else $Tuple4(false, currentAmount, stopInner, currentAmount)
1387
1378
 
            }
1388
1379
 
1389
1380
 
    let targetAmount = {
1390
1381
 
        let targetAmount = sourceAmount_
1391
1382
 
        let tempAssetBalances = _decrementBalanceByIndex(assetBalances, targetAssetIndex_, targetAmount)
1392
1383
 
        let tempAssetTotalSupply = (assetTotalSupply - targetAmount)
1393
1384
 
        let fee = _calculateFee(tempAssetBalances, tempAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1394
1385
 
        let feeDiff = (fee - prevFee)
1395
1386
 
        if ((feeDiff == 0))
1396
1387
 
            then targetAmount
1397
1388
 
            else {
1398
-
                let $t03784137960 = {
1389
+
                let $t03762537744 = {
1399
1390
 
                    let $l = LIST_64
1400
1391
 
                    let $s = size($l)
1401
1392
 
                    let $acc0 = $Tuple4(false, 0, (sourceAmount_ + prevFee), 0)
1402
1393
 
                    func $f0_1 ($a,$i) =                     if (($i >= $s))
1403
1394
 
                        then $a
1404
1395
 
                        else foldFunc($a, $l[$i])
1405
1396
 
1406
1397
 
                    func $f0_2 ($a,$i) =                     if (($i >= $s))
1407
1398
 
                        then $a
1408
1399
 
                        else throw("List size exceeds 64")
1409
1400
 
1410
1401
 
                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 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)
1411
1402
 
                    }
1412
-
                let success = $t03784137960._1
1413
-
                let startOut = $t03784137960._2
1414
-
                let stopOut = $t03784137960._3
1415
-
                let targetAmountOut = $t03784137960._4
1403
+
                let success = $t03762537744._1
1404
+
                let startOut = $t03762537744._2
1405
+
                let stopOut = $t03762537744._3
1406
+
                let targetAmountOut = $t03762537744._4
1416
1407
 
                if (!(success))
1417
1408
 
                    then throw(("_swap: can't calculate targetAmount=" + toString(targetAmountOut)))
1418
1409
 
                    else targetAmountOut
1419
1410
 
                }
1420
1411
 
        }
1421
1412
 
    let finalAssetBalances = _decrementBalanceByIndex(assetBalances, targetAssetIndex_, targetAmount)
1422
1413
 
    let finalAssetTotalSupply = (assetTotalSupply - targetAmount)
1423
1414
 
    let err1 = if (_validateAllocation(finalAssetBalances, finalAssetTotalSupply, prevAssetBalances, prevAssetTotalSupply, assetWeights, sigmaWeight, maxAllocAmplifier))
1424
1415
 
        then _validateSwapInvariant(prevAssetBalances, prevAssetTotalSupply, finalAssetBalances, finalAssetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1425
1416
 
        else false
1426
1417
 
    if ((err1 == err1))
1427
1418
 
        then {
1428
-
            let $t03877338914 = _calculateLpAndProtocolFees((targetAssetIndex_ + 1), targetAmount, lpFeeRate, protocolFeeRate)
1429
-
            let lpFee = $t03877338914._1
1430
-
            let protocolFee = $t03877338914._2
1431
-
            let sigmaFeePerLpUpdated = $t03877338914._3
1419
+
            let $t03855738698 = _calculateLpAndProtocolFees((targetAssetIndex_ + 1), targetAmount, lpFeeRate, protocolFeeRate)
1420
+
            let lpFee = $t03855738698._1
1421
+
            let protocolFee = $t03855738698._2
1422
+
            let sigmaFeePerLpUpdated = $t03855738698._3
1432
1423
 
            $Tuple5(targetAmount, finalAssetBalances, lpFee, protocolFee, sigmaFeePerLpUpdated)
1433
1424
 
            }
1434
1425
 
        else throw("Strict value is not equal to itself.")
1435
1426
 
    }
1436
1427
 
1437
1428
 
1438
1429
 
@Callable(i)
1439
-
func init (assets_,assetWeights_,lpFeeRate_,protocolFeeRate_,lpTokenName_,lpTokenDescr_,lpTokenDecimals_,maxAllocationAmplifier_,weightAmplifier_,slippageRate_,feeMaxRate_,protocolFeeContract_,precision_) = {
1440
-
    let err = if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (_onlyThisContract(i.caller))
1430
+
func init (assets_,assetWeights_,lpFeeRate_,protocolFeeRate_,lpTokenName_,lpTokenDescr_,lpTokenDecimals_,maxAllocationAmplifier_,weightAmplifier_,slippageRate_,feeMaxRate_,protocolFeeContract_,precision_,pauser_) = {
1431
+
    let err = if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (if (_onlyThisContract(i.caller))
1441
1432
 
        then _whenNotInitialized()
1442
1433
 
        else false)
1443
1434
 
        then _whenMultisigSet()
1444
1435
 
        else false)
1445
1436
 
        then _validateAssets(assets_, "init: invalid assets")
1446
1437
 
        else false)
1447
-
        then _validateIntList(assetWeights_, 0, MAX_WEIGHT, "init: invalid assetWeights")
1438
+
        then _validateIntList(assetWeights_, 1, MAX_WEIGHT, "init: invalid assetWeights")
1448
1439
 
        else false)
1449
1440
 
        then _validateIntEquals(size(assets_), size(assetWeights_), "init: invalid assetWeights size")
1450
1441
 
        else false)
1451
1442
 
        then _validateInt(lpFeeRate_, 0, MAX_FEE, "init: invalid lp fee")
1452
1443
 
        else false)
1453
1444
 
        then _validateInt(protocolFeeRate_, 0, MAX_FEE, "init: invalid protocol fee")
1454
1445
 
        else false)
1455
1446
 
        then _validateTokenName(lpTokenName_, "init: invalid name")
1456
1447
 
        else false)
1457
1448
 
        then _validateTokenDescr(lpTokenDescr_, "init: invalid descr")
1458
1449
 
        else false)
1459
1450
 
        then _validateDecimals(lpTokenDecimals_, "init: invalid decimals")
1460
1451
 
        else false)
1461
1452
 
        then _validateInt(maxAllocationAmplifier_, 0, MAX_AMPLIFIER, "init: invalid maxAllocationAmplifier")
1462
1453
 
        else false)
1463
1454
 
        then _validateInt(weightAmplifier_, 0, maxAllocationAmplifier_, "init: invalid weightAmplifier")
1464
1455
 
        else false)
1465
1456
 
        then _validateInt(slippageRate_, 0, MAX_INT, "init: invalid slippageRate")
1466
1457
 
        else false)
1467
1458
 
        then _validateInt(feeMaxRate_, 0, MAX_INT, "init: invalid feeMaxRate")
1468
1459
 
        else false)
1469
1460
 
        then _validateAddress(protocolFeeContract_, "init: invalid protocolFeeContract")
1470
1461
 
        else false)
1471
-
        then _validateInt(precision_, 0, MAX_INT, "init: invalid precision")
1462
+
        then _validateInt(precision_, 1, MAX_INT, "init: invalid precision")
1463
+
        else false)
1464
+
        then _validateAddress(pauser_, "init: invalid pauser")
1472
1465
 
        else false
1473
1466
 
    if ((err == err))
1474
1467
 
        then {
1475
-
            let $t04069540764 = _prepareAssetWeights(assetWeights_)
1476
-
            let assetWeights = $t04069540764._1
1477
-
            let sigmaWeight = $t04069540764._2
1468
+
            let $t04056140630 = _prepareAssetWeights(assetWeights_)
1469
+
            let assetWeights = $t04056140630._1
1470
+
            let sigmaWeight = $t04056140630._2
1478
1471
 
            let assetBalances = _prepareAssetBalances(assets_)
1479
1472
 
            let issue = Issue(lpTokenName_, lpTokenDescr_, 0, lpTokenDecimals_, true)
1480
1473
 
            let lpAssetId = calculateAssetId(issue)
1481
1474
 
            let storageUpdated = $Tuple10(lpAssetId, true, 0, lpFeeRate_, protocolFeeRate_, maxAllocationAmplifier_, weightAmplifier_, slippageRate_, feeMaxRate_, addressFromStringValue(protocolFeeContract_))
1482
-
            $Tuple2((((((([issue] ++ _saveStorage(storageUpdated)) ++ _saveAssets(assets_)) ++ _saveAssetBalances(assetBalances)) ++ _saveAssetWeights(assetWeights)) ++ _savePrecision(precision_)) ++ _saveSigmaFeePerLp(_loadSigmaFeePerLp())), unit)
1475
+
            $Tuple2(((((((([issue] ++ _saveStorage(storageUpdated)) ++ _saveAssets(assets_)) ++ _saveAssetBalances(assetBalances)) ++ _saveAssetWeights(assetWeights)) ++ _savePrecision(precision_)) ++ _saveSigmaFeePerLp(_loadSigmaFeePerLp())) ++ _savePauser(addressFromStringValue(pauser_))), unit)
1483
1476
 
            }
1484
1477
 
        else throw("Strict value is not equal to itself.")
1485
1478
 
    }
1486
1479
 
1487
1480
 
1488
1481
 
1489
1482
 
@Callable(i)
1490
1483
 
func depositAll (amount_) = {
1491
1484
 
    let err = if (if (_whenInitialized())
1492
1485
 
        then _whenNotPaused()
1493
1486
 
        else false)
1494
1487
 
        then _validateInt(amount_, 0, MAX_INT, "depositAll: invalid amount")
1495
1488
 
        else false
1496
1489
 
    if ((err == err))
1497
1490
 
        then {
1498
1491
 
            let storage = _loadStorage()
1499
1492
 
            let lpAssetId = storage._1
1500
1493
 
            let lpDecimals = _getDecimals(toBase58String(lpAssetId))
1501
1494
 
            let assets = _loadAssets()
1502
-
            let $t04245742542 = _depositAll(amount_)
1503
-
            let lpTokensToMint = $t04245742542._1
1504
-
            let requiredAmountsNormalized = $t04245742542._2
1505
-
            let assetBalances = $t04245742542._3
1495
+
            let $t04238042465 = _depositAll(amount_)
1496
+
            let lpTokensToMint = $t04238042465._1
1497
+
            let requiredAmountsNormalized = $t04238042465._2
1498
+
            let assetBalances = $t04238042465._3
1506
1499
 
            func foldFunc (acc,elem) =             {
1507
1500
 
                let index = acc._1
1508
1501
 
                let paymentAssetStr = _assetToStr(i.payments[index].assetId)
1509
1502
 
                let paymentAssetDecimals = _getDecimals(paymentAssetStr)
1510
1503
 
                let requiredAmountNormalized = requiredAmountsNormalized[index]
1511
1504
 
                let requiredAmount = _normalizeDecimals(requiredAmountNormalized, lpDecimals, paymentAssetDecimals, CEILING)
1512
1505
 
                let err1 = if ((paymentAssetStr != elem))
1513
1506
 
                    then throw(("depositAll: invalid payment: index=" + toString(index)))
1514
1507
 
                    else if ((0 >= requiredAmount))
1515
1508
 
                        then throw("depositAll: too little amount required")
1516
1509
 
                        else unit
1517
1510
 
                if ((err1 == err1))
1518
1511
 
                    then {
1519
1512
 
                        let change = if ((i.payments[index].amount > requiredAmount))
1520
1513
 
                            then [ScriptTransfer(i.caller, (i.payments[index].amount - requiredAmount), i.payments[index].assetId)]
1521
1514
 
                            else if ((requiredAmount > i.payments[index].amount))
1522
1515
 
                                then throw(((("depositAll: insufficient payment, index=" + toString(index)) + ", required=") + toString(requiredAmount)))
1523
1516
 
                                else nil
1524
1517
 
                        $Tuple2((index + 1), (acc._2 ++ change))
1525
1518
 
                        }
1526
1519
 
                    else throw("Strict value is not equal to itself.")
1527
1520
 
                }
1528
1521
 
1529
-
            let $t04368543747 = {
1522
+
            let $t04360843670 = {
1530
1523
 
                let $l = assets
1531
1524
 
                let $s = size($l)
1532
1525
 
                let $acc0 = $Tuple2(0, nil)
1533
1526
 
                func $f0_1 ($a,$i) =                 if (($i >= $s))
1534
1527
 
                    then $a
1535
1528
 
                    else foldFunc($a, $l[$i])
1536
1529
 
1537
1530
 
                func $f0_2 ($a,$i) =                 if (($i >= $s))
1538
1531
 
                    then $a
1539
1532
 
                    else throw("List size exceeds 10")
1540
1533
 
1541
1534
 
                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1542
1535
 
                }
1543
-
            let idx = $t04368543747._1
1544
-
            let changeActions = $t04368543747._2
1536
+
            let idx = $t04360843670._1
1537
+
            let changeActions = $t04360843670._2
1545
1538
 
            let storageUpdated = $Tuple10(storage._1, storage._2, (storage._3 + lpTokensToMint), storage._4, storage._5, storage._6, storage._7, storage._8, storage._9, storage._10)
1546
1539
 
            $Tuple2(((([Reissue(lpAssetId, lpTokensToMint, true), ScriptTransfer(i.caller, lpTokensToMint, lpAssetId)] ++ _saveStorage(storageUpdated)) ++ _saveAssetBalances(assetBalances)) ++ changeActions), unit)
1547
1540
 
            }
1548
1541
 
        else throw("Strict value is not equal to itself.")
1549
1542
 
    }
1550
1543
 
1551
1544
 
1552
1545
 
1553
1546
 
@Callable(i)
1554
1547
 
func deposit (minLpAmount_) = {
1555
1548
 
    let err = _validateInt(minLpAmount_, 0, MAX_INT, "deposit: invalid min lp amount")
1556
1549
 
    if ((err == err))
1557
1550
 
        then {
1558
1551
 
            let storage = _loadStorage()
1559
1552
 
            let lpAssetId = storage._1
1560
-
            let lpDecimals = _getDecimals(toBase58String(lpAssetId))
1553
+
            let lpAssetIdStr = _assetToStr(lpAssetId)
1554
+
            let lpDecimals = _getDecimals(lpAssetIdStr)
1561
1555
 
            let err1 = if (if (if (if (_whenInitialized())
1562
1556
 
                then _whenNotPaused()
1563
1557
 
                else false)
1564
1558
 
                then _validateIntEquals(size(i.payments), 1, "deposit: invalid payments size")
1565
1559
 
                else false)
1566
1560
 
                then _validateListContains(_loadAssets(), _assetToStr(i.payments[0].assetId), "deposit: invalid payment asset")
1567
1561
 
                else false)
1568
-
                then _validateInt(i.payments[0].amount, 0, MAX_INT, "deposit: invalid payment amount")
1562
+
                then _validateInt(i.payments[0].amount, 1, MAX_INT, "deposit: invalid payment amount")
1569
1563
 
                else false
1570
1564
 
            if ((err1 == err1))
1571
1565
 
                then {
1572
1566
 
                    let assetStr = _assetToStr(i.payments[0].assetId)
1573
1567
 
                    let assetDecimals = _getDecimals(assetStr)
1574
1568
 
                    let amountNormalized = _normalizeDecimals(i.payments[0].amount, assetDecimals, lpDecimals, DOWN)
1575
-
                    let $t04512645200 = _deposit(assetStr, amountNormalized)
1576
-
                    let lpTokensToMint = $t04512645200._1
1577
-
                    let assetBalances = $t04512645200._2
1578
-
                    let err2 = _validateInt(lpTokensToMint, minLpAmount_, MAX_INT, "deposit: less than min lp")
1569
+
                    let $t04508245198 = _deposit(assetStr, amountNormalized)
1570
+
                    let lpTokensToMint = $t04508245198._1
1571
+
                    let assetBalances = $t04508245198._2
1572
+
                    let lpFee = $t04508245198._3
1573
+
                    let protocolFee = $t04508245198._4
1574
+
                    let sigmaFeePerLpUpdated = $t04508245198._5
1575
+
                    let lpTokensToSend = ((lpTokensToMint - lpFee) - protocolFee)
1576
+
                    let err2 = _validateInt(lpTokensToSend, minLpAmount_, MAX_INT, "deposit: less than min")
1579
1577
 
                    if ((err2 == err2))
1580
1578
 
                        then {
1581
1579
 
                            let storageUpdated = $Tuple10(storage._1, storage._2, (storage._3 + lpTokensToMint), storage._4, storage._5, storage._6, storage._7, storage._8, storage._9, storage._10)
1582
-
                            $Tuple2((([Reissue(lpAssetId, lpTokensToMint, true), ScriptTransfer(i.caller, lpTokensToMint, lpAssetId)] ++ _saveStorage(storageUpdated)) ++ _saveAssetBalances(assetBalances)), unit)
1580
+
                            $Tuple2(((((([Reissue(lpAssetId, lpTokensToMint, true), ScriptTransfer(i.caller, lpTokensToSend, lpAssetId)] ++ _saveStorage(storageUpdated)) ++ _saveAssetBalances(assetBalances)) ++ _saveLpFee(lpAssetIdStr, (lpFee + _loadLpFee(lpAssetIdStr)))) ++ _saveProtocolFee(lpAssetIdStr, (protocolFee + _loadProtocolFee(lpAssetIdStr)))) ++ _saveSigmaFeePerLp(sigmaFeePerLpUpdated)), unit)
1583
1581
 
                            }
1584
1582
 
                        else throw("Strict value is not equal to itself.")
1585
1583
 
                    }
1586
1584
 
                else throw("Strict value is not equal to itself.")
1587
1585
 
            }
1588
1586
 
        else throw("Strict value is not equal to itself.")
1589
1587
 
    }
1590
1588
 
1591
1589
 
1592
1590
 
1593
1591
 
@Callable(i)
1594
1592
 
func withdrawAll () = {
1595
1593
 
    let storage = _loadStorage()
1596
1594
 
    let lpAssetId = storage._1
1597
1595
 
    let lpAssetIdStr = toBase58String(lpAssetId)
1598
1596
 
    let lpDecimals = _getDecimals(lpAssetIdStr)
1599
1597
 
    let assets = _loadAssets()
1600
1598
 
    let err = if (if (if (if (_whenInitialized())
1601
1599
 
        then _whenNotPaused()
1602
1600
 
        else false)
1603
1601
 
        then _validateIntEquals(size(i.payments), 1, "withdrawAll: invalid payments size")
1604
1602
 
        else false)
1605
1603
 
        then _validateStringEqual(lpAssetIdStr, _assetToStr(i.payments[0].assetId), "withdrawAll: invalid payment asset")
1606
1604
 
        else false)
1607
-
        then _validateInt(i.payments[0].amount, 0, MAX_INT, "withdrawAll: invalid payment amount")
1605
+
        then _validateInt(i.payments[0].amount, 1, MAX_INT, "withdrawAll: invalid payment amount")
1608
1606
 
        else false
1609
1607
 
    if ((err == err))
1610
1608
 
        then {
1611
-
            let $t04642146550 = _withdrawAll(i.payments[0].amount)
1612
-
            let lpTokensToBurn = $t04642146550._1
1613
-
            let balancesToPay = $t04642146550._2
1614
-
            let assetBalances = $t04642146550._3
1615
-
            let lpFee = $t04642146550._4
1616
-
            let protocolFee = $t04642146550._5
1617
-
            let sigmaFeePerLpUpdated = $t04642146550._6
1609
+
            let $t04668746774 = _withdrawAll(i.payments[0].amount)
1610
+
            let lpTokensToBurn = $t04668746774._1
1611
+
            let balancesToPay = $t04668746774._2
1612
+
            let assetBalances = $t04668746774._3
1618
1613
 
            let paymentActions = _getPaymentsFromBalances(assets, balancesToPay, i.caller, lpDecimals)
1619
1614
 
            let storageUpdated = $Tuple10(storage._1, storage._2, (storage._3 - lpTokensToBurn), storage._4, storage._5, storage._6, storage._7, storage._8, storage._9, storage._10)
1620
-
            $Tuple2((((((([Burn(lpAssetId, lpTokensToBurn)] ++ paymentActions) ++ _saveStorage(storageUpdated)) ++ _saveAssetBalances(assetBalances)) ++ _saveLpFee(lpAssetIdStr, (lpFee + _loadLpFee(lpAssetIdStr)))) ++ _saveProtocolFee(lpAssetIdStr, (protocolFee + _loadProtocolFee(lpAssetIdStr)))) ++ _saveSigmaFeePerLp(sigmaFeePerLpUpdated)), unit)
1615
+
            $Tuple2(((([Burn(lpAssetId, lpTokensToBurn)] ++ paymentActions) ++ _saveStorage(storageUpdated)) ++ _saveAssetBalances(assetBalances)), unit)
1621
1616
 
            }
1622
1617
 
        else throw("Strict value is not equal to itself.")
1623
1618
 
    }
1624
1619
 
1625
1620
 
1626
1621
 
1627
1622
 
@Callable(i)
1628
1623
 
func withdraw (assetId_,minAmount_) = {
1629
1624
 
    let storage = _loadStorage()
1630
1625
 
    let lpAssetId = storage._1
1631
1626
 
    let lpAssetIdStr = toBase58String(lpAssetId)
1632
1627
 
    let lpDecimals = _getDecimals(lpAssetIdStr)
1633
1628
 
    let assets = _loadAssets()
1634
1629
 
    let err = if (if (if (if (if (if (_whenInitialized())
1635
1630
 
        then _whenNotPaused()
1636
1631
 
        else false)
1637
1632
 
        then _validateIntEquals(size(i.payments), 1, "withdraw: invalid payments size")
1638
1633
 
        else false)
1639
1634
 
        then _validateStringEqual(lpAssetIdStr, _assetToStr(i.payments[0].assetId), "withdraw: invalid payment asset")
1640
1635
 
        else false)
1641
-
        then _validateInt(i.payments[0].amount, 0, MAX_INT, "withdraw: invalid payment amount")
1636
+
        then _validateInt(i.payments[0].amount, 1, MAX_INT, "withdraw: invalid payment amount")
1642
1637
 
        else false)
1643
1638
 
        then _validateListContains(assets, assetId_, "withdraw: invalid assetId")
1644
1639
 
        else false)
1645
1640
 
        then _validateInt(minAmount_, 0, MAX_INT, "withdraw: invalid minAmount")
1646
1641
 
        else false
1647
1642
 
    if ((err == err))
1648
1643
 
        then {
1649
-
            let $t04808648220 = _withdraw(assetId_, i.payments[0].amount)
1650
-
            let targetAmountNormalized = $t04808648220._1
1651
-
            let finalAssetBalances = $t04808648220._2
1652
-
            let lpFee = $t04808648220._3
1653
-
            let protocolFee = $t04808648220._4
1654
-
            let sigmaFeePerLpUpdated = $t04808648220._5
1644
+
            let $t04810048234 = _withdraw(assetId_, i.payments[0].amount)
1645
+
            let targetAmountNormalized = $t04810048234._1
1646
+
            let finalAssetBalances = $t04810048234._2
1647
+
            let lpFee = $t04810048234._3
1648
+
            let protocolFee = $t04810048234._4
1649
+
            let sigmaFeePerLpUpdated = $t04810048234._5
1655
1650
 
            let finalAmountNormalized = ((targetAmountNormalized - lpFee) - protocolFee)
1656
1651
 
            let targetDecimals = _getDecimals(assetId_)
1657
1652
 
            let finalAmount = _normalizeDecimals(finalAmountNormalized, lpDecimals, targetDecimals, DOWN)
1658
-
            let err1 = _validateInt(finalAmount, minAmount_, MAX_INT, "withdraw: insufficient final amount")
1653
+
            let err1 = _validateInt(finalAmount, minAmount_, MAX_INT, "withdraw: less than min")
1659
1654
 
            if ((err1 == err1))
1660
1655
 
                then {
1661
1656
 
                    let storageUpdated = $Tuple10(storage._1, storage._2, (storage._3 - i.payments[0].amount), storage._4, storage._5, storage._6, storage._7, storage._8, storage._9, storage._10)
1662
1657
 
                    $Tuple2(((((([Burn(lpAssetId, i.payments[0].amount), ScriptTransfer(i.caller, finalAmount, _strToAsset(assetId_))] ++ _saveStorage(storageUpdated)) ++ _saveAssetBalances(finalAssetBalances)) ++ _saveLpFee(assetId_, (lpFee + _loadLpFee(assetId_)))) ++ _saveProtocolFee(assetId_, (protocolFee + _loadProtocolFee(assetId_)))) ++ _saveSigmaFeePerLp(sigmaFeePerLpUpdated)), unit)
1663
1658
 
                    }
1664
1659
 
                else throw("Strict value is not equal to itself.")
1665
1660
 
            }
1666
1661
 
        else throw("Strict value is not equal to itself.")
1667
1662
 
    }
1668
1663
 
1669
1664
 
1670
1665
 
1671
1666
 
@Callable(i)
1672
1667
 
func swap (targetAssetId_,minAmount_) = {
1673
1668
 
    let storage = _loadStorage()
1674
1669
 
    let lpAssetId = storage._1
1675
1670
 
    let lpDecimals = _getDecimals(toBase58String(lpAssetId))
1676
1671
 
    let assets = _loadAssets()
1677
1672
 
    let sourceAssetStr = _assetToStr(i.payments[0].assetId)
1678
1673
 
    let sourceAmountNormalized = _normalizeDecimals(i.payments[0].amount, _getDecimals(sourceAssetStr), lpDecimals, DOWN)
1679
1674
 
    let sourceAssetIndex = valueOrErrorMessage(indexOf(assets, sourceAssetStr), "swap: invalid source asset")
1680
1675
 
    if ((sourceAssetIndex == sourceAssetIndex))
1681
1676
 
        then {
1682
1677
 
            let targetAssetIndex = valueOrErrorMessage(indexOf(assets, targetAssetId_), "swap: invalid target asset")
1683
1678
 
            if ((targetAssetIndex == targetAssetIndex))
1684
1679
 
                then {
1685
1680
 
                    let err = if (if (if (if (if (_whenInitialized())
1686
1681
 
                        then _whenNotPaused()
1687
1682
 
                        else false)
1688
1683
 
                        then _validateInt(minAmount_, 0, MAX_INT, "swap: invalid min target amount")
1689
1684
 
                        else false)
1690
-
                        then _validateInt(sourceAmountNormalized, 0, MAX_INT, "swap: invalid source amount")
1685
+
                        then _validateInt(sourceAmountNormalized, 1, MAX_INT, "swap: invalid source amount")
1691
1686
 
                        else false)
1692
1687
 
                        then _validateStringNotEq(sourceAssetStr, targetAssetId_, "swap: same assets")
1693
1688
 
                        else false)
1694
1689
 
                        then _validateIntEquals(size(i.payments), 1, "swap: invalid payments size")
1695
1690
 
                        else false
1696
1691
 
                    if ((err == err))
1697
1692
 
                        then {
1698
-
                            let $t05031750475 = _swap(sourceAssetIndex, targetAssetIndex, sourceAmountNormalized)
1699
-
                            let targetAmountNormalized = $t05031750475._1
1700
-
                            let finalAssetBalances = $t05031750475._2
1701
-
                            let lpFee = $t05031750475._3
1702
-
                            let protocolFee = $t05031750475._4
1703
-
                            let sigmaFeePerLpUpdated = $t05031750475._5
1693
+
                            let $t05031950477 = _swap(sourceAssetIndex, targetAssetIndex, sourceAmountNormalized)
1694
+
                            let targetAmountNormalized = $t05031950477._1
1695
+
                            let finalAssetBalances = $t05031950477._2
1696
+
                            let lpFee = $t05031950477._3
1697
+
                            let protocolFee = $t05031950477._4
1698
+
                            let sigmaFeePerLpUpdated = $t05031950477._5
1704
1699
 
                            let finalAmountNormalized = ((targetAmountNormalized - lpFee) - protocolFee)
1705
1700
 
                            let targetDecimals = _getDecimals(targetAssetId_)
1706
1701
 
                            let finalAmount = _normalizeDecimals(finalAmountNormalized, lpDecimals, targetDecimals, DOWN)
1707
-
                            let err1 = _validateInt(finalAmount, minAmount_, MAX_INT, "swap: insufficient final amount")
1702
+
                            let err1 = _validateInt(finalAmount, minAmount_, MAX_INT, "swap: less than min")
1708
1703
 
                            if ((err1 == err1))
1709
1704
 
                                then $Tuple2((((([ScriptTransfer(i.caller, finalAmount, _strToAsset(targetAssetId_))] ++ _saveAssetBalances(finalAssetBalances)) ++ _saveLpFee(targetAssetId_, (lpFee + _loadLpFee(targetAssetId_)))) ++ _saveProtocolFee(targetAssetId_, (protocolFee + _loadProtocolFee(targetAssetId_)))) ++ _saveSigmaFeePerLp(sigmaFeePerLpUpdated)), unit)
1710
1705
 
                                else throw("Strict value is not equal to itself.")
1711
1706
 
                            }
1712
1707
 
                        else throw("Strict value is not equal to itself.")
1713
1708
 
                    }
1714
1709
 
                else throw("Strict value is not equal to itself.")
1715
1710
 
            }
1716
1711
 
        else throw("Strict value is not equal to itself.")
1717
1712
 
    }
1718
1713
 
1719
1714
 
1720
1715
 
1721
1716
 
@Callable(i)
1722
1717
 
func getDepositAll (lpAmount_) = {
1723
-
    let err = _validateInt(lpAmount_, 0, MAX_INT, "getDepositAll: invalid amount")
1718
+
    let err = _validateInt(lpAmount_, 1, MAX_INT, "getDepositAll: invalid amount")
1724
1719
 
    if ((err == err))
1725
1720
 
        then {
1726
-
            let $t05160751694 = _depositAll(lpAmount_)
1727
-
            let lpTokensToMint = $t05160751694._1
1728
-
            let requiredAmountsNormalized = $t05160751694._2
1729
-
            let assetBalances = $t05160751694._3
1721
+
            let $t05159751684 = _depositAll(lpAmount_)
1722
+
            let lpTokensToMint = $t05159751684._1
1723
+
            let requiredAmountsNormalized = $t05159751684._2
1724
+
            let assetBalances = $t05159751684._3
1730
1725
 
            $Tuple2(nil, $Tuple2(lpTokensToMint, requiredAmountsNormalized))
1731
1726
 
            }
1732
1727
 
        else throw("Strict value is not equal to itself.")
1733
1728
 
    }
1734
1729
 
1735
1730
 
1736
1731
 
1737
1732
 
@Callable(i)
1738
1733
 
func getDeposit (assetId_,amount_) = {
1739
1734
 
    let err = if (_validateListContains(_loadAssets(), assetId_, "getDeposit: invalid asset"))
1740
-
        then _validateInt(amount_, 0, MAX_INT, "getDeposit: invalid amount")
1735
+
        then _validateInt(amount_, 1, MAX_INT, "getDeposit: invalid amount")
1741
1736
 
        else false
1742
1737
 
    if ((err == err))
1743
1738
 
        then {
1744
1739
 
            let storage = _loadStorage()
1745
1740
 
            let lpAssetId = storage._1
1746
1741
 
            let lpDecimals = _getDecimals(toBase58String(lpAssetId))
1747
1742
 
            let assetDecimals = _getDecimals(assetId_)
1748
1743
 
            let amountNormalized = _normalizeDecimals(amount_, assetDecimals, lpDecimals, DOWN)
1749
-
            let $t05245352527 = _deposit(assetId_, amountNormalized)
1750
-
            let lpTokensToMint = $t05245352527._1
1751
-
            let assetBalances = $t05245352527._2
1752
-
            $Tuple2(nil, lpTokensToMint)
1744
+
            let $t05244352559 = _deposit(assetId_, amountNormalized)
1745
+
            let lpTokensToMint = $t05244352559._1
1746
+
            let assetBalances = $t05244352559._2
1747
+
            let lpFee = $t05244352559._3
1748
+
            let protocolFee = $t05244352559._4
1749
+
            let sigmaFeePerLpUpdated = $t05244352559._5
1750
+
            let lpTokensToSend = ((lpTokensToMint - lpFee) - protocolFee)
1751
+
            $Tuple2(nil, lpTokensToSend)
1753
1752
 
            }
1754
1753
 
        else throw("Strict value is not equal to itself.")
1755
1754
 
    }
1756
1755
 
1757
1756
 
1758
1757
 
1759
1758
 
@Callable(i)
1760
1759
 
func getWithdrawAll (lpAmount_) = {
1761
1760
 
    let err = _validateInt(lpAmount_, 0, MAX_INT, "getWithdrawAll: invalid amount")
1762
1761
 
    if ((err == err))
1763
1762
 
        then {
1764
-
            let $t05290453022 = _withdrawAll(lpAmount_)
1765
-
            let lpTokensToBurn = $t05290453022._1
1766
-
            let balancesToGet = $t05290453022._2
1767
-
            let assetBalances = $t05290453022._3
1768
-
            let lpFee = $t05290453022._4
1769
-
            let protocolFee = $t05290453022._5
1770
-
            let sigmaFeePerLpUpdated = $t05290453022._6
1763
+
            let $t05299853074 = _withdrawAll(lpAmount_)
1764
+
            let lpTokensToBurn = $t05299853074._1
1765
+
            let balancesToGet = $t05299853074._2
1766
+
            let assetBalances = $t05299853074._3
1771
1767
 
            $Tuple2(nil, balancesToGet)
1772
1768
 
            }
1773
1769
 
        else throw("Strict value is not equal to itself.")
1774
1770
 
    }
1775
1771
 
1776
1772
 
1777
1773
 
1778
1774
 
@Callable(i)
1779
1775
 
func getWithdraw (assetId_,amount_) = {
1780
1776
 
    let err = if (_validateListContains(_loadAssets(), assetId_, "getWithdraw: invalid asset"))
1781
-
        then _validateInt(amount_, 0, MAX_INT, "getWithdraw: invalid amount")
1777
+
        then _validateInt(amount_, 1, MAX_INT, "getWithdraw: invalid amount")
1782
1778
 
        else false
1783
1779
 
    if ((err == err))
1784
1780
 
        then {
1785
1781
 
            let storage = _loadStorage()
1786
1782
 
            let lpAssetId = storage._1
1787
1783
 
            let lpDecimals = _getDecimals(toBase58String(lpAssetId))
1788
-
            let $t05367353789 = _withdraw(assetId_, amount_)
1789
-
            let targetAmountNormalized = $t05367353789._1
1790
-
            let assetBalances = $t05367353789._2
1791
-
            let lpFee = $t05367353789._3
1792
-
            let protocolFee = $t05367353789._4
1793
-
            let sigmaFeePerLpUpdated = $t05367353789._5
1784
+
            let $t05372553841 = _withdraw(assetId_, amount_)
1785
+
            let targetAmountNormalized = $t05372553841._1
1786
+
            let assetBalances = $t05372553841._2
1787
+
            let lpFee = $t05372553841._3
1788
+
            let protocolFee = $t05372553841._4
1789
+
            let sigmaFeePerLpUpdated = $t05372553841._5
1794
1790
 
            let finalAmountNormalized = ((targetAmountNormalized - lpFee) - protocolFee)
1795
1791
 
            let targetDecimals = _getDecimals(assetId_)
1796
1792
 
            let finalAmount = _normalizeDecimals(finalAmountNormalized, lpDecimals, targetDecimals, DOWN)
1797
1793
 
            $Tuple2(nil, finalAmount)
1798
1794
 
            }
1799
1795
 
        else throw("Strict value is not equal to itself.")
1800
1796
 
    }
1801
1797
 
1802
1798
 
1803
1799
 
1804
1800
 
@Callable(i)
1805
1801
 
func getSwap (sourceAssetId_,targetAssetId_,sourceAmount_) = {
1806
1802
 
    let storage = _loadStorage()
1807
1803
 
    let lpAssetId = storage._1
1808
1804
 
    let lpDecimals = _getDecimals(toBase58String(lpAssetId))
1809
1805
 
    let assets = _loadAssets()
1810
1806
 
    let sourceAssetIndex = valueOrErrorMessage(indexOf(assets, sourceAssetId_), "swap: invalid source asset")
1811
1807
 
    if ((sourceAssetIndex == sourceAssetIndex))
1812
1808
 
        then {
1813
1809
 
            let targetAssetIndex = valueOrErrorMessage(indexOf(assets, targetAssetId_), "swap: invalid target asset")
1814
1810
 
            if ((targetAssetIndex == targetAssetIndex))
1815
1811
 
                then {
1816
1812
 
                    let sourceAmountNormalized = _normalizeDecimals(sourceAmount_, _getDecimals(sourceAssetId_), lpDecimals, DOWN)
1817
-
                    let err = if (_validateInt(sourceAmountNormalized, 0, MAX_INT, "swap: invalid source amount"))
1813
+
                    let err = if (_validateInt(sourceAmountNormalized, 1, MAX_INT, "swap: invalid source amount"))
1818
1814
 
                        then _validateStringNotEq(sourceAssetId_, targetAssetId_, "swap: same assets")
1819
1815
 
                        else false
1820
1816
 
                    if ((err == err))
1821
1817
 
                        then {
1822
-
                            let $t05520355361 = _swap(sourceAssetIndex, targetAssetIndex, sourceAmountNormalized)
1823
-
                            let targetAmountNormalized = $t05520355361._1
1824
-
                            let finalAssetBalances = $t05520355361._2
1825
-
                            let lpFee = $t05520355361._3
1826
-
                            let protocolFee = $t05520355361._4
1827
-
                            let sigmaFeePerLpUpdated = $t05520355361._5
1818
+
                            let $t05525555413 = _swap(sourceAssetIndex, targetAssetIndex, sourceAmountNormalized)
1819
+
                            let targetAmountNormalized = $t05525555413._1
1820
+
                            let finalAssetBalances = $t05525555413._2
1821
+
                            let lpFee = $t05525555413._3
1822
+
                            let protocolFee = $t05525555413._4
1823
+
                            let sigmaFeePerLpUpdated = $t05525555413._5
1828
1824
 
                            let finalAmountNormalized = ((targetAmountNormalized - lpFee) - protocolFee)
1829
1825
 
                            let targetDecimals = _getDecimals(targetAssetId_)
1830
1826
 
                            let finalAmount = _normalizeDecimals(finalAmountNormalized, lpDecimals, targetDecimals, DOWN)
1831
1827
 
                            $Tuple2(nil, finalAmount)
1832
1828
 
                            }
1833
1829
 
                        else throw("Strict value is not equal to itself.")
1834
1830
 
                    }
1835
1831
 
                else throw("Strict value is not equal to itself.")
1836
1832
 
            }
1837
1833
 
        else throw("Strict value is not equal to itself.")
1838
1834
 
    }
1839
1835
 
1840
1836
 
1841
1837
 
1842
1838
 
@Callable(i)
1843
1839
 
func getClaim (user_) = {
1844
1840
 
    let user = if ((size(user_) > 0))
1845
1841
 
        then valueOrErrorMessage(addressFromString(user_), "getClaim: invalid user")
1846
1842
 
        else i.caller
1847
-
    let $t05600356059 = _checkpoint(user)
1848
-
    let checkpointActions = $t05600356059._1
1849
-
    let userProfits = $t05600356059._2
1843
+
    let $t05605556111 = _checkpoint(user)
1844
+
    let checkpointActions = $t05605556111._1
1845
+
    let userProfits = $t05605556111._2
1850
1846
 
    $Tuple2(nil, userProfits)
1851
1847
 
    }
1852
1848
 
1853
1849
 
1854
1850
 
1855
1851
 
@Callable(i)
1856
1852
 
func getUtilFunc () = {
1857
1853
 
    let storage = _loadStorage()
1858
1854
 
    let lpTotalSupply = storage._3
1859
1855
 
    let weightAmplifier = storage._7
1860
1856
 
    let slippageRate = storage._8
1861
1857
 
    let feeMaxRate = storage._9
1862
-
    let $t05639256452 = _loadAssetBalances()
1863
-
    let assetBalances = $t05639256452._1
1864
-
    let assetTotalSupply = $t05639256452._2
1865
-
    let $t05645756510 = _loadAssetWeights()
1866
-
    let assetWeights = $t05645756510._1
1867
-
    let sigmaWeight = $t05645756510._2
1858
+
    let $t05644456504 = _loadAssetBalances()
1859
+
    let assetBalances = $t05644456504._1
1860
+
    let assetTotalSupply = $t05644456504._2
1861
+
    let $t05650956562 = _loadAssetWeights()
1862
+
    let assetWeights = $t05650956562._1
1863
+
    let sigmaWeight = $t05650956562._2
1868
1864
 
    let fee = _calculateFee(assetBalances, assetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1869
1865
 
    let utilValue = (assetTotalSupply - fee)
1870
1866
 
    $Tuple2(nil, $Tuple2(utilValue, lpTotalSupply))
1867
+
    }
1868
+
1869
+
1870
+
1871
+
@Callable(i)
1872
+
func getFeeFunc () = {
1873
+
    let storage = _loadStorage()
1874
+
    let weightAmplifier = storage._7
1875
+
    let slippageRate = storage._8
1876
+
    let feeMaxRate = storage._9
1877
+
    let $t05699457054 = _loadAssetBalances()
1878
+
    let assetBalances = $t05699457054._1
1879
+
    let assetTotalSupply = $t05699457054._2
1880
+
    let $t05705957112 = _loadAssetWeights()
1881
+
    let assetWeights = $t05705957112._1
1882
+
    let sigmaWeight = $t05705957112._2
1883
+
    let fee = _calculateFee(assetBalances, assetTotalSupply, assetWeights, sigmaWeight, weightAmplifier, slippageRate, feeMaxRate)
1884
+
    $Tuple2(nil, fee)
1871
1885
 
    }
1872
1886
 
1873
1887
 
1874
1888
 
1875
1889
 
@Callable(i)
1876
1890
 
func checkpoint (user_) = {
1877
1891
 
    let err = if (_whenInitialized())
1878
1892
 
        then _whenNotPaused()
1879
1893
 
        else false
1880
1894
 
    if ((err == err))
1881
1895
 
        then {
1882
1896
 
            let user = if ((size(user_) > 0))
1883
1897
 
                then valueOrErrorMessage(addressFromString(user_), "checkpoint: invalid user")
1884
1898
 
                else i.caller
1885
1899
 
            _checkpoint(user)
1886
1900
 
            }
1887
1901
 
        else throw("Strict value is not equal to itself.")
1888
1902
 
    }
1889
1903
 
1890
1904
 
1891
1905
 
1892
1906
 
@Callable(i)
1893
1907
 
func stake () = {
1894
1908
 
    let err = if (_whenInitialized())
1895
1909
 
        then _whenNotPaused()
1896
1910
 
        else false
1897
1911
 
    if ((err == err))
1898
1912
 
        then {
1899
1913
 
            let storage = _loadStorage()
1900
1914
 
            let lpAssetIdStr = _assetToStr(storage._1)
1901
1915
 
            let err1 = if (if (_validateIntEquals(size(i.payments), 1, "stake: invalid payments size"))
1902
1916
 
                then _validateStringEqual(lpAssetIdStr, _assetToStr(i.payments[0].assetId), "stake: invalid payment asset")
1903
1917
 
                else false)
1904
1918
 
                then _validateInt(i.payments[0].amount, 0, MAX_INT, "stake: invalid payment amount")
1905
1919
 
                else false
1906
1920
 
            if ((err1 == err1))
1907
1921
 
                then {
1908
-
                    let $t05758357643 = _checkpoint(i.caller)
1909
-
                    let checkpointActions = $t05758357643._1
1910
-
                    let userProfits = $t05758357643._2
1922
+
                    let $t05812058180 = _checkpoint(i.caller)
1923
+
                    let checkpointActions = $t05812058180._1
1924
+
                    let userProfits = $t05812058180._2
1911
1925
 
                    $Tuple2(((checkpointActions ++ _saveUserLp(i.caller, (_loadUserLp(i.caller) + i.payments[0].amount))) ++ _saveTotalLp((_loadTotalLp() + i.payments[0].amount))), unit)
1912
1926
 
                    }
1913
1927
 
                else throw("Strict value is not equal to itself.")
1914
1928
 
            }
1915
1929
 
        else throw("Strict value is not equal to itself.")
1916
1930
 
    }
1917
1931
 
1918
1932
 
1919
1933
 
1920
1934
 
@Callable(i)
1921
1935
 
func unstake (amount_) = {
1922
1936
 
    let err = if (_whenInitialized())
1923
1937
 
        then _whenNotPaused()
1924
1938
 
        else false
1925
1939
 
    if ((err == err))
1926
1940
 
        then {
1927
1941
 
            let storage = _loadStorage()
1928
1942
 
            let lpAssetId = storage._1
1929
1943
 
            let userLp = _loadUserLp(i.caller)
1930
1944
 
            let err1 = _validateInt(amount_, 0, userLp, "unstake: invalid amount")
1931
1945
 
            if ((err1 == err1))
1932
1946
 
                then {
1933
-
                    let $t05815458214 = _checkpoint(i.caller)
1934
-
                    let checkpointActions = $t05815458214._1
1935
-
                    let userProfits = $t05815458214._2
1947
+
                    let $t05869158751 = _checkpoint(i.caller)
1948
+
                    let checkpointActions = $t05869158751._1
1949
+
                    let userProfits = $t05869158751._2
1936
1950
 
                    $Tuple2(((([ScriptTransfer(i.caller, amount_, lpAssetId)] ++ checkpointActions) ++ _saveUserLp(i.caller, (userLp - amount_))) ++ _saveTotalLp((_loadTotalLp() - amount_))), unit)
1937
1951
 
                    }
1938
1952
 
                else throw("Strict value is not equal to itself.")
1939
1953
 
            }
1940
1954
 
        else throw("Strict value is not equal to itself.")
1941
1955
 
    }
1942
1956
 
1943
1957
 
1944
1958
 
1945
1959
 
@Callable(i)
1946
-
func claim (user_,assets_) = {
1947
-
    let err = if (if (_whenInitialized())
1960
+
func claim (user_) = {
1961
+
    let err = if (_whenInitialized())
1948
1962
 
        then _whenNotPaused()
1949
-
        else false)
1950
-
        then _validateInt(size(assets_), 1, 10, "claim: invalid assets size")
1951
1963
 
        else false
1952
1964
 
    if ((err == err))
1953
1965
 
        then {
1954
1966
 
            let user = if ((size(user_) > 0))
1955
1967
 
                then valueOrErrorMessage(addressFromString(user_), "claim: invalid user")
1956
1968
 
                else i.caller
1957
1969
 
            let storage = _loadStorage()
1958
1970
 
            let lpAssetId = storage._1
1959
1971
 
            let lpAssetIdStr = _assetToStr(lpAssetId)
1960
1972
 
            let assets = [lpAssetIdStr, _loadAssets()]
1961
1973
 
            let maxIndex = (size(assets) - 1)
1962
1974
 
            let userLp = _loadUserLp(user)
1963
-
            let $t05903759093 = _checkpoint(user)
1964
-
            let checkpointActions = $t05903759093._1
1965
-
            let userProfits = $t05903759093._2
1975
+
            let $t05947459530 = _checkpoint(user)
1976
+
            let checkpointActions = $t05947459530._1
1977
+
            let userProfits = $t05947459530._2
1966
1978
 
            func foldFunc (acc,profit) =             {
1967
1979
 
                let index = acc._1
1968
-
                if ((index > maxIndex))
1969
-
                    then $Tuple3((index + 1), (acc._2 :+ profit), acc._3)
1970
-
                    else {
1980
+
                if (if ((maxIndex >= index))
1981
+
                    then (profit > 0)
1982
+
                    else false)
1983
+
                    then {
1971
1984
 
                        let asset = assets[index]
1972
-
                        if (containsElement(assets_, asset))
1973
-
                            then $Tuple3((index + 1), (acc._2 :+ 0), (acc._3 :+ ScriptTransfer(user, profit, _strToAsset(asset))))
1974
-
                            else $Tuple3((index + 1), (acc._2 :+ profit), acc._3)
1985
+
                        $Tuple3((index + 1), (acc._2 :+ 0), (acc._3 :+ ScriptTransfer(user, profit, _strToAsset(asset))))
1975
1986
 
                        }
1987
+
                    else $Tuple3((index + 1), (acc._2 :+ profit), acc._3)
1976
1988
 
                }
1977
1989
 
1978
-
            let $t05958259673 = {
1990
+
            let $t05990859999 = {
1979
1991
 
                let $l = userProfits
1980
1992
 
                let $s = size($l)
1981
1993
 
                let $acc0 = $Tuple3(0, nil, nil)
1982
1994
 
                func $f0_1 ($a,$i) =                 if (($i >= $s))
1983
1995
 
                    then $a
1984
1996
 
                    else foldFunc($a, $l[$i])
1985
1997
 
1986
1998
 
                func $f0_2 ($a,$i) =                 if (($i >= $s))
1987
1999
 
                    then $a
1988
2000
 
                    else throw("List size exceeds 11")
1989
2001
 
1990
2002
 
                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
1991
2003
 
                }
1992
-
            let idx = $t05958259673._1
1993
-
            let userProfitsUpdated = $t05958259673._2
1994
-
            let profitActions = $t05958259673._3
2004
+
            let idx = $t05990859999._1
2005
+
            let userProfitsUpdated = $t05990859999._2
2006
+
            let profitActions = $t05990859999._3
1995
2007
 
            $Tuple2(((profitActions ++ removeByIndex(checkpointActions, 0)) ++ _saveUserProfits(user, userProfitsUpdated)), unit)
1996
2008
 
            }
1997
2009
 
        else throw("Strict value is not equal to itself.")
1998
2010
 
    }
1999
2011
 
2000
2012
 
2001
2013
 
2002
2014
 
@Callable(i)
2003
2015
 
func pause () = {
2004
2016
 
    let err = if (if (_onlyPauser(i.caller))
2005
2017
 
        then _whenInitialized()
2006
2018
 
        else false)
2007
2019
 
        then _whenNotPaused()
2008
2020
 
        else false
2009
2021
 
    if ((err == err))
2010
2022
 
        then $Tuple2(_savePause(true), unit)
2011
2023
 
        else throw("Strict value is not equal to itself.")
2012
2024
 
    }
2013
2025
 
2014
2026
 
2015
2027
 
2016
2028
 
@Callable(i)
2017
2029
 
func unpause () = {
2018
2030
 
    let err = if (if (_onlyPauser(i.caller))
2019
2031
 
        then _whenInitialized()
2020
2032
 
        else false)
2021
2033
 
        then _whenPaused()
2022
2034
 
        else false
2023
2035
 
    if ((err == err))
2024
2036
 
        then $Tuple2(_savePause(false), unit)
2025
2037
 
        else throw("Strict value is not equal to itself.")
2026
2038
 
    }
2027
2039
 
2028
2040
 
2029
2041
 
2030
2042
 
@Callable(i)
2031
2043
 
func updatePauser (pauser_) = {
2032
2044
 
    let err = if (if (_onlyThisContract(i.caller))
2033
2045
 
        then _whenInitialized()
2034
2046
 
        else false)
2035
2047
 
        then _validateAddress(pauser_, "updatePauser: invalid pauser")
2036
2048
 
        else false
2037
2049
 
    if ((err == err))
2038
2050
 
        then $Tuple2(_savePauser(addressFromStringValue(pauser_)), unit)
2039
2051
 
        else throw("Strict value is not equal to itself.")
2040
2052
 
    }
2041
2053
 
2042
2054
 
2043
2055
 
2044
2056
 
@Callable(i)
2045
2057
 
func setMultisig (multisig_) = {
2046
2058
 
    let err = if (_onlyThisContract(i.caller))
2047
2059
 
        then _validateAddress(multisig_, "setMultisig: invalid multisig")
2048
2060
 
        else false
2049
2061
 
    if ((err == err))
2050
2062
 
        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
2051
2063
 
        else throw("Strict value is not equal to itself.")
2052
2064
 
    }
2053
2065
 
2054
2066
 
2055
2067
 
@Verifier(tx)
2056
2068
 
func verify () = match getString(KEY_MULTISIG) {
2057
2069
 
    case multisig: String => 
2058
2070
 
        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEP)), false)
2059
2071
 
    case _ => 
2060
2072
 
        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
2061
2073
 
}
2062
2074