tx · 4rJ7GbZPXKCd9WLQX6LtehLgQfqBWzXDA6N226PidFY9

3MFuoRsHSjgLxydKMVu35u5zfHW3EAyNVim:  -0.05500000 Waves

2025.09.24 21:35 [327483] smart account 3MFuoRsHSjgLxydKMVu35u5zfHW3EAyNVim > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "4rJ7GbZPXKCd9WLQX6LtehLgQfqBWzXDA6N226PidFY9",
    "fee": 5500000,
    "feeAssetId": null,
    "timestamp": 1758738957026,
    "version": 2,
    "chainId": 82,
    "sender": "3MFuoRsHSjgLxydKMVu35u5zfHW3EAyNVim",
    "senderPublicKey": "2r1miifTvuqhqTZ9PykzRrCrFziPF4cHQc4QtX8qTCTq",
    "proofs": [
        "4J6VnFuNAGCmhCFkQJdaYprnEfzoWT6C9AM9xSvqvQ2qkcNh191yVEPyfHSeQn76X3PHWRBYvade9znZr4nv8sju"
    ],
    "script": "base64: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",
    "height": 327483,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 94ajPM9EN6Bn68rQTwT5TGNfBi6Z2jYFi5mESdij6pfP
Next: none

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let VERSION = "PZ-3.6.1 PROD-refactor"
55 
66 let configStr = valueOrElse(getString(this, "configAddress"), "3PMoEibdLeWqcURQ8351XhaWwyacDc7G4e5")
77 
88 let CONFIG_ADDRESS = if ((configStr == ""))
99     then this
1010     else Address(fromBase58String(configStr))
1111 
1212 let AssetsWeightsDecimals = 4
1313 
1414 let Scale = 10000
1515 
1616 let Scale8 = 100000000
1717 
1818 let Scale12 = 1000000000000
1919 
2020 let Scale16 = 10000000000000000
2121 
2222 let FeeScale = 10000
2323 
2424 let PoolTokenDecimals = 8
2525 
2626 let PoolTokenScale = pow(10, 0, PoolTokenDecimals, 0, 0, HALFUP)
2727 
2828 let MIN_STEPS_AMOUNT = valueOrElse(getInteger(CONFIG_ADDRESS, "min_steps_amount"), 1)
2929 
3030 let MAX_STEPS_AMOUNT = valueOrElse(getInteger(CONFIG_ADDRESS, "max_steps_amount"), 500)
3131 
3232 let MIN_STEPS_INTERVAL = valueOrElse(getInteger(CONFIG_ADDRESS, "min_steps_interval"), 1)
3333 
3434 let MAX_STEPS_INTERVAL = valueOrElse(getInteger(CONFIG_ADDRESS, "max_steps_interval"), 10000)
3535 
3636 let MIN_WEIGHT = valueOrElse(getInteger(CONFIG_ADDRESS, "min_weight"), 100)
3737 
3838 let MAX_WEIGHT = valueOrElse(getInteger(CONFIG_ADDRESS, "max_weight"), 9900)
3939 
4040 func tryGetInteger (key) = match getInteger(this, key) {
4141     case b: Int => 
4242         b
4343     case _ => 
4444         0
4545 }
4646 
4747 
4848 func tryGetBinary (key) = match getBinary(this, key) {
4949     case b: ByteVector => 
5050         b
5151     case _ => 
5252         base58''
5353 }
5454 
5555 
5656 func tryGetString (key) = match getString(this, key) {
5757     case b: String => 
5858         b
5959     case _ => 
6060         ""
6161 }
6262 
6363 
6464 func tryGetStringOrThrow (key) = match getString(this, key) {
6565     case b: String => 
6666         b
6767     case _ => 
6868         throw(("no such key in data storage: " + key))
6969 }
7070 
7171 
7272 func getAssetString (assetId) = match assetId {
7373     case b: ByteVector => 
7474         toBase58String(b)
7575     case _ => 
7676         "WAVES"
7777 }
7878 
7979 
8080 func getAssetBytes (assetIdStr) = if ((assetIdStr == "WAVES"))
8181     then unit
8282     else fromBase58String(assetIdStr)
8383 
8484 
8585 func getTokenBalance (assetId) = match assetId {
8686     case t: ByteVector => 
8787         assetBalance(this, t)
8888     case _ => 
8989         wavesBalance(this).available
9090 }
9191 
9292 
9393 func addAssetBytesToList (accum,item) = (accum ++ [getAssetBytes(item)])
9494 
9595 
9696 func addAssetWeightToList (accum,item) = (accum ++ [tryGetInteger((("static_" + getAssetString(item)) + "_weight"))])
9797 
9898 
9999 func addAssetWeightToStrList (accum,item) = (accum ++ [toString(tryGetInteger((("static_" + item) + "_weight")))])
100100 
101101 
102102 func addAssetDecimalsToList (accum,item) = (accum ++ [tryGetInteger((("static_" + getAssetString(item)) + "_decimals"))])
103103 
104104 
105105 func addAssetScaleToList (accum,item) = (accum ++ [tryGetInteger((("static_" + getAssetString(item)) + "_scale"))])
106106 
107107 
108108 func addIntToList (accum,item) = (accum ++ [parseIntValue(item)])
109109 
110110 
111111 func parstStrToIntList (s) = {
112112     func f (accum,next) =     (accum ++ [parseIntValue(next)])
113113 
114114     let $l = split(s, ",")
115115     let $s = size($l)
116116     let $acc0 = nil
117117     func $f0_1 ($a,$i) =     if (($i >= $s))
118118         then $a
119119         else f($a, $l[$i])
120120 
121121     func $f0_2 ($a,$i) =     if (($i >= $s))
122122         then $a
123123         else throw("List size exceeds 10")
124124 
125125     $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)
126126     }
127127 
128128 
129129 let usdnAssetIdStr = valueOrElse(getString(CONFIG_ADDRESS, "usdnAssetIdStr"), "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p")
130130 
131131 let puzzleAssetIdStr = valueOrElse(getString(CONFIG_ADDRESS, "puzzleAssetIdStr"), "HEB8Qaw9xrWpWs8tHsiATYGBWDBtP2S7kcPALrMu43AS")
132132 
133133 let usdtAssetIdStr = valueOrElse(getString(CONFIG_ADDRESS, "usdtAssetIdStr"), "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ")
134134 
135135 let usdtPptAssetIdStr = valueOrElse(getString(CONFIG_ADDRESS, "usdtPptAssetIdStr"), "9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi")
136136 
137137 let romeAssetIdStr = valueOrElse(getString(CONFIG_ADDRESS, "romeAssetIdStr"), "AP4Cb5xLYGH6ZigHreCZHoXpQTWDkPsG2BHqfDUx6taJ")
138138 
139139 let wavesAssetIdStr = "WAVES"
140140 
141141 let usdnAssetId = fromBase58String(usdnAssetIdStr)
142142 
143143 let puzzleAssetId = fromBase58String(puzzleAssetIdStr)
144144 
145145 let usdtAssetId = fromBase58String(usdtAssetIdStr)
146146 
147147 let usdtPptAssetId = fromBase58String(usdtPptAssetIdStr)
148148 
149149 let romeAssetId = fromBase58String(romeAssetIdStr)
150150 
151151 let wavesAssetId = unit
152152 
153153 let supportedFeeAssetsStr = [usdnAssetIdStr, puzzleAssetIdStr, usdtAssetIdStr, usdtPptAssetIdStr, wavesAssetIdStr, romeAssetIdStr]
154154 
155155 let parentPoolAddress = Address(fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "parentPoolAddress"), "3PFDgzu1UtswAkCMxqqQjbTeHaX4cMab8Kh")))
156156 
157157 let masterAddress = Address(fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "masterAddress"), "3PLjwHcz9NEuaTo63NZR9B9okQiKQxZSbmf")))
158158 
159159 let masterPubKey = fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "masterPubKey"), "2jTJGqHSopyj5d1cjbUe6f2jXqGMHE412cy3vGwYoRbP"))
160160 
161161 let oracleAddress = Address(fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "oracleAddress"), "3P8d1E1BLKoD52y3bQJ1bDTd2TD1gpaLn9t")))
162162 
163163 let stakingAddress = Address(fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "stakingAddress"), "3PFTbywqxtFfukX3HyT881g4iW5K4QL3FAS")))
164164 
165165 let feesAddress = Address(fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "feesAddress"), "3PFWAVKmXjfHXyzJb12jCbhP4Uhi9t4uWiD")))
166166 
167167 let poolsHubAddress = Address(fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "poolsHubAddress"), "3P5RGYyCnELF8JTPxgX54dBGzwkQMKUJ5H7")))
168168 
169169 let shutdownAddressStr = valueOrElse(getString(CONFIG_ADDRESS, "shutdownAddress"), "3PEpv9hRFWEEBU22WRnLsw1bH4YGtcU728o")
170170 
171171 let layer2Addresses = valueOrElse(getString(CONFIG_ADDRESS, "layer2Addresses"), "3PR1Qvi9mHT35SwWEkLSqqE2L8thiPLdVWU,3PQoBfUKHkJAeGWhooLP7WS8ovb54av9Jp2")
172172 
173173 let govAddress = Address(fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "govAddress"), "3P6uro9xCsE8te78QZjzqy7aq8natSzdceC")))
174174 
175175 let coldMasterAddress = Address(fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "coldMasterAddress"), "3PK9nhPfPbMBygB9ZgHVMHaQbSoojwrBfxj")))
176176 
177177 let T = tryGetInteger("static_tokensAmount")
178178 
179179 let assetIds = {
180180     let $l = split(tryGetString("static_tokenIds"), ",")
181181     let $s = size($l)
182182     let $acc0 = nil
183183     func $f0_1 ($a,$i) =     if (($i >= $s))
184184         then $a
185185         else addAssetBytesToList($a, $l[$i])
186186 
187187     func $f0_2 ($a,$i) =     if (($i >= $s))
188188         then $a
189189         else throw("List size exceeds 10")
190190 
191191     $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)
192192     }
193193 
194194 let AssetsWeights = {
195195     let $l = assetIds
196196     let $s = size($l)
197197     let $acc0 = nil
198198     func $f1_1 ($a,$i) =     if (($i >= $s))
199199         then $a
200200         else addAssetWeightToList($a, $l[$i])
201201 
202202     func $f1_2 ($a,$i) =     if (($i >= $s))
203203         then $a
204204         else throw("List size exceeds 10")
205205 
206206     $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
207207     }
208208 
209209 let Decimals = {
210210     let $l = assetIds
211211     let $s = size($l)
212212     let $acc0 = nil
213213     func $f2_1 ($a,$i) =     if (($i >= $s))
214214         then $a
215215         else addAssetDecimalsToList($a, $l[$i])
216216 
217217     func $f2_2 ($a,$i) =     if (($i >= $s))
218218         then $a
219219         else throw("List size exceeds 10")
220220 
221221     $f2_2($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
222222     }
223223 
224224 let Scales = {
225225     let $l = assetIds
226226     let $s = size($l)
227227     let $acc0 = nil
228228     func $f3_1 ($a,$i) =     if (($i >= $s))
229229         then $a
230230         else addAssetScaleToList($a, $l[$i])
231231 
232232     func $f3_2 ($a,$i) =     if (($i >= $s))
233233         then $a
234234         else throw("List size exceeds 10")
235235 
236236     $f3_2($f3_1($f3_1($f3_1($f3_1($f3_1($f3_1($f3_1($f3_1($f3_1($f3_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
237237     }
238238 
239239 let Fee = tryGetInteger("static_fee")
240240 
241241 let earnedAssets = assetIds
242242 
243243 func _get (assetId,param) = tryGetInteger(((("global_" + assetId) + "_") + param))
244244 
245245 
246246 func _get_feesEarned (assetId) = tryGetInteger(("global_feesEarned_" + assetId))
247247 
248248 
249249 func _get_lastCheck_interest (assetId) = tryGetInteger((("global_lastCheck_" + assetId) + "_interest"))
250250 
251251 
252252 func _get_extraEarned (assetId) = tryGetInteger(("global_extraEarned_" + assetId))
253253 
254254 
255255 func loadGlobalTokenParams (assetId) = match getString(("globalParams_" + assetId)) {
256256     case p: String => 
257257         let params = split(p, "__")
258258         $Tuple8(parseIntValue(params[0]), parseIntValue(params[1]), parseIntValue(params[2]), parseIntValue(params[3]), parseIntValue(params[4]), parseIntValue(params[5]), parseIntValue(params[6]), parseIntValue(params[7]))
259259     case _ => 
260260         $Tuple8(_get(assetId, "balance"), _get(assetId, "factBalance"), _get_feesEarned(assetId), _get_lastCheck_interest(assetId), _get_extraEarned(assetId), _get(assetId, "selloff"), _get(assetId, "selloffStartBalance"), _get(assetId, "selloffStartHeight"))
261261 }
262262 
263263 
264264 func saveGlobalTokenParams (assetId,params) = StringEntry(("globalParams_" + assetId), makeString([toString(params._1), toString(params._2), toString(params._3), toString(params._4), toString(params._5), toString(params._6), toString(params._7), toString(params._8)], "__"))
265265 
266266 
267267 func isShutdown () = {
268268     let shutdownAddress = addressFromString(shutdownAddressStr)
269269     if ((shutdownAddress == unit))
270270         then false
271271         else         match getBoolean(value(shutdownAddress), "is_shutdown") {
272272             case x: Boolean => 
273273                 x
274274             case _ => 
275275                 false
276276         }
277277     }
278278 
279279 
280280 func getFactBalance (assetIdStr) = {
281281     let assetParams = loadGlobalTokenParams(assetIdStr)
282282     assetParams._2
283283     }
284284 
285285 
286286 func getCurrentTokenBalance (tokenNum) = {
287287     let tokenIdStr = getAssetString(assetIds[tokenNum])
288288     let tokenParams = loadGlobalTokenParams(tokenIdStr)
289289     tokenParams._1
290290     }
291291 
292292 
293293 func stakeIfNeeded (assetIdStr,amount) = {
294294     let stakeTx = if ((tryGetString(("static_stakingContract_" + assetIdStr)) != ""))
295295         then invoke(addressFromStringValue(tryGetString(("static_stakingContract_" + assetIdStr))), "stake", nil, [AttachedPayment(getAssetBytes(assetIdStr), amount)])
296296         else unit
297297     if ((stakeTx == stakeTx))
298298         then true
299299         else throw("Strict value is not equal to itself.")
300300     }
301301 
302302 
303303 func unstakeIfNeeded (assetIdStr,amount) = {
304304     let unstakeTx = if ((tryGetString(("static_stakingContract_" + assetIdStr)) != ""))
305305         then invoke(addressFromStringValue(tryGetString(("static_stakingContract_" + assetIdStr))), "unstake", [amount], nil)
306306         else unit
307307     if ((unstakeTx == unstakeTx))
308308         then true
309309         else throw("Strict value is not equal to itself.")
310310     }
311311 
312312 
313313 func burnIndexIfNeeded (amount) = {
314314     let indexIdStr = tryGetString("static_poolToken_idStr")
315315     if ((indexIdStr == ""))
316316         then nil
317317         else if ((assetInfo(fromBase58String(indexIdStr)) == unit))
318318             then nil
319319             else [Burn(fromBase58String(indexIdStr), amount)]
320320     }
321321 
322322 
323323 func mintIndexIfNeeded (amount) = {
324324     let indexIdStr = tryGetString("static_poolToken_idStr")
325325     if ((indexIdStr == ""))
326326         then nil
327327         else if ((assetInfo(fromBase58String(indexIdStr)) == unit))
328328             then nil
329329             else [Reissue(fromBase58String(indexIdStr), amount, true)]
330330     }
331331 
332332 
333333 func getKMult () = match getInteger("static_KMult") {
334334     case x: Int => 
335335         x
336336     case _ => 
337337         Scale16
338338 }
339339 
340340 
341341 func saveCurrentWeights () = {
342342     let assetIdsLi = split(tryGetString("static_tokenIds"), ",")
343343     func s (accum,assetId) =     (accum ++ [IntegerEntry(("rebalance_startWeight_" + assetId), tryGetInteger((("static_" + assetId) + "_weight")))])
344344 
345345     let $l = assetIdsLi
346346     let $s = size($l)
347347     let $acc0 = nil
348348     func $f4_1 ($a,$i) =     if (($i >= $s))
349349         then $a
350350         else s($a, $l[$i])
351351 
352352     func $f4_2 ($a,$i) =     if (($i >= $s))
353353         then $a
354354         else throw("List size exceeds 10")
355355 
356356     $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
357357     }
358358 
359359 
360360 func getVirtualPoolTokenAmount () = fraction(tryGetInteger("global_poolToken_amount"), getKMult(), Scale16)
361361 
362362 
363363 func calculatePIssued (amount,tokenId) = {
364364     let Psupply = getVirtualPoolTokenAmount()
365365     let Balance = getFactBalance(getAssetString(tokenId))
366366     let t1 = fraction(amount, Psupply, Balance, DOWN)
367367     t1
368368     }
369369 
370370 
371371 func getMinPIssued (payments) = {
372372     func handler (accum,current) =     if ((getFactBalance(getAssetString(current.assetId)) == 0))
373373         then accum
374374         else {
375375             let PIssued = calculatePIssued(current.amount, current.assetId)
376376             if ((PIssued == 0))
377377                 then throw("one of the tokens amounts is too low")
378378                 else if (if ((accum == 0))
379379                     then true
380380                     else (accum > PIssued))
381381                     then PIssued
382382                     else accum
383383             }
384384 
385385     let minPIssed = {
386386         let $l = payments
387387         let $s = size($l)
388388         let $acc0 = 0
389389         func $f4_1 ($a,$i) =         if (($i >= $s))
390390             then $a
391391             else handler($a, $l[$i])
392392 
393393         func $f4_2 ($a,$i) =         if (($i >= $s))
394394             then $a
395395             else throw("List size exceeds 10")
396396 
397397         $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
398398         }
399399     minPIssed
400400     }
401401 
402402 
403403 func getPriceFromOracle (assetIdStr) = match getInteger(oracleAddress, (assetIdStr + "_twap5B")) {
404404     case x: Int => 
405405         x
406406     case _ => 
407407         0
408408 }
409409 
410410 
411411 func calculateUsdValue (assetId,amount,aBalance,feeAssetBalance) = {
412412     let assetWeight = tryGetInteger((("static_" + getAssetString(assetId)) + "_weight"))
413413     let feeAssetStr = tryGetString("static_feeToken")
414414     let feeAssetScale = getIntegerValue(this, (("static_" + feeAssetStr) + "_scale"))
415415     let feeAssetNum = value(indexOf(assetIds, getAssetBytes(feeAssetStr)))
416416     let feeAssetWeight = AssetsWeights[feeAssetNum]
417417     let valInFeeAsset = fraction(amount, (feeAssetBalance / feeAssetWeight), (aBalance / assetWeight))
418418     let feeAssetPrice = getPriceFromOracle(feeAssetStr)
419419     fraction(valInFeeAsset, feeAssetPrice, feeAssetScale)
420420     }
421421 
422422 
423423 func calcAvgConcentration () = {
424424     func f (accum,next) =     {
425425         let assetIdStr = getAssetString(next)
426426         let weight = tryGetInteger((("static_" + assetIdStr) + "_weight"))
427427         let assetParams = loadGlobalTokenParams(assetIdStr)
428428         let assetFactBalance = assetParams._2
429429         let assetVirtBalance = assetParams._1
430430         $Tuple2((accum._1 + fraction(assetFactBalance, weight, assetVirtBalance)), (accum._2 + weight))
431431         }
432432 
433433     let $l = assetIds
434434     let $s = size($l)
435435     let $acc0 = $Tuple2(0, 0)
436436     func $f4_1 ($a,$i) =     if (($i >= $s))
437437         then $a
438438         else f($a, $l[$i])
439439 
440440     func $f4_2 ($a,$i) =     if (($i >= $s))
441441         then $a
442442         else throw("List size exceeds 10")
443443 
444444     $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
445445     }
446446 
447447 
448448 func checkTokensValidity (payments) = {
449449     func handler1 (accum,payment) =     (accum ++ [payment.assetId])
450450 
451451     let ids = {
452452         let $l = payments
453453         let $s = size($l)
454454         let $acc0 = nil
455455         func $f4_1 ($a,$i) =         if (($i >= $s))
456456             then $a
457457             else handler1($a, $l[$i])
458458 
459459         func $f4_2 ($a,$i) =         if (($i >= $s))
460460             then $a
461461             else throw("List size exceeds 10")
462462 
463463         $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
464464         }
465465     if ((ids == ids))
466466         then {
467467             func handler2 (accum,assetId) =             if ((indexOf(ids, assetId) != unit))
468468                 then (accum + 1)
469469                 else throw(("asset not attached: " + getAssetString(assetId)))
470470 
471471             let checks = {
472472                 let $l = assetIds
473473                 let $s = size($l)
474474                 let $acc0 = 0
475475                 func $f5_1 ($a,$i) =                 if (($i >= $s))
476476                     then $a
477477                     else handler2($a, $l[$i])
478478 
479479                 func $f5_2 ($a,$i) =                 if (($i >= $s))
480480                     then $a
481481                     else throw("List size exceeds 10")
482482 
483483                 $f5_2($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
484484                 }
485485             if ((checks == checks))
486486                 then true
487487                 else throw("Strict value is not equal to itself.")
488488             }
489489         else throw("Strict value is not equal to itself.")
490490     }
491491 
492492 
493493 func handlePoolTokensAdd (PIssued,payments,userAddress,needChange) = {
494494     func getTokenPaymentAmount (tokenId) =     {
495495         func handler (accum,payment) =         if ((payment.assetId == tokenId))
496496             then payment.amount
497497             else accum
498498 
499499         let $l = payments
500500         let $s = size($l)
501501         let $acc0 = 0
502502         func $f4_1 ($a,$i) =         if (($i >= $s))
503503             then $a
504504             else handler($a, $l[$i])
505505 
506506         func $f4_2 ($a,$i) =         if (($i >= $s))
507507             then $a
508508             else throw("List size exceeds 10")
509509 
510510         $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
511511         }
512512 
513513     func handleTokenChange (accum,tokenId) =     {
514514         let assetIdStr = getAssetString(tokenId)
515515         let assetParams = loadGlobalTokenParams(assetIdStr)
516516         let paymentAmount = getTokenPaymentAmount(tokenId)
517517         let Bk = assetParams._2
518518         let PSupply = getVirtualPoolTokenAmount()
519519         let tokenDecimals = tryGetInteger((("static_" + assetIdStr) + "_scale"))
520520         let a1 = fraction((toBigInt((PSupply + PIssued)) * toBigInt(Scale8)), toBigInt(tokenDecimals), toBigInt(PSupply), CEILING)
521521         let Dk = toInt(fraction((a1 - (toBigInt(tokenDecimals) * toBigInt(Scale8))), toBigInt(Bk), (toBigInt(tokenDecimals) * toBigInt(Scale8)), CEILING))
522522         let toReturn = (paymentAmount - Dk)
523523         let stakeTx = stakeIfNeeded(assetIdStr, Dk)
524524         if ((stakeTx == stakeTx))
525525             then {
526526                 let t = if (if (needChange)
527527                     then (toReturn > 0)
528528                     else false)
529529                     then [ScriptTransfer(userAddress, toReturn, tokenId)]
530530                     else nil
531531                 let selloffStartBalance = if ((assetParams._8 != ((height / 100) * 100)))
532532                     then assetParams._7
533533                     else fraction(assetParams._7, (PSupply + PIssued), PSupply)
534534                 let assetParamsUpd = $Tuple8(fraction(assetParams._1, (PSupply + PIssued), PSupply, HALFEVEN), (assetParams._2 + Dk), assetParams._3, assetParams._4, assetParams._5, assetParams._6, selloffStartBalance, assetParams._8)
535535                 ((accum ++ t) ++ [saveGlobalTokenParams(assetIdStr, assetParamsUpd)])
536536                 }
537537             else throw("Strict value is not equal to itself.")
538538         }
539539 
540540     let $l = assetIds
541541     let $s = size($l)
542542     let $acc0 = nil
543543     func $f4_1 ($a,$i) =     if (($i >= $s))
544544         then $a
545545         else handleTokenChange($a, $l[$i])
546546 
547547     func $f4_2 ($a,$i) =     if (($i >= $s))
548548         then $a
549549         else throw("List size exceeds 10")
550550 
551551     $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
552552     }
553553 
554554 
555555 func calcMintedWithOneToken (assetAddedIdStr,amount) = {
556556     let PSupply = getVirtualPoolTokenAmount()
557557     let assetParams = loadGlobalTokenParams(assetAddedIdStr)
558558     let assetFactBalance = assetParams._2
559559     let assetVirtBalance = assetParams._1
560560     let assetWeight = tryGetInteger((("static_" + assetAddedIdStr) + "_weight"))
561561     let assetScale = tryGetInteger((("static_" + assetAddedIdStr) + "_scale"))
562562     let assetDecimals = tryGetInteger((("static_" + assetAddedIdStr) + "_decimals"))
563563     let PIssuedNoMultiplier = fraction(PSupply, (toInt(pow(toBigInt((assetScale + fraction(amount, assetScale, assetVirtBalance))), assetDecimals, toBigInt(assetWeight), 4, 8, DOWN)) - Scale8), Scale8)
564564     let avgConc = calcAvgConcentration()
565565     let PIssued = fraction(PIssuedNoMultiplier, avgConc._2, avgConc._1)
566566     let assetParamsUpd = $Tuple8((assetVirtBalance + amount), (assetFactBalance + amount), assetParams._3, assetParams._4, assetParams._5, assetParams._6, assetParams._7, assetParams._8)
567567     $Tuple2([saveGlobalTokenParams(assetAddedIdStr, assetParamsUpd)], PIssued)
568568     }
569569 
570570 
571571 func calcRedeemWithOneToken (assetOutIdStr,PRedeemed) = {
572572     let PSupply = getVirtualPoolTokenAmount()
573573     let assetParams = loadGlobalTokenParams(assetOutIdStr)
574574     let assetFactBalance = assetParams._2
575575     let assetVirtBalance = assetParams._1
576576     let assetWeight = tryGetInteger((("static_" + assetOutIdStr) + "_weight"))
577577     let assetScale = tryGetInteger((("static_" + assetOutIdStr) + "_scale"))
578578     let assetDecimals = tryGetInteger((("static_" + assetOutIdStr) + "_decimals"))
579579     let amountOutNoMulitplier = fraction(assetVirtBalance, (Scale8 - toInt(pow(toBigInt((assetScale - fraction(PRedeemed, assetScale, PSupply))), assetDecimals, toBigInt(fraction(10000, 10000, assetWeight)), 4, 8, DOWN))), Scale8)
580580     let avgConc = calcAvgConcentration()
581581     let amountOut = fraction(amountOutNoMulitplier, avgConc._1, avgConc._2)
582582     if ((amountOut > assetFactBalance))
583583         then throw("no available fact liquidity to withdraw in one token")
584584         else {
585585             let assetParamsUpd = $Tuple8((assetVirtBalance - amountOut), (assetFactBalance - amountOut), assetParams._3, assetParams._4, assetParams._5, assetParams._6, assetParams._7, assetParams._8)
586586             $Tuple2([saveGlobalTokenParams(assetOutIdStr, assetParamsUpd)], amountOut)
587587             }
588588     }
589589 
590590 
591591 func handlePoolTokensRedeem (PRedeemed,userAddress) = {
592592     func handleTokenRedeem (accum,tokenId) =     {
593593         let assetIdStr = getAssetString(tokenId)
594594         let assetParams = loadGlobalTokenParams(assetIdStr)
595595         let Bk = assetParams._2
596596         let PSupply = getVirtualPoolTokenAmount()
597597         let tokenDecimals = tryGetInteger((("static_" + assetIdStr) + "_scale"))
598598         let psuppl = fraction((toBigInt((PSupply - PRedeemed)) * toBigInt(Scale8)), toBigInt(Scale8), toBigInt(PSupply), DOWN)
599599         let amount = toInt(fraction((toBigInt(Scale16) - psuppl), toBigInt(Bk), toBigInt(Scale16), CEILING))
600600         let unstakeTx = unstakeIfNeeded(assetIdStr, amount)
601601         if ((unstakeTx == unstakeTx))
602602             then {
603603                 let selloffStartBalance = if ((assetParams._8 != ((height / 100) * 100)))
604604                     then assetParams._7
605605                     else fraction(assetParams._7, (PSupply - PRedeemed), PSupply)
606606                 let assetParamsUpd = $Tuple8(fraction(assetParams._1, (PSupply - PRedeemed), PSupply), (assetParams._2 - amount), assetParams._3, assetParams._4, assetParams._5, assetParams._6, selloffStartBalance, assetParams._8)
607607                 ((accum ++ [ScriptTransfer(userAddress, amount, tokenId)]) ++ [saveGlobalTokenParams(assetIdStr, assetParamsUpd)])
608608                 }
609609             else throw("Strict value is not equal to itself.")
610610         }
611611 
612612     let $l = assetIds
613613     let $s = size($l)
614614     let $acc0 = nil
615615     func $f4_1 ($a,$i) =     if (($i >= $s))
616616         then $a
617617         else handleTokenRedeem($a, $l[$i])
618618 
619619     func $f4_2 ($a,$i) =     if (($i >= $s))
620620         then $a
621621         else throw("List size exceeds 10")
622622 
623623     $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
624624     }
625625 
626626 
627627 func calculateOutAmount (AmountIn,assetIn,assetOut,BalanceIn,BalanceOut) = {
628628     let IndexIn = value(indexOf(assetIds, assetIn))
629629     let IndexOut = value(indexOf(assetIds, assetOut))
630630     if ((IndexIn == IndexOut))
631631         then AmountIn
632632         else fraction(BalanceOut, ((Scale8 * Scale8) - toInt(pow(fraction((toBigInt(BalanceIn) * toBigInt(10000)), toBigInt((Scale8 * Scale8)), (toBigInt((BalanceIn + AmountIn)) * toBigInt(10000)), HALFUP), 16, toBigInt(fraction(AssetsWeights[IndexIn], 1000000000000, AssetsWeights[IndexOut])), 12, 16, CEILING))), (Scale8 * Scale8), HALFEVEN)
633633     }
634634 
635635 
636636 func claimResult (address) = {
637637     let addressStr = toString(address)
638638     let indexAmount = tryGetInteger((addressStr + "_indexStaked"))
639639     let feeAssetStr = tryGetString("static_feeToken")
640640     let feeAssetParams = loadGlobalTokenParams(feeAssetStr)
641641     let feeTokenBalance = feeAssetParams._1
642642     func handler (accum,assetId) =     {
643643         let assetIdStr = getAssetString(assetId)
644644         let assetParams = loadGlobalTokenParams(assetIdStr)
645645         let currentTokenInterest = assetParams._4
646646         let aBalance = assetParams._1
647647         let rewardAmount = fraction(indexAmount, (currentTokenInterest - tryGetInteger((((addressStr + "_lastCheck_") + assetIdStr) + "_interest"))), Scale16)
648648         let unstakeInv = unstakeIfNeeded(assetIdStr, rewardAmount)
649649         if ((unstakeInv == unstakeInv))
650650             then {
651651                 let transfer = if ((rewardAmount == 0))
652652                     then nil
653653                     else [ScriptTransfer(address, rewardAmount, assetId)]
654654                 $Tuple2(((accum._1 ++ transfer) ++ [IntegerEntry((((addressStr + "_lastCheck_") + assetIdStr) + "_interest"), currentTokenInterest)]), (accum._2 + calculateUsdValue(assetId, rewardAmount, aBalance, feeTokenBalance)))
655655                 }
656656             else throw("Strict value is not equal to itself.")
657657         }
658658 
659659     let accum = {
660660         let $l = earnedAssets
661661         let $s = size($l)
662662         let $acc0 = $Tuple2(nil, 0)
663663         func $f4_1 ($a,$i) =         if (($i >= $s))
664664             then $a
665665             else handler($a, $l[$i])
666666 
667667         func $f4_2 ($a,$i) =         if (($i >= $s))
668668             then $a
669669             else throw("List size exceeds 10")
670670 
671671         $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
672672         }
673673     $Tuple2((accum._1 ++ [IntegerEntry((addressStr + "_claimedRewardUSD"), (tryGetInteger((addressStr + "_claimedRewardUSD")) + accum._2)), IntegerEntry((addressStr + "_lastClaim"), lastBlock.timestamp)]), accum._2)
674674     }
675675 
676676 
677677 func indexStakeResult (addressStr,amount) = {
678678     let li = claimResult(addressFromStringValue(addressStr))._1
679679     (li ++ [IntegerEntry((addressStr + "_indexStaked"), (tryGetInteger((addressStr + "_indexStaked")) + amount)), IntegerEntry("global_indexStaked", (tryGetInteger("global_indexStaked") + amount))])
680680     }
681681 
682682 
683683 func sum (accum,n) = (accum + parseIntValue(n))
684684 
685685 
686686 func checkFeeAsset (accum,next) = if (if ((indexOf(supportedFeeAssetsStr, next) != unit))
687687     then (accum == "")
688688     else false)
689689     then next
690690     else accum
691691 
692692 
693693 func calcInterestChange (assetIdStr,lpFee) = {
694694     let totalIndex = tryGetInteger("global_indexStaked")
695695     let interestDelta = fraction(lpFee, Scale16, totalIndex)
696696     interestDelta
697697     }
698698 
699699 
700700 func updSelloffData (assetIdStr,amountIn,balance,selloffParams) = {
701701     let currentPeriod = ((height / 100) * 100)
702702     let prevPeriod = selloffParams._2
703703     let prevSelloff = if ((currentPeriod == prevPeriod))
704704         then selloffParams._1
705705         else 0
706706     let selloffStartBalance = if ((currentPeriod == prevPeriod))
707707         then selloffParams._3
708708         else balance
709709     let selloffDelta = fraction(Scale16, amountIn, selloffStartBalance)
710710     let maxSelloff = tryGetInteger((("static_" + assetIdStr) + "_maxSelloff"))
711711     if (if (((prevSelloff + selloffDelta) > maxSelloff))
712712         then (maxSelloff != 0)
713713         else false)
714714         then throw(("max selloff reached for this asset " + assetIdStr))
715715         else {
716716             let startH = if ((currentPeriod == prevPeriod))
717717                 then prevPeriod
718718                 else currentPeriod
719719             let startB = if ((currentPeriod == prevPeriod))
720720                 then selloffParams._3
721721                 else selloffStartBalance
722722             $Tuple3((prevSelloff + selloffDelta), startH, startB)
723723             }
724724     }
725725 
726726 
727727 func getTmpRebalanceIds (newAssetIdsLi) = {
728728     let currentAssetIdsLi = split(tryGetString("static_tokenIds"), ",")
729729     let result = newAssetIdsLi
730730     func f (accum,assetId) =     if ((indexOf(result, assetId) == unit))
731731         then (accum ++ [assetId])
732732         else accum
733733 
734734     let $l = currentAssetIdsLi
735735     let $s = size($l)
736736     let $acc0 = result
737737     func $f4_1 ($a,$i) =     if (($i >= $s))
738738         then $a
739739         else f($a, $l[$i])
740740 
741741     func $f4_2 ($a,$i) =     if (($i >= $s))
742742         then $a
743743         else throw("List size exceeds 10")
744744 
745745     $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
746746     }
747747 
748748 
749749 func checkTokensChange (newAssetIdsLi) = {
750750     let currentAssetIdsLi = split(tryGetString("static_tokenIds"), ",")
751751     func rem (accum,assetId) =     if ((indexOf(newAssetIdsLi, assetId) == unit))
752752         then (accum + 1)
753753         else accum
754754 
755755     func add (accum,assetId) =     if ((indexOf(currentAssetIdsLi, assetId) == unit))
756756         then (accum + 1)
757757         else accum
758758 
759759     let removed = {
760760         let $l = currentAssetIdsLi
761761         let $s = size($l)
762762         let $acc0 = 0
763763         func $f4_1 ($a,$i) =         if (($i >= $s))
764764             then $a
765765             else rem($a, $l[$i])
766766 
767767         func $f4_2 ($a,$i) =         if (($i >= $s))
768768             then $a
769769             else throw("List size exceeds 10")
770770 
771771         $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
772772         }
773773     let added = {
774774         let $l = newAssetIdsLi
775775         let $s = size($l)
776776         let $acc0 = 0
777777         func $f5_1 ($a,$i) =         if (($i >= $s))
778778             then $a
779779             else add($a, $l[$i])
780780 
781781         func $f5_2 ($a,$i) =         if (($i >= $s))
782782             then $a
783783             else throw("List size exceeds 10")
784784 
785785         $f5_2($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
786786         }
787787     (removed + added)
788788     }
789789 
790790 
791791 func validatePayments (assetsList,payments) = {
792792     func getPaymentAssets (accum,next) =     if ((0 >= next.amount))
793793         then throw(((("Too low payment amount for " + getAssetString(next.assetId)) + ": ") + toString(next.amount)))
794794         else (accum ++ [getAssetString(next.assetId)])
795795 
796796     let paymentList = {
797797         let $l = payments
798798         let $s = size($l)
799799         let $acc0 = nil
800800         func $f4_1 ($a,$i) =         if (($i >= $s))
801801             then $a
802802             else getPaymentAssets($a, $l[$i])
803803 
804804         func $f4_2 ($a,$i) =         if (($i >= $s))
805805             then $a
806806             else throw("List size exceeds 10")
807807 
808808         $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
809809         }
810810     func f1 (accum,next) =     if ((indexOf(assetsList, next) == unit))
811811         then throw(((next + " asset is present in payments, but is not in new assets: ") + makeString(assetsList, ",")))
812812         else (accum + 1)
813813 
814814     func f2 (accum,next) =     if ((indexOf(paymentList, next) == unit))
815815         then throw(((next + " asset is present in new assets, but is not in payments: ") + makeString(paymentList, ",")))
816816         else (accum + 1)
817817 
818818     let a1 = {
819819         let $l = paymentList
820820         let $s = size($l)
821821         let $acc0 = 0
822822         func $f5_1 ($a,$i) =         if (($i >= $s))
823823             then $a
824824             else f1($a, $l[$i])
825825 
826826         func $f5_2 ($a,$i) =         if (($i >= $s))
827827             then $a
828828             else throw("List size exceeds 10")
829829 
830830         $f5_2($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
831831         }
832832     let a2 = {
833833         let $l = assetsList
834834         let $s = size($l)
835835         let $acc0 = 0
836836         func $f6_1 ($a,$i) =         if (($i >= $s))
837837             then $a
838838             else f2($a, $l[$i])
839839 
840840         func $f6_2 ($a,$i) =         if (($i >= $s))
841841             then $a
842842             else throw("List size exceeds 10")
843843 
844844         $f6_2($f6_1($f6_1($f6_1($f6_1($f6_1($f6_1($f6_1($f6_1($f6_1($f6_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
845845         }
846846     (a1 + a2)
847847     }
848848 
849849 
850850 func validateWeights (weights) = {
851851     func v (accum,w) =     {
852852         let wInt = valueOrErrorMessage(parseInt(w), ("Wrong weight format: " + w))
853853         if (if ((MIN_WEIGHT > wInt))
854854             then true
855855             else (wInt > MAX_WEIGHT))
856856             then throw(((((("Weight should be in range " + toString(MIN_WEIGHT)) + " - ") + toString(MAX_WEIGHT)) + ", current: ") + w))
857857             else (accum + wInt)
858858         }
859859 
860860     let $l = weights
861861     let $s = size($l)
862862     let $acc0 = 0
863863     func $f4_1 ($a,$i) =     if (($i >= $s))
864864         then $a
865865         else v($a, $l[$i])
866866 
867867     func $f4_2 ($a,$i) =     if (($i >= $s))
868868         then $a
869869         else throw("List size exceeds 10")
870870 
871871     $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
872872     }
873873 
874874 
875875 func getP1P2 (assetIdStr,baseAssetIdStr) = {
876876     let assetParams = loadGlobalTokenParams(assetIdStr)
877877     let baseAssetParams = loadGlobalTokenParams(baseAssetIdStr)
878878     let B1 = baseAssetParams._1
879879     let B2 = assetParams._1
880880     let F1 = baseAssetParams._2
881881     let F2 = assetParams._2
882882     let S1 = tryGetInteger((("static_" + baseAssetIdStr) + "_scale"))
883883     let S2 = tryGetInteger((("static_" + assetIdStr) + "_scale"))
884884     let D1 = tryGetInteger((("static_" + baseAssetIdStr) + "_decimals"))
885885     let D2 = tryGetInteger((("static_" + assetIdStr) + "_decimals"))
886886     let W1 = tryGetInteger((("static_" + baseAssetIdStr) + "_weight"))
887887     let W2 = tryGetInteger((("static_" + assetIdStr) + "_weight"))
888888     let W1W2 = fraction(W1, 10000, W2)
889889     let W2W1 = fraction(W2, 10000, W1)
890890     let p1_unweighted = fraction((B1 - F1), S1, fraction(B2, pow(fraction(B1, S1, (B1 - F1)), D1, W1W2, 4, D1, CEILING), S2))
891891     let p1 = fraction(p1_unweighted, W2W1, 10000)
892892     if ((B2 == F2))
893893         then $Tuple2(p1, unit)
894894         else {
895895             let p2_unweighted = fraction(fraction(B1, pow(fraction(B2, S2, (B2 - F2)), D2, W2W1, 4, D2, FLOOR), S2), S2, (B2 - F2))
896896             let p2 = fraction(p2_unweighted, W2W1, 10000)
897897             $Tuple2(p1, p2)
898898             }
899899     }
900900 
901901 
902902 @Callable(i)
903903 func addUnderlyingStaker (stakerAddress,assetIdStr) = if ((this != i.caller))
904904     then throw("admin only")
905905     else [StringEntry(("static_stakingContract_" + assetIdStr), stakerAddress)]
906906 
907907 
908908 
909909 @Callable(i)
910910 func preInit (assetIdsStr,assetWeightsStr,assetMaxSelloffStr,baseTokenIdStr,poolDomain,poolOwner,fee) = {
911911     let poolOwnerAddress = addressFromStringValue(poolOwner)
912912     let assetIdsStrLi = split(assetIdsStr, ",")
913913     let assetMaxSelloffStrLi = split(assetMaxSelloffStr, ",")
914914     let assetWeightsStrLi = split(assetWeightsStr, ",")
915915     let assetIdsLi = {
916916         let $l = assetIdsStrLi
917917         let $s = size($l)
918918         let $acc0 = nil
919919         func $f4_1 ($a,$i) =         if (($i >= $s))
920920             then $a
921921             else addAssetBytesToList($a, $l[$i])
922922 
923923         func $f4_2 ($a,$i) =         if (($i >= $s))
924924             then $a
925925             else throw("List size exceeds 10")
926926 
927927         $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
928928         }
929929     let feeAssetChosenStr = {
930930         let $l = assetIdsStrLi
931931         let $s = size($l)
932932         let $acc0 = ""
933933         func $f5_1 ($a,$i) =         if (($i >= $s))
934934             then $a
935935             else checkFeeAsset($a, $l[$i])
936936 
937937         func $f5_2 ($a,$i) =         if (($i >= $s))
938938             then $a
939939             else throw("List size exceeds 10")
940940 
941941         $f5_2($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($f5_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
942942         }
943943     let feeAssetStr = if ((feeAssetChosenStr == ""))
944944         then baseTokenIdStr
945945         else feeAssetChosenStr
946946     if (isShutdown())
947947         then throw("contract is on stop")
948948         else if ((this != i.caller))
949949             then throw("admin only")
950950             else if ((size(poolDomain) > 13))
951951                 then throw("too large pool domain")
952952                 else if (if ((fee > 500))
953953                     then true
954954                     else (0 > fee))
955955                     then throw("fee value must be between 0 and 500 (0-5%)")
956956                     else if ((validateWeights(assetWeightsStrLi) != 10000))
957957                         then throw(("weights sum should be 10000, current: " + toString(validateWeights(assetWeightsStrLi))))
958958                         else {
959959                             func addTokenDataEntries (accum,assetNum) =                             if ((assetNum >= size(assetIdsLi)))
960960                                 then accum
961961                                 else {
962962                                     let assetStakingAddress = {
963963                                         let @ = invoke(poolsHubAddress, "useEmptyContract", [("staker_" + assetIdsStrLi[assetNum])], nil)
964964                                         if ($isInstanceOf(@, "String"))
965965                                             then @
966966                                             else throw(($getType(@) + " couldn't be cast to String"))
967967                                         }
968968                                     if ((assetStakingAddress == assetStakingAddress))
969969                                         then {
970970                                             let assetDecimals =                                             match assetIdsLi[assetNum] {
971971                                                 case x: ByteVector => 
972972                                                     value(assetInfo(x)).decimals
973973                                                 case _ => 
974974                                                     8
975975                                             }
976976                                             ((accum ++ [IntegerEntry((("static_" + assetIdsStrLi[assetNum]) + "_scale"), pow(10, 0, assetDecimals, 0, 0, DOWN)), IntegerEntry((("static_" + assetIdsStrLi[assetNum]) + "_decimals"), assetDecimals), IntegerEntry((("static_" + assetIdsStrLi[assetNum]) + "_weight"), value(parseInt(assetWeightsStrLi[assetNum]))), StringEntry(("static_stakingContract_" + assetIdsStrLi[assetNum]), assetStakingAddress)]) ++ (if ((assetMaxSelloffStrLi[assetNum] == ""))
977977                                                 then nil
978978                                                 else [IntegerEntry((("static_" + assetIdsStrLi[assetNum]) + "_maxSelloff"), (parseIntValue(assetMaxSelloffStrLi[assetNum]) * Scale12))]))
979979                                             }
980980                                         else throw("Strict value is not equal to itself.")
981981                                     }
982982 
983983                             ({
984984                                 let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
985985                                 let $s = size($l)
986986                                 let $acc0 = nil
987987                                 func $f6_1 ($a,$i) =                                 if (($i >= $s))
988988                                     then $a
989989                                     else addTokenDataEntries($a, $l[$i])
990990 
991991                                 func $f6_2 ($a,$i) =                                 if (($i >= $s))
992992                                     then $a
993993                                     else throw("List size exceeds 10")
994994 
995995                                 $f6_2($f6_1($f6_1($f6_1($f6_1($f6_1($f6_1($f6_1($f6_1($f6_1($f6_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
996996                                 } ++ [StringEntry("static_tokenIds", assetIdsStr), StringEntry("static_feeToken", feeAssetStr), StringEntry("static_tokenWeights", assetWeightsStr), IntegerEntry("static_tokensAmount", size(assetIdsLi)), StringEntry("static_poolDomain", poolDomain), StringEntry("static_poolToken_idStr", ""), StringEntry("static_baseTokenId", baseTokenIdStr), StringEntry("static_poolOwner", poolOwner), IntegerEntry("static_fee", fee), IntegerEntry("static_KMult", Scale16), IntegerEntry("global_indexStaked", 0), IntegerEntry("global_poolToken_amount", 0), IntegerEntry("global_wasPreInited", 1)])
997997                             }
998998     }
999999 
10001000 
10011001 
10021002 @Callable(i)
10031003 func deInit () = if (isShutdown())
10041004     then throw("contract is on stop")
10051005     else if ((i.caller != this))
10061006         then throw("admin only")
10071007         else [IntegerEntry("global_wasInited", 0)]
10081008 
10091009 
10101010 
10111011 @Callable(i)
10121012 func init (assetIdsStr,assetWeightsStr,assetMaxSelloffStr,baseTokenIdStr,poolDomain,fee,vBalancesStr) = {
10131013     let preInitInv = invoke(this, "preInit", [assetIdsStr, assetWeightsStr, assetMaxSelloffStr, baseTokenIdStr, poolDomain, toString(i.caller), fee], nil)
10141014     if ((preInitInv == preInitInv))
10151015         then {
10161016             let vBalances = parstStrToIntList(vBalancesStr)
10171017             func getPaymentAmount (assetIdStr) =             {
10181018                 func handler (accum,payment) =                 if ((getAssetString(payment.assetId) == assetIdStr))
10191019                     then payment.amount
10201020                     else accum
10211021 
10221022                 let $l = i.payments
10231023                 let $s = size($l)
10241024                 let $acc0 = 0
10251025                 func $f4_1 ($a,$i) =                 if (($i >= $s))
10261026                     then $a
10271027                     else handler($a, $l[$i])
10281028 
10291029                 func $f4_2 ($a,$i) =                 if (($i >= $s))
10301030                     then $a
10311031                     else throw("List size exceeds 10")
10321032 
10331033                 $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
10341034                 }
10351035 
10361036             func prepareList () =             {
10371037                 func handler (accum,assetId) =                 {
10381038                     let assetIdStr = getAssetString(assetId)
10391039                     let n = value(indexOf(assetIds, assetId))
10401040                     let paymentAmount = getPaymentAmount(assetIdStr)
10411041                     let assetParams = loadGlobalTokenParams(assetIdStr)
10421042                     let assetParamsUpd = $Tuple8(vBalances[n], paymentAmount, assetParams._3, assetParams._4, assetParams._5, assetParams._6, assetParams._7, assetParams._8)
10431043                     (accum ++ [saveGlobalTokenParams(assetIdStr, assetParamsUpd)])
10441044                     }
10451045 
10461046                 let $l = assetIds
10471047                 let $s = size($l)
10481048                 let $acc0 = nil
10491049                 func $f4_1 ($a,$i) =                 if (($i >= $s))
10501050                     then $a
10511051                     else handler($a, $l[$i])
10521052 
10531053                 func $f4_2 ($a,$i) =                 if (($i >= $s))
10541054                     then $a
10551055                     else throw("List size exceeds 10")
10561056 
10571057                 $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
10581058                 }
10591059 
10601060             func calculatePoolTokensAmount (assetId) =             {
10611061                 func handler (accum,assetId) =                 {
10621062                     func handler2 (accum,n) =                     if ((n == assetId))
10631063                         then value(indexOf(assetIds, n))
10641064                         else accum
10651065 
10661066                     let Token = {
10671067                         let $l = assetIds
10681068                         let $s = size($l)
10691069                         let $acc0 = 1
10701070                         func $f4_1 ($a,$i) =                         if (($i >= $s))
10711071                             then $a
10721072                             else handler2($a, $l[$i])
10731073 
10741074                         func $f4_2 ($a,$i) =                         if (($i >= $s))
10751075                             then $a
10761076                             else throw("List size exceeds 10")
10771077 
10781078                         $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
10791079                         }
10801080                     fraction(accum, pow(vBalances[Token], Decimals[Token], AssetsWeights[Token], AssetsWeightsDecimals, 8, FLOOR), Scale8)
10811081                     }
10821082 
10831083                 let $l = assetIds
10841084                 let $s = size($l)
10851085                 let $acc0 = PoolTokenScale
10861086                 func $f4_1 ($a,$i) =                 if (($i >= $s))
10871087                     then $a
10881088                     else handler($a, $l[$i])
10891089 
10901090                 func $f4_2 ($a,$i) =                 if (($i >= $s))
10911091                     then $a
10921092                     else throw("List size exceeds 10")
10931093 
10941094                 $f4_2($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($f4_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
10951095                 }
10961096 
10971097             if (isShutdown())
10981098                 then throw("contract is on stop")
10991099                 else if ((size(i.payments) == 0))
11001100                     then throw("at least some of the assets should be provided as payment")
11011101                     else if ((tryGetInteger("global_wasInited") > 0))
11021102                         then throw("pool already inited")
11031103                         else {
11041104                             let initialPoolTokens = calculatePoolTokensAmount(assetIds)
11051105                             let notifyInvoke = invoke(poolsHubAddress, "addSelfPool", nil, nil)
11061106                             if ((notifyInvoke == notifyInvoke))
11071107                                 then if ((initialPoolTokens == 0))
11081108                                     then throw("you need a bigger tokens amount to launch the pool")
11091109                                     else (prepareList() ++ [IntegerEntry("global_poolToken_amount", initialPoolTokens), IntegerEntry("global_wasInited", 1), IntegerEntry((toString(i.caller) + "_indexStaked"), initialPoolTokens), IntegerEntry("global_indexStaked", initialPoolTokens)])
11101110                                 else throw("Strict value is not equal to itself.")
11111111                             }
11121112             }
11131113         else throw("Strict value is not equal to itself.")
11141114     }
11151115 
11161116 
11171117 
11181118 @Callable(i)
11191119 func generateIndex (needChange) = if ((size(i.payments) != T))
11201120     then throw(("you need to attach all pool tokens. amount of pool tokens: " + toString(T)))
11211121     else if (!(checkTokensValidity(i.payments)))
11221122         then throw("wrong assets attached")
11231123         else {
11241124             let PIssuedNoMult = getMinPIssued(i.payments)
11251125             let result = handlePoolTokensAdd(PIssuedNoMult, i.payments, i.originCaller, needChange)
11261126             let PIssuedWithMult = fraction(PIssuedNoMult, Scale16, getKMult(), DOWN)
11271127             $Tuple2((((result ++ claimResult(i.caller)._1) ++ mintIndexIfNeeded(PIssuedWithMult)) ++ [IntegerEntry((toString(i.caller) + "_indexStaked"), (tryGetInteger((toString(i.caller) + "_indexStaked")) + PIssuedWithMult)), IntegerEntry("global_indexStaked", (tryGetInteger("global_indexStaked") + PIssuedWithMult)), IntegerEntry("global_poolToken_amount", (tryGetInteger("global_poolToken_amount") + PIssuedWithMult))]), PIssuedWithMult)
11281128             }
11291129 
11301130 
11311131 
11321132 @Callable(i)
11331133 func redeemIndex (poolTokenAmount) = if ((poolTokenAmount > tryGetInteger((toString(i.caller) + "_indexStaked"))))
11341134     then throw("user doesn't have this amount of pool tokens")
11351135     else if (isShutdown())
11361136         then throw("contract is on stop")
11371137         else {
11381138             let PRedeemedWithMult = poolTokenAmount
11391139             let PRedeemedWithNoMult = fraction(PRedeemedWithMult, getKMult(), Scale16, DOWN)
11401140             let result = handlePoolTokensRedeem(PRedeemedWithNoMult, i.caller)
11411141             (((result ++ claimResult(i.caller)._1) ++ [IntegerEntry((toString(i.caller) + "_indexStaked"), (tryGetInteger((toString(i.caller) + "_indexStaked")) - PRedeemedWithMult)), IntegerEntry("global_indexStaked", (tryGetInteger("global_indexStaked") - PRedeemedWithMult)), IntegerEntry("global_poolToken_amount", (tryGetInteger("global_poolToken_amount") - PRedeemedWithMult))]) ++ burnIndexIfNeeded(poolTokenAmount))
11421142             }
11431143 
11441144 
11451145 
11461146 @Callable(i)
11471147 func stakeIndex () = {
11481148     let addressStr = toString(i.originCaller)
11491149     let pmt = i.payments[0]
11501150     if ((value(pmt.assetId) != fromBase58String(tryGetString("static_poolToken_idStr"))))
11511151         then throw("wrong asset attached")
11521152         else indexStakeResult(addressStr, pmt.amount)
11531153     }
11541154 
11551155 
11561156 
11571157 @Callable(i)
11581158 func stakeIndexFor (addressStr) = {
11591159     let pmt = i.payments[0]
11601160     if ((value(pmt.assetId) != fromBase58String(tryGetString("static_poolToken_idStr"))))
11611161         then throw("wrong asset attached")
11621162         else indexStakeResult(addressStr, pmt.amount)
11631163     }
11641164 
11651165 
11661166 
11671167 @Callable(i)
11681168 func unstakeIndex (indexAmount) = {
11691169     func issueIndex () =     {
11701170         let issue = Issue(("PR " + tryGetString("static_poolDomain")), "Puzzle Range Index", tryGetInteger("global_poolToken_amount"), PoolTokenDecimals, true, unit, 0)
11711171         let poolTokenIdStr = toBase58String(calculateAssetId(issue))
11721172         $Tuple2([issue, StringEntry("static_poolToken_idStr", poolTokenIdStr)], poolTokenIdStr)
11731173         }
11741174 
11751175     let $t04005240218 = if ((tryGetString("static_poolToken_idStr") == ""))
11761176         then issueIndex()
11771177         else $Tuple2(nil, tryGetString("static_poolToken_idStr"))
11781178     let poolTokenIssueResult = $t04005240218._1
11791179     let poolTokenIdStr = $t04005240218._2
11801180     let poolTokenId = fromBase58String(poolTokenIdStr)
11811181     let addressStr = toString(i.caller)
11821182     let indexAvailable = tryGetInteger((addressStr + "_indexStaked"))
11831183     if (isShutdown())
11841184         then throw("contract is on stop")
11851185         else if ((indexAmount > indexAvailable))
11861186             then throw("you don't have index tokens available")
11871187             else if (isShutdown())
11881188                 then throw("contract is on stop")
11891189                 else ((poolTokenIssueResult ++ claimResult(addressFromStringValue(addressStr))._1) ++ [IntegerEntry((addressStr + "_indexStaked"), (indexAvailable - indexAmount)), IntegerEntry("global_indexStaked", (tryGetInteger("global_indexStaked") - indexAmount)), ScriptTransfer(i.caller, indexAmount, poolTokenId)])
11901190     }
11911191 
11921192 
11931193 
11941194 @Callable(i)
11951195 func claimIndexRewards () = if (isShutdown())
11961196     then throw("contract is on stop")
11971197     else claimResult(i.caller)
11981198 
11991199 
12001200 
12011201 @Callable(i)
12021202 func evaluateClaim (user) = $Tuple2(nil, claimResult(addressFromStringValue(user))._2)
12031203 
12041204 
12051205 
12061206 @Callable(i)
12071207 func addInterestExternal () = {
12081208     let assetId = value(i.payments[0]).assetId
12091209     let assetIdStr = getAssetString(assetId)
12101210     let amount = i.payments[0].amount
12111211     let stakeTx = stakeIfNeeded(assetIdStr, amount)
12121212     if ((stakeTx == stakeTx))
12131213         then if ((indexOf(assetIds, assetId) == unit))
12141214             then throw("you can only add interest for assets in the pool")
12151215             else {
12161216                 let params = loadGlobalTokenParams(assetIdStr)
12171217                 let interestDelta = calcInterestChange(assetIdStr, amount)
12181218                 let updParams = $Tuple8(params._1, params._2, params._3, (params._4 + interestDelta), (params._5 + amount), params._6, params._7, params._8)
12191219 [saveGlobalTokenParams(assetIdStr, updParams)]
12201220                 }
12211221         else throw("Strict value is not equal to itself.")
12221222     }
12231223 
12241224 
12251225 
12261226 @Callable(i)
12271227 func notifyStakingPayment (assetIdStr,amount) = {
12281228     let assetId = getAssetBytes(assetIdStr)
12291229     if ((indexOf(assetIds, assetId) == unit))
12301230         then throw("you can only add interest for assets in the pool")
12311231         else if ((tryGetString(("static_stakingContract_" + assetIdStr)) != toString(i.caller)))
12321232             then throw("can only be invoked by staker contract")
12331233             else {
12341234                 let params = loadGlobalTokenParams(assetIdStr)
12351235                 let interestDelta = calcInterestChange(assetIdStr, amount)
12361236                 let updParams = $Tuple8(params._1, params._2, params._3, (params._4 + interestDelta), (params._5 + amount), params._6, params._7, params._8)
12371237 [saveGlobalTokenParams(assetIdStr, updParams)]
12381238                 }
12391239     }
12401240 
12411241 
12421242 
12431243 @Callable(i)
12441244 func swap (assetOut,minimum) = {
12451245     let pmt = if ((size(i.payments) == 1))
12461246         then value(i.payments[0])
12471247         else throw("please attach exactly one payment")
12481248     let AmountIn = value(i.payments[0].amount)
12491249     let AssetIn = pmt.assetId
12501250     let AssetOut = getAssetBytes(assetOut)
12511251     let assetIn = getAssetString(AssetIn)
12521252     let scaleIn = (Scale8 / tryGetInteger((("static_" + assetIn) + "_scale")))
12531253     let scaleOut = (Scale8 / tryGetInteger((("static_" + assetOut) + "_scale")))
12541254     let assetInParams = loadGlobalTokenParams(getAssetString(AssetIn))
12551255     let assetOutParams = loadGlobalTokenParams(assetOut)
12561256     let AssetInBalance = assetInParams._1
12571257     let AssetInFactBalance = assetInParams._2
12581258     let assetInFeesEarned = assetInParams._3
12591259     let assetInLastCheckInterest = assetInParams._4
12601260     let AssetOutBalance = assetOutParams._1
12611261     let assetOutFactBalance = assetOutParams._2
12621262     let AssetInBalanceScaled = (AssetInBalance * scaleIn)
12631263     let AssetOutBalanceScaled = (AssetOutBalance * scaleOut)
12641264     let feeAmountIn = fraction(AmountIn, Fee, FeeScale)
12651265     let cleanAmountIn = (AmountIn - feeAmountIn)
12661266     let cleanAmountInScaled = (cleanAmountIn * scaleIn)
12671267     let AmountOut1 = calculateOutAmount(cleanAmountInScaled, AssetIn, AssetOut, AssetInBalanceScaled, AssetOutBalanceScaled)
12681268     let AmountOut = fraction(AmountOut1, 1, scaleOut)
12691269     let AssetOutBalance2 = (AssetOutBalance - AmountOut)
12701270     let AssetInBalance2 = (AssetInBalance + cleanAmountIn)
12711271     if ((minimum > AmountOut))
12721272         then throw("amount to recieve is lower than given one")
12731273         else if ((AssetOut == AssetIn))
12741274             then throw("this swap is not allowed")
12751275             else if ((0 > (assetOutFactBalance - AmountOut)))
12761276                 then throw("contract is out of reserves")
12771277                 else if (isShutdown())
12781278                     then throw("contract is on stop")
12791279                     else if (valueOrElse(getBoolean(poolsHubAddress, ("global_shutdownIn_" + assetIn)), false))
12801280                         then throw("token IN trades are stopped")
12811281                         else if (valueOrElse(getBoolean(poolsHubAddress, ("global_shutdownOut_" + assetOut)), false))
12821282                             then throw("token OUT trades are stopped")
12831283                             else {
12841284                                 let protocolFee = fraction(feeAmountIn, 5, 10)
12851285                                 let lpFee = (feeAmountIn - protocolFee)
12861286                                 let interestDelta = calcInterestChange(assetIn, lpFee)
12871287                                 let stakeTx = stakeIfNeeded(assetIn, (cleanAmountIn + lpFee))
12881288                                 if ((stakeTx == stakeTx))
12891289                                     then {
12901290                                         let unstakeTx = unstakeIfNeeded(assetOut, AmountOut)
12911291                                         if ((unstakeTx == unstakeTx))
12921292                                             then {
12931293                                                 let newBalanceIn = AssetInBalance2
12941294                                                 let newBalanceOut = AssetOutBalance2
12951295                                                 let assetInSelloffData = updSelloffData(assetIn, cleanAmountIn, AssetInBalance, $Tuple3(assetInParams._6, assetInParams._7, assetInParams._8))
12961296                                                 let assetOutSelloffData = updSelloffData(assetOut, -(AmountOut), AssetOutBalance, $Tuple3(assetOutParams._6, assetOutParams._7, assetOutParams._8))
12971297                                                 let assetInFinalParams = $Tuple8(newBalanceIn, (AssetInFactBalance + cleanAmountIn), (assetInFeesEarned + lpFee), (assetInLastCheckInterest + interestDelta), assetInParams._5, assetInSelloffData._1, assetInSelloffData._2, assetInSelloffData._3)
12981298                                                 let assetOutFinalParams = $Tuple8(newBalanceOut, (assetOutFactBalance - AmountOut), assetOutParams._3, assetOutParams._4, assetOutParams._5, assetOutSelloffData._1, assetOutSelloffData._2, assetOutSelloffData._3)
12991299                                                 let assetInChange = saveGlobalTokenParams(assetIn, assetInFinalParams)
13001300                                                 let assetOutChange = saveGlobalTokenParams(assetOut, assetOutFinalParams)
13011301                                                 let feeAssetStr = tryGetString("static_feeToken")
13021302                                                 let feeAssetParams = loadGlobalTokenParams(feeAssetStr)
13031303                                                 let feeTokenBalance = feeAssetParams._1
13041304                                                 let volumeUsdUpdate = calculateUsdValue(AssetIn, AmountIn, AssetInBalance, feeTokenBalance)
13051305                                                 $Tuple2([assetInChange, assetOutChange, ScriptTransfer(i.caller, AmountOut, AssetOut), IntegerEntry("global_volume_usd", (tryGetInteger("global_volume_usd") + volumeUsdUpdate)), ScriptTransfer(feesAddress, protocolFee, getAssetBytes(assetIn))], AmountOut)
13061306                                                 }
13071307                                             else throw("Strict value is not equal to itself.")
13081308                                         }
13091309                                     else throw("Strict value is not equal to itself.")
13101310                                 }
13111311     }
13121312 
13131313 
13141314 
13151315 @Callable(i)
13161316 func swapReadOnly (assetIn,assetOut,AmountIn) = {
13171317     let AssetIn = getAssetBytes(assetIn)
13181318     let AssetOut = getAssetBytes(assetOut)
13191319     let scaleIn = (Scale8 / tryGetInteger((("static_" + assetIn) + "_scale")))
13201320     let scaleOut = (Scale8 / tryGetInteger((("static_" + assetOut) + "_scale")))
13211321     let feeAssetOutStr = tryGetString("static_feeToken")
13221322     let feeAssetOut = if ((feeAssetOutStr == ""))
13231323         then usdnAssetId
13241324         else getAssetBytes(feeAssetOutStr)
13251325     let assetInParams = loadGlobalTokenParams(getAssetString(AssetIn))
13261326     let assetOutParams = loadGlobalTokenParams(assetOut)
13271327     let AssetInBalance = assetInParams._1
13281328     let AssetInFactBalance = assetInParams._2
13291329     let assetInFeesEarned = assetInParams._3
13301330     let assetInLastCheckInterest = assetInParams._4
13311331     let AssetOutBalance = assetOutParams._1
13321332     let assetOutFactBalance = assetOutParams._2
13331333     let AssetInBalanceScaled = (AssetInBalance * scaleIn)
13341334     let AssetOutBalanceScaled = (AssetOutBalance * scaleOut)
13351335     let feeAmountIn = fraction(AmountIn, Fee, FeeScale)
13361336     let cleanAmountIn = (AmountIn - feeAmountIn)
13371337     let cleanAmountInScaled = (cleanAmountIn * scaleIn)
13381338     let AmountOut1 = calculateOutAmount(cleanAmountInScaled, AssetIn, AssetOut, AssetInBalanceScaled, AssetOutBalanceScaled)
13391339     let AmountOut = fraction(AmountOut1, 1, scaleOut)
13401340     let AssetOutBalance2 = (AssetOutBalance - AmountOut)
13411341     let AssetInBalance2 = (AssetInBalance + cleanAmountIn)
13421342     if ((AssetOut == AssetIn))
13431343         then throw("this swap is not allowed")
13441344         else if ((0 > (assetOutParams._2 - AmountOut)))
13451345             then throw("contract is out of reserves")
13461346             else if (isShutdown())
13471347                 then throw("contract is on stop")
13481348                 else $Tuple2(nil, AmountOut)
13491349     }
13501350 
13511351 
13521352 
13531353 @Callable(i)
13541354 func transferOwnership (newOwnerAddress) = if ((toString(i.caller) != tryGetString("static_poolOwner")))
13551355     then throw("this call available only for pool owner")
13561356     else [StringEntry("static_poolOwner", newOwnerAddress)]
13571357 
13581358 
13591359 
13601360 @Callable(i)
13611361 func setFee (newFee) = if ((toString(i.caller) != tryGetString("static_poolOwner")))
13621362     then throw("this call available only for pool owner")
13631363     else [IntegerEntry("static_fee", newFee)]
13641364 
13651365 
13661366 @Verifier(tx)
13671367 func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], masterPubKey)
13681368 
github/deemru/w8io
93.79 ms ◑