tx · EvYmFvPzNTKMBVRMK685kP6Ax4XWfZf8D9iGFK1GG2mK

3Mz6JabBsxZgDscdZHoWmRW5PP8WVJ8r4n2:  -0.02600000 Waves

2024.10.08 10:32 [3317554] smart account 3Mz6JabBsxZgDscdZHoWmRW5PP8WVJ8r4n2 > SELF 0.00000000 Waves

{ "type": 13, "id": "EvYmFvPzNTKMBVRMK685kP6Ax4XWfZf8D9iGFK1GG2mK", "fee": 2600000, "feeAssetId": null, "timestamp": 1728372847148, "version": 2, "chainId": 84, "sender": "3Mz6JabBsxZgDscdZHoWmRW5PP8WVJ8r4n2", "senderPublicKey": "jzHbeZEmXjiRimwbmDUcu7twaP3fRWZYg9YER9bDRUU", "proofs": [ "27aW4SyV59zyDjpyQavJVj7bgcCoS9QREpKQwuiU1T2DDg5j8TuBPbWHMDrnjoXJEF1a5DhDsV77Soio4Kceo2cS" ], "script": "base64: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", "height": 3317554, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: CzaqYqFb1Zd2QMcdPTA616SYMyNAmxhgBg1YZTbyc8e3 Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let VERSION = "PM-0.4.0"
5+
6+let configStr = valueOrElse(getString(this, "configAddress"), "3N91e7wHiV7QadDsx3RUJQxx1etqcAKrfHj")
7+
8+let CONFIG_ADDRESS = if ((configStr == ""))
9+ then this
10+ else Address(fromBase58String(configStr))
11+
12+let AssetsWeightsDecimals = 4
13+
14+let Scale = 10000
15+
16+let Scale8 = 100000000
17+
18+let Scale16 = 10000000000000000
19+
20+let FeeScale = 10000
21+
22+let PoolTokenDecimals = 8
23+
24+let PoolTokenScale = pow(10, 0, PoolTokenDecimals, 0, 0, HALFUP)
25+
26+let InitalWavesLiquidity = Scale8
27+
28+let MIN_STEPS_AMOUNT = valueOrElse(getInteger(CONFIG_ADDRESS, "min_steps_amount"), 1)
29+
30+let MAX_STEPS_AMOUNT = valueOrElse(getInteger(CONFIG_ADDRESS, "max_steps_amount"), 500)
31+
32+let MIN_STEPS_INTERVAL = valueOrElse(getInteger(CONFIG_ADDRESS, "min_steps_interval"), 1)
33+
34+let MAX_STEPS_INTERVAL = valueOrElse(getInteger(CONFIG_ADDRESS, "max_steps_interval"), 10000)
35+
36+let MIN_WEIGHT = valueOrElse(getInteger(CONFIG_ADDRESS, "min_weight"), 100)
37+
38+let MAX_WEIGHT = valueOrElse(getInteger(CONFIG_ADDRESS, "max_weight"), 9900)
39+
40+func tryGetInteger (key) = match getInteger(this, key) {
41+ case b: Int =>
42+ b
43+ case _ =>
44+ 0
45+}
46+
47+
48+func tryGetBinary (key) = match getBinary(this, key) {
49+ case b: ByteVector =>
50+ b
51+ case _ =>
52+ base58''
53+}
54+
55+
56+func tryGetString (key) = match getString(this, key) {
57+ case b: String =>
58+ b
59+ case _ =>
60+ ""
61+}
62+
63+
64+func tryGetStringOrThrow (key) = match getString(this, key) {
65+ case b: String =>
66+ b
67+ case _ =>
68+ throw(("no such key in data storage: " + key))
69+}
70+
71+
72+func getAssetString (assetId) = match assetId {
73+ case b: ByteVector =>
74+ toBase58String(b)
75+ case _ =>
76+ "WAVES"
77+}
78+
79+
80+func getAssetBytes (assetIdStr) = if ((assetIdStr == "WAVES"))
81+ then unit
82+ else fromBase58String(assetIdStr)
83+
84+
85+func getTokenBalance (assetId) = match assetId {
86+ case t: ByteVector =>
87+ assetBalance(this, t)
88+ case _ =>
89+ wavesBalance(this).available
90+}
91+
92+
93+func addAssetBytesToList (accum,item) = (accum ++ [getAssetBytes(item)])
94+
95+
96+func addAssetWeightToList (accum,item) = (accum ++ [tryGetInteger((("static_" + getAssetString(item)) + "_weight"))])
97+
98+
99+func addAssetWeightToStrList (accum,item) = (accum ++ [toString(tryGetInteger((("static_" + item) + "_weight")))])
100+
101+
102+func addAssetDecimalsToList (accum,item) = (accum ++ [tryGetInteger((("static_" + getAssetString(item)) + "_decimals"))])
103+
104+
105+func addAssetScaleToList (accum,item) = (accum ++ [tryGetInteger((("static_" + getAssetString(item)) + "_scale"))])
106+
107+
108+func addIntToList (accum,item) = (accum ++ [parseIntValue(item)])
109+
110+
111+let usdnAssetIdStr = valueOrElse(getString(CONFIG_ADDRESS, "usdnAssetIdStr"), "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p")
112+
113+let puzzleAssetIdStr = valueOrElse(getString(CONFIG_ADDRESS, "puzzleAssetIdStr"), "HEB8Qaw9xrWpWs8tHsiATYGBWDBtP2S7kcPALrMu43AS")
114+
115+let usdtAssetIdStr = valueOrElse(getString(CONFIG_ADDRESS, "usdtAssetIdStr"), "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ")
116+
117+let usdtPptAssetIdStr = valueOrElse(getString(CONFIG_ADDRESS, "usdtPptAssetIdStr"), "9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi")
118+
119+let romeAssetIdStr = valueOrElse(getString(CONFIG_ADDRESS, "romeAssetIdStr"), "AP4Cb5xLYGH6ZigHreCZHoXpQTWDkPsG2BHqfDUx6taJ")
120+
121+let wavesAssetIdStr = "WAVES"
122+
123+let usdnAssetId = fromBase58String(usdnAssetIdStr)
124+
125+let puzzleAssetId = fromBase58String(puzzleAssetIdStr)
126+
127+let usdtAssetId = fromBase58String(usdtAssetIdStr)
128+
129+let usdtPptAssetId = fromBase58String(usdtPptAssetIdStr)
130+
131+let romeAssetId = fromBase58String(romeAssetIdStr)
132+
133+let wavesAssetId = unit
134+
135+let supportedFeeAssetsStr = [usdnAssetIdStr, puzzleAssetIdStr, usdtAssetIdStr, usdtPptAssetIdStr, wavesAssetIdStr, romeAssetIdStr]
136+
137+let oracleAddress = Address(fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "oracleAddress"), "3N91e7wHiV7QadDsx3RUJQxx1etqcAKrfHj")))
138+
139+let feesAddress = Address(fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "feesAddress"), "3N91e7wHiV7QadDsx3RUJQxx1etqcAKrfHj")))
140+
141+let shutdownAddressStr = valueOrElse(getString(CONFIG_ADDRESS, "shutdownAddress"), "3N91e7wHiV7QadDsx3RUJQxx1etqcAKrfHj")
142+
143+let layer2Addresses = valueOrElse(getString(CONFIG_ADDRESS, "layer2Addresses"), "3N91e7wHiV7QadDsx3RUJQxx1etqcAKrfHj")
144+
145+let coldMasterAddress = Address(fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "coldMasterAddress"), "3N91e7wHiV7QadDsx3RUJQxx1etqcAKrfHj")))
146+
147+let factoryAccount = Address(fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "factoryAddress"), "3N1ytAUyhtig9X6F2hHHs1jbzYxr47Yp8Fr")))
148+
149+let masterPubKey = fromBase58String(valueOrElse(getString(CONFIG_ADDRESS, "masterPubKey"), "4z8CKSYQBKkzx7PBb5uBP1YPa6YAHRNTApW1sQVHT5eU"))
150+
151+let T = tryGetInteger("static_tokensAmount")
152+
153+let assetIds = {
154+ let $l = split(tryGetString("static_tokenIds"), ",")
155+ let $s = size($l)
156+ let $acc0 = nil
157+ func $f0_1 ($a,$i) = if (($i >= $s))
158+ then $a
159+ else addAssetBytesToList($a, $l[$i])
160+
161+ func $f0_2 ($a,$i) = if (($i >= $s))
162+ then $a
163+ else throw("List size exceeds 10")
164+
165+ $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)
166+ }
167+
168+let AssetsWeights = {
169+ let $l = assetIds
170+ let $s = size($l)
171+ let $acc0 = nil
172+ func $f1_1 ($a,$i) = if (($i >= $s))
173+ then $a
174+ else addAssetWeightToList($a, $l[$i])
175+
176+ func $f1_2 ($a,$i) = if (($i >= $s))
177+ then $a
178+ else throw("List size exceeds 10")
179+
180+ $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)
181+ }
182+
183+let Decimals = {
184+ let $l = assetIds
185+ let $s = size($l)
186+ let $acc0 = nil
187+ func $f2_1 ($a,$i) = if (($i >= $s))
188+ then $a
189+ else addAssetDecimalsToList($a, $l[$i])
190+
191+ func $f2_2 ($a,$i) = if (($i >= $s))
192+ then $a
193+ else throw("List size exceeds 10")
194+
195+ $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)
196+ }
197+
198+let Scales = {
199+ let $l = assetIds
200+ let $s = size($l)
201+ let $acc0 = nil
202+ func $f3_1 ($a,$i) = if (($i >= $s))
203+ then $a
204+ else addAssetScaleToList($a, $l[$i])
205+
206+ func $f3_2 ($a,$i) = if (($i >= $s))
207+ then $a
208+ else throw("List size exceeds 10")
209+
210+ $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)
211+ }
212+
213+let Fee = tryGetInteger("static_fee")
214+
215+let earnedAssets = assetIds
216+
217+func isShutdown () = {
218+ let shutdownAddress = addressFromString(shutdownAddressStr)
219+ if ((shutdownAddress == unit))
220+ then false
221+ else match getBoolean(value(shutdownAddress), "is_shutdown") {
222+ case x: Boolean =>
223+ x
224+ case _ =>
225+ false
226+ }
227+ }
228+
229+
230+func getCurrentTokenBalance (tokenNum) = {
231+ let tokenIdStr = getAssetString(assetIds[tokenNum])
232+ tryGetInteger((("global_" + tokenIdStr) + "_balance"))
233+ }
234+
235+
236+func getKMult () = match getInteger("static_KMult") {
237+ case x: Int =>
238+ x
239+ case _ =>
240+ Scale16
241+}
242+
243+
244+func getVirtualPoolTokenAmount () = fraction(tryGetInteger("global_poolToken_amount"), getKMult(), Scale16)
245+
246+
247+func getPriceFromOracle (assetIdStr) = match getInteger(oracleAddress, (assetIdStr + "_twap5B")) {
248+ case x: Int =>
249+ x
250+ case _ =>
251+ 1000000
252+}
253+
254+
255+func calculateUsdValue (assetId,amount,aBalance) = {
256+ let assetWeight = tryGetInteger((("static_" + getAssetString(assetId)) + "_weight"))
257+ let feeAssetStr = tryGetString("static_feeToken")
258+ let feeAssetScale = getIntegerValue(this, (("static_" + feeAssetStr) + "_scale"))
259+ let feeAssetNum = value(indexOf(assetIds, getAssetBytes(feeAssetStr)))
260+ let feeAssetWeight = AssetsWeights[feeAssetNum]
261+ let feeAssetBalance = tryGetInteger((("global_" + feeAssetStr) + "_balance"))
262+ let valInFeeAsset = fraction(amount, (feeAssetBalance / feeAssetWeight), (aBalance / assetWeight))
263+ let feeAssetPrice = getPriceFromOracle(feeAssetStr)
264+ fraction(valInFeeAsset, feeAssetPrice, feeAssetScale)
265+ }
266+
267+
268+func handlePoolTokensRedeem (PRedeemed,userAddress) = {
269+ func handleTokenRedeem (accum,tokenId) = {
270+ let Bk = tryGetInteger((("global_" + getAssetString(tokenId)) + "_balance"))
271+ let PSupply = getVirtualPoolTokenAmount()
272+ let tokenDecimals = tryGetInteger((("static_" + getAssetString(tokenId)) + "_scale"))
273+ let psuppl = fraction((toBigInt((PSupply - PRedeemed)) * toBigInt(Scale8)), toBigInt(Scale8), toBigInt(PSupply), DOWN)
274+ let amount = toInt(fraction((toBigInt(Scale16) - psuppl), toBigInt(Bk), toBigInt(Scale16), CEILING))
275+ (accum ++ [IntegerEntry((("global_" + getAssetString(tokenId)) + "_balance"), (Bk - amount)), ScriptTransfer(userAddress, amount, tokenId)])
276+ }
277+
278+ let $l = assetIds
279+ let $s = size($l)
280+ let $acc0 = nil
281+ func $f4_1 ($a,$i) = if (($i >= $s))
282+ then $a
283+ else handleTokenRedeem($a, $l[$i])
284+
285+ func $f4_2 ($a,$i) = if (($i >= $s))
286+ then $a
287+ else throw("List size exceeds 10")
288+
289+ $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)
290+ }
291+
292+
293+func calculateOutAmount (AmountIn,assetIn,assetOut,BalanceIn,BalanceOut) = {
294+ let IndexIn = value(indexOf(assetIds, assetIn))
295+ let IndexOut = value(indexOf(assetIds, assetOut))
296+ if ((IndexIn == IndexOut))
297+ then AmountIn
298+ 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)
299+ }
300+
301+
302+func calculateCurrentAssetInterest (assetId,assetIdStr,aBalance,tokenEarningsLastCheck) = {
303+ let totalStaked = tryGetInteger("global_indexStaked")
304+ let tokenBalanceLastCheck = tokenEarningsLastCheck
305+ let currentBalanceDelta = (getTokenBalance(assetId) - aBalance)
306+ let currentTokenEarnings = if ((currentBalanceDelta > tokenBalanceLastCheck))
307+ then currentBalanceDelta
308+ else tokenBalanceLastCheck
309+ let newEarnings = (currentTokenEarnings - tokenBalanceLastCheck)
310+ let newInterest = if ((totalStaked == 0))
311+ then 0
312+ else fraction(newEarnings, Scale8, totalStaked)
313+ let lastCheckInterest = tryGetInteger((("global_lastCheck_" + assetIdStr) + "_interest"))
314+ (lastCheckInterest + newInterest)
315+ }
316+
317+
318+func claimResult (address) = {
319+ let addressStr = toString(address)
320+ let puzzleAmount = tryGetInteger((addressStr + "_indexStaked"))
321+ func handler (accum,assetId) = {
322+ let assetIdStr = getAssetString(assetId)
323+ let aBalance = tryGetInteger((("global_" + getAssetString(assetId)) + "_balance"))
324+ let tokenEarningsLastCheck = tryGetInteger((("global_lastCheck_" + assetIdStr) + "_earnings"))
325+ let currentTokenInterest = calculateCurrentAssetInterest(assetId, assetIdStr, aBalance, tokenEarningsLastCheck)
326+ let currentTokenEarnings = max([tokenEarningsLastCheck, (getTokenBalance(assetId) - aBalance)])
327+ let rewardAmount = fraction(puzzleAmount, (currentTokenInterest - tryGetInteger((((addressStr + "_lastCheck_") + assetIdStr) + "_interest"))), Scale8)
328+ let transfer = if ((rewardAmount == 0))
329+ then nil
330+ else [ScriptTransfer(address, rewardAmount, assetId)]
331+ $Tuple2(((accum._1 ++ transfer) ++ [IntegerEntry((("global_lastCheck_" + assetIdStr) + "_earnings"), (currentTokenEarnings - rewardAmount)), IntegerEntry((("global_lastCheck_" + assetIdStr) + "_interest"), currentTokenInterest), IntegerEntry((((addressStr + "_lastCheck_") + assetIdStr) + "_interest"), currentTokenInterest)]), (accum._2 + calculateUsdValue(assetId, rewardAmount, aBalance)))
332+ }
333+
334+ let accum = {
335+ let $l = earnedAssets
336+ let $s = size($l)
337+ let $acc0 = $Tuple2(nil, 0)
338+ func $f4_1 ($a,$i) = if (($i >= $s))
339+ then $a
340+ else handler($a, $l[$i])
341+
342+ func $f4_2 ($a,$i) = if (($i >= $s))
343+ then $a
344+ else throw("List size exceeds 10")
345+
346+ $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)
347+ }
348+ $Tuple2((accum._1 ++ [IntegerEntry((addressStr + "_claimedRewardUSD"), (tryGetInteger((addressStr + "_claimedRewardUSD")) + accum._2)), IntegerEntry((addressStr + "_lastClaim"), lastBlock.timestamp)]), accum._2)
349+ }
350+
351+
352+func indexStakeResult (addressStr,amount) = {
353+ let li = claimResult(addressFromStringValue(addressStr))._1
354+ (li ++ [IntegerEntry((addressStr + "_indexStaked"), (tryGetInteger((addressStr + "_indexStaked")) + amount)), IntegerEntry("global_indexStaked", (tryGetInteger("global_indexStaked") + amount))])
355+ }
356+
357+
358+func sum (accum,n) = (accum + parseIntValue(n))
359+
360+
361+func checkFeeAsset (accum,next) = if (if ((indexOf(supportedFeeAssetsStr, next) != unit))
362+ then (accum == "")
363+ else false)
364+ then next
365+ else accum
366+
367+
368+func getTmpRebalanceIds (newAssetIdsLi) = {
369+ let currentAssetIdsLi = split(tryGetString("static_tokenIds"), ",")
370+ let result = newAssetIdsLi
371+ func f (accum,assetId) = if ((indexOf(result, assetId) == unit))
372+ then (accum ++ [assetId])
373+ else accum
374+
375+ let $l = currentAssetIdsLi
376+ let $s = size($l)
377+ let $acc0 = result
378+ func $f4_1 ($a,$i) = if (($i >= $s))
379+ then $a
380+ else f($a, $l[$i])
381+
382+ func $f4_2 ($a,$i) = if (($i >= $s))
383+ then $a
384+ else throw("List size exceeds 10")
385+
386+ $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)
387+ }
388+
389+
390+func checkTokensChange (newAssetIdsLi) = {
391+ let currentAssetIdsLi = split(tryGetString("static_tokenIds"), ",")
392+ func rem (accum,assetId) = if ((indexOf(newAssetIdsLi, assetId) == unit))
393+ then (accum + 1)
394+ else accum
395+
396+ func add (accum,assetId) = if ((indexOf(currentAssetIdsLi, assetId) == unit))
397+ then (accum + 1)
398+ else accum
399+
400+ let removed = {
401+ let $l = currentAssetIdsLi
402+ let $s = size($l)
403+ let $acc0 = 0
404+ func $f4_1 ($a,$i) = if (($i >= $s))
405+ then $a
406+ else rem($a, $l[$i])
407+
408+ func $f4_2 ($a,$i) = if (($i >= $s))
409+ then $a
410+ else throw("List size exceeds 10")
411+
412+ $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)
413+ }
414+ let added = {
415+ let $l = newAssetIdsLi
416+ let $s = size($l)
417+ let $acc0 = 0
418+ func $f5_1 ($a,$i) = if (($i >= $s))
419+ then $a
420+ else add($a, $l[$i])
421+
422+ func $f5_2 ($a,$i) = if (($i >= $s))
423+ then $a
424+ else throw("List size exceeds 10")
425+
426+ $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)
427+ }
428+ (removed + added)
429+ }
430+
431+
432+func validatePayments (assetsList,payments) = {
433+ func getPaymentAssets (accum,next) = if ((0 >= next.amount))
434+ then throw(((("Too low payment amount for " + getAssetString(next.assetId)) + ": ") + toString(next.amount)))
435+ else (accum ++ [getAssetString(next.assetId)])
436+
437+ let paymentList = {
438+ let $l = payments
439+ let $s = size($l)
440+ let $acc0 = nil
441+ func $f4_1 ($a,$i) = if (($i >= $s))
442+ then $a
443+ else getPaymentAssets($a, $l[$i])
444+
445+ func $f4_2 ($a,$i) = if (($i >= $s))
446+ then $a
447+ else throw("List size exceeds 10")
448+
449+ $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)
450+ }
451+ func f1 (accum,next) = if ((indexOf(assetsList, next) == unit))
452+ then throw(((next + " asset is present in payments, but is not in new assets: ") + makeString(assetsList, ",")))
453+ else (accum + 1)
454+
455+ func f2 (accum,next) = if ((indexOf(paymentList, next) == unit))
456+ then throw(((next + " asset is present in new assets, but is not in payments: ") + makeString(paymentList, ",")))
457+ else (accum + 1)
458+
459+ let a1 = {
460+ let $l = paymentList
461+ let $s = size($l)
462+ let $acc0 = 0
463+ func $f5_1 ($a,$i) = if (($i >= $s))
464+ then $a
465+ else f1($a, $l[$i])
466+
467+ func $f5_2 ($a,$i) = if (($i >= $s))
468+ then $a
469+ else throw("List size exceeds 10")
470+
471+ $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)
472+ }
473+ let a2 = {
474+ let $l = assetsList
475+ let $s = size($l)
476+ let $acc0 = 0
477+ func $f6_1 ($a,$i) = if (($i >= $s))
478+ then $a
479+ else f2($a, $l[$i])
480+
481+ func $f6_2 ($a,$i) = if (($i >= $s))
482+ then $a
483+ else throw("List size exceeds 10")
484+
485+ $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)
486+ }
487+ (a1 + a2)
488+ }
489+
490+
491+func swapInternal (assetIn,assetOut,amountIn,minimum,receipientAddressStr) = {
492+ let AmountIn = amountIn
493+ let AssetIn = getAssetBytes(assetIn)
494+ let AssetOut = getAssetBytes(assetOut)
495+ let scaleIn = (Scale8 / tryGetInteger((("static_" + assetIn) + "_scale")))
496+ let scaleOut = (Scale8 / tryGetInteger((("static_" + assetOut) + "_scale")))
497+ let feeAssetOutStr = tryGetString("static_feeToken")
498+ let feeAssetOut = if ((feeAssetOutStr == ""))
499+ then wavesAssetId
500+ else getAssetBytes(feeAssetOutStr)
501+ let AssetInBalance = tryGetInteger((("global_" + getAssetString(AssetIn)) + "_balance"))
502+ let AssetOutBalance = tryGetInteger((("global_" + assetOut) + "_balance"))
503+ let AssetInBalanceScaled = (AssetInBalance * scaleIn)
504+ let AssetOutBalanceScaled = (AssetOutBalance * scaleOut)
505+ let feeAmountIn = fraction(AmountIn, Fee, FeeScale)
506+ let cleanAmountIn = (AmountIn - feeAmountIn)
507+ let cleanAmountInScaled = (cleanAmountIn * scaleIn)
508+ let AmountOut1 = calculateOutAmount(cleanAmountInScaled, AssetIn, AssetOut, AssetInBalanceScaled, AssetOutBalanceScaled)
509+ let AmountOut = fraction(AmountOut1, 1, scaleOut)
510+ let AssetOutBalance2 = (AssetOutBalance - AmountOut)
511+ let AssetInBalance2 = (AssetInBalance + cleanAmountIn)
512+ let feeAssetOutBalance = if ((feeAssetOut == AssetIn))
513+ then AssetInBalance2
514+ else if ((feeAssetOut == AssetOut))
515+ then AssetOutBalance2
516+ else tryGetInteger((("global_" + getAssetString(feeAssetOut)) + "_balance"))
517+ let feeAmountOut = calculateOutAmount(feeAmountIn, AssetIn, feeAssetOut, AssetInBalance, feeAssetOutBalance)
518+ if ((minimum > AmountOut))
519+ then throw("amount to recieve is lower than given one")
520+ else if ((AssetOut == AssetIn))
521+ then throw("this swap is not allowed")
522+ else if ((0 > (AssetOutBalance - AmountOut)))
523+ then throw("contract is out of reserves")
524+ else if (isShutdown())
525+ then throw("contract is on stop")
526+ else {
527+ let creatorFee = fraction(feeAmountOut, 1, 10)
528+ let protocolFee = fraction(feeAmountOut, 4, 10)
529+ let newBalanceIn = AssetInBalance2
530+ let newBalanceOut = (AssetOutBalance2 - (if ((AssetOut == feeAssetOut))
531+ then feeAmountOut
532+ else 0))
533+ let newBalanceFeeAsset = if (if ((feeAssetOut != AssetIn))
534+ then (feeAssetOut != AssetOut)
535+ else false)
536+ then (feeAssetOutBalance - feeAmountOut)
537+ else unit
538+ let assetInChange = IntegerEntry((("global_" + getAssetString(AssetIn)) + "_balance"), newBalanceIn)
539+ let assetOutChange = IntegerEntry((("global_" + assetOut) + "_balance"), newBalanceOut)
540+ let feeAssetOutChange = if ((newBalanceFeeAsset != unit))
541+ then IntegerEntry((("global_" + getAssetString(feeAssetOut)) + "_balance"), value(newBalanceFeeAsset))
542+ else StringEntry("hello", "world")
543+ let volumeUsdUpdate = calculateUsdValue(AssetIn, AmountIn, AssetInBalance)
544+ $Tuple2([assetOutChange, assetInChange, feeAssetOutChange, ScriptTransfer(addressFromStringValue(receipientAddressStr), AmountOut, AssetOut), ScriptTransfer(addressFromStringValue(tryGetString("static_poolOwner")), creatorFee, feeAssetOut), IntegerEntry("global_earnedByOwner", (tryGetInteger("global_earnedByOwner") + creatorFee)), IntegerEntry("global_volume_usd", (tryGetInteger("global_volume_usd") + volumeUsdUpdate)), ScriptTransfer(feesAddress, protocolFee, feeAssetOut)], AmountOut)
545+ }
546+ }
547+
548+
549+@Callable(i)
550+func deInit () = if (isShutdown())
551+ then throw("contract is on stop")
552+ else if ((i.caller != this))
553+ then throw("admin only")
554+ else [IntegerEntry("global_wasInited", 0)]
555+
556+
557+
558+@Callable(i)
559+func initPool (poolDomain,poolOwner,tokenName,tokenDesc,tokenQuantity) = {
560+ func calculatePoolTokensAmount (payments) = {
561+ func handler (accum,pmt) = {
562+ let assetId = pmt.assetId
563+ func handler2 (accum,n) = if ((n == assetId))
564+ then value(indexOf(assetIds, n))
565+ else accum
566+
567+ let Token = {
568+ let $l = assetIds
569+ let $s = size($l)
570+ let $acc0 = 1
571+ func $f4_1 ($a,$i) = if (($i >= $s))
572+ then $a
573+ else handler2($a, $l[$i])
574+
575+ func $f4_2 ($a,$i) = if (($i >= $s))
576+ then $a
577+ else throw("List size exceeds 10")
578+
579+ $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)
580+ }
581+ fraction(accum, pow(pmt.amount, Decimals[Token], AssetsWeights[Token], AssetsWeightsDecimals, 8, FLOOR), Scale8)
582+ }
583+
584+ let $l = payments
585+ let $s = size($l)
586+ let $acc0 = PoolTokenScale
587+ func $f4_1 ($a,$i) = if (($i >= $s))
588+ then $a
589+ else handler($a, $l[$i])
590+
591+ func $f4_2 ($a,$i) = if (($i >= $s))
592+ then $a
593+ else throw("List size exceeds 10")
594+
595+ $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)
596+ }
597+
598+ let meme = Issue(tokenName, tokenDesc, tokenQuantity, 8, false)
599+ let memeId = calculateAssetId(meme)
600+ let memeIdStr = getAssetString(memeId)
601+ let assetWeightsStr = "5000,5000"
602+ let baseTokenIdStr = "WAVES"
603+ let poolOwnerAddress = Address(fromBase58String(poolOwner))
604+ let assetIdsStr = ("WAVES," + memeIdStr)
605+ let assetIdsStrLi = split(assetIdsStr, ",")
606+ let assetIdsLi = {
607+ let $l = assetIdsStrLi
608+ let $s = size($l)
609+ let $acc0 = nil
610+ func $f4_1 ($a,$i) = if (($i >= $s))
611+ then $a
612+ else addAssetBytesToList($a, $l[$i])
613+
614+ func $f4_2 ($a,$i) = if (($i >= $s))
615+ then $a
616+ else throw("List size exceeds 10")
617+
618+ $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)
619+ }
620+ let fee = 100
621+ let feeAssetStr = {
622+ let $l = assetIdsStrLi
623+ let $s = size($l)
624+ let $acc0 = ""
625+ func $f5_1 ($a,$i) = if (($i >= $s))
626+ then $a
627+ else checkFeeAsset($a, $l[$i])
628+
629+ func $f5_2 ($a,$i) = if (($i >= $s))
630+ then $a
631+ else throw("List size exceeds 10")
632+
633+ $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)
634+ }
635+ let pmt = i.payments[0]
636+ let amount = pmt.amount
637+ let pmtAsset = if ((pmt.assetId == unit))
638+ then "WAVES"
639+ else throw("you have to attach some WAVES")
640+ if ((this != this))
641+ then throw("admin only")
642+ else if ((feeAssetStr == ""))
643+ then throw("pool must have one of the supported fee assets in the composition")
644+ else if ((size(poolDomain) > 13))
645+ then throw("too large pool domain")
646+ else if (if ((fee > 500))
647+ then true
648+ else (0 > fee))
649+ then throw("fee value must be between 50 and 500 (0.5-5%)")
650+ else if (isShutdown())
651+ then throw("contract is on stop")
652+ else {
653+ let assetWeightsStrLi = split(assetWeightsStr, ",")
654+ let assetWeightsSum = {
655+ let $l = assetWeightsStrLi
656+ let $s = size($l)
657+ let $acc0 = 0
658+ func $f6_1 ($a,$i) = if (($i >= $s))
659+ then $a
660+ else sum($a, $l[$i])
661+
662+ func $f6_2 ($a,$i) = if (($i >= $s))
663+ then $a
664+ else throw("List size exceeds 10")
665+
666+ $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)
667+ }
668+ func addTokenDataEntries (accum,assetNum) = if ((assetNum >= size(assetIdsLi)))
669+ then accum
670+ else {
671+ let assetDecimals = 8
672+ (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])))])
673+ }
674+
675+ let initialPoolTokens = calculatePoolTokensAmount(i.payments)
676+ if ((assetWeightsSum != 10000))
677+ then throw("sum of token weights must be equal to 10000")
678+ else if ((initialPoolTokens == 0))
679+ then throw("you need a bigger tokens amount to launch the pool")
680+ else {
681+ let poolTokenIssue = Issue(("PZ " + poolDomain), "Puzzle Swap: pool index token", initialPoolTokens, PoolTokenDecimals, true, unit, 0)
682+ let poolTokenId = calculateAssetId(poolTokenIssue)
683+ $Tuple2(((({
684+ let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
685+ let $s = size($l)
686+ let $acc0 = nil
687+ func $f7_1 ($a,$i) = if (($i >= $s))
688+ then $a
689+ else addTokenDataEntries($a, $l[$i])
690+
691+ func $f7_2 ($a,$i) = if (($i >= $s))
692+ then $a
693+ else throw("List size exceeds 10")
694+
695+ $f7_2($f7_1($f7_1($f7_1($f7_1($f7_1($f7_1($f7_1($f7_1($f7_1($f7_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
696+ } ++ [meme, StringEntry("static_tokenIds", assetIdsStr), StringEntry("static_feeToken", feeAssetStr), StringEntry("static_tokenWeights", assetWeightsStr), IntegerEntry("static_tokensAmount", size(assetIdsLi)), StringEntry("static_poolDomain", poolDomain), StringEntry("static_baseTokenId", baseTokenIdStr), StringEntry("static_poolOwner", poolOwner), IntegerEntry("static_fee", fee), IntegerEntry("static_KMult", Scale16), IntegerEntry("global_wasPreInited", 1)]) ++ [IntegerEntry("global_WAVES_balance", InitalWavesLiquidity), IntegerEntry((("global_" + memeIdStr) + "_balance"), tokenQuantity)]) ++ [poolTokenIssue, IntegerEntry("global_poolToken_amount", initialPoolTokens), IntegerEntry("global_wasInited", 1), BinaryEntry("global_poolToken_id", poolTokenId), StringEntry("static_poolToken_idStr", getAssetString(poolTokenId)), IntegerEntry((toString(i.caller) + "_indexStaked"), initialPoolTokens), IntegerEntry("global_indexStaked", initialPoolTokens)]), memeIdStr)
697+ }
698+ }
699+ }
700+
701+
702+
703+@Callable(i)
704+func init (poolDomain,poolOwner,tokenName,tokenDesc,tokenQuantity) = if ((i.caller != factoryAccount))
705+ then throw("admin only")
706+ else {
707+ let inv1 = invoke(this, "initPool", [poolDomain, poolOwner, tokenName, tokenDesc, tokenQuantity], nil)
708+ if ((inv1 == inv1))
709+ then {
710+ let memeIdStr = {
711+ let @ = inv1
712+ if ($isInstanceOf(@, "String"))
713+ then @
714+ else throw(($getType(@) + " couldn't be cast to String"))
715+ }
716+ swapInternal("WAVES", memeIdStr, (i.payments[0].amount - InitalWavesLiquidity), 0, toString(i.caller))._1
717+ }
718+ else throw("Strict value is not equal to itself.")
719+ }
720+
721+
722+
723+@Callable(i)
724+func redeemIndex (sendToOrigin) = {
725+ let pmt = i.payments[0]
726+ if ((pmt.assetId != tryGetBinary("global_poolToken_id")))
727+ then throw("please attach pool share token")
728+ else if (isShutdown())
729+ then throw("contract is on stop")
730+ else {
731+ let PRedeemedWithMult = pmt.amount
732+ let PRedeemedWithNoMult = fraction(PRedeemedWithMult, getKMult(), Scale16, DOWN)
733+ let result = handlePoolTokensRedeem(PRedeemedWithNoMult, if (sendToOrigin)
734+ then i.originCaller
735+ else i.caller)
736+ (result ++ [Burn(tryGetBinary("global_poolToken_id"), PRedeemedWithMult), IntegerEntry("global_poolToken_amount", (tryGetInteger("global_poolToken_amount") - PRedeemedWithMult))])
737+ }
738+ }
739+
740+
741+
742+@Callable(i)
743+func stakeIndex () = {
744+ let addressStr = toString(i.originCaller)
745+ let pmt = i.payments[0]
746+ if ((value(pmt.assetId) != tryGetBinary("global_poolToken_id")))
747+ then throw("wrong asset attached")
748+ else indexStakeResult(addressStr, pmt.amount)
749+ }
750+
751+
752+
753+@Callable(i)
754+func stakeIndexFor (addressStr) = {
755+ let pmt = i.payments[0]
756+ if ((value(pmt.assetId) != tryGetBinary("global_poolToken_id")))
757+ then throw("wrong asset attached")
758+ else indexStakeResult(addressStr, pmt.amount)
759+ }
760+
761+
762+
763+@Callable(i)
764+func unstakeIndex (indexAmount) = {
765+ let addressStr = if ((indexOf(layer2Addresses, toString(i.caller)) != unit))
766+ then toString(i.originCaller)
767+ else toString(i.caller)
768+ let indexAvailable = tryGetInteger((addressStr + "_indexStaked"))
769+ if (isShutdown())
770+ then throw("contract is on stop")
771+ else if ((indexAmount > indexAvailable))
772+ then throw("you don't have index tokens available")
773+ else if (isShutdown())
774+ then throw("contract is on stop")
775+ else (claimResult(addressFromStringValue(addressStr))._1 ++ [IntegerEntry((addressStr + "_indexStaked"), (indexAvailable - indexAmount)), IntegerEntry("global_indexStaked", (tryGetInteger("global_indexStaked") - indexAmount)), ScriptTransfer(i.caller, indexAmount, getBinaryValue("global_poolToken_id"))])
776+ }
777+
778+
779+
780+@Callable(i)
781+func claimIndexRewards () = if (isShutdown())
782+ then throw("contract is on stop")
783+ else claimResult(i.caller)
784+
785+
786+
787+@Callable(i)
788+func evaluateClaim (user) = $Tuple2(nil, claimResult(addressFromStringValue(user))._2)
789+
790+
791+
792+@Callable(i)
793+func swap (assetOut,minimum) = {
794+ let pmt = if ((size(i.payments) == 1))
795+ then value(i.payments[0])
796+ else throw("please attach exactly one payment")
797+ let AmountIn = value(i.payments[0].amount)
798+ let AssetIn = i.payments[0].assetId
799+ swapInternal(getAssetString(AssetIn), assetOut, AmountIn, minimum, toString(i.caller))
800+ }
801+
802+
803+
804+@Callable(i)
805+func swapReadOnly (assetIn,assetOut,AmountIn) = {
806+ let AssetIn = getAssetBytes(assetIn)
807+ let AssetOut = getAssetBytes(assetOut)
808+ let scaleIn = (Scale8 / tryGetInteger((("static_" + assetIn) + "_scale")))
809+ let scaleOut = (Scale8 / tryGetInteger((("static_" + assetOut) + "_scale")))
810+ let feeAssetOutStr = tryGetString("static_feeToken")
811+ let feeAssetOut = if ((feeAssetOutStr == ""))
812+ then usdnAssetId
813+ else getAssetBytes(feeAssetOutStr)
814+ let AssetInBalance = tryGetInteger((("global_" + getAssetString(AssetIn)) + "_balance"))
815+ let AssetOutBalance = tryGetInteger((("global_" + assetOut) + "_balance"))
816+ let AssetInBalanceScaled = (AssetInBalance * scaleIn)
817+ let AssetOutBalanceScaled = (AssetOutBalance * scaleOut)
818+ let feeAmountIn = fraction(AmountIn, Fee, FeeScale)
819+ let cleanAmountIn = (AmountIn - feeAmountIn)
820+ let cleanAmountInScaled = (cleanAmountIn * scaleIn)
821+ let AmountOut1 = calculateOutAmount(cleanAmountInScaled, AssetIn, AssetOut, AssetInBalanceScaled, AssetOutBalanceScaled)
822+ let AmountOut = fraction(AmountOut1, 1, scaleOut)
823+ let AssetOutBalance2 = (AssetOutBalance - AmountOut)
824+ let AssetInBalance2 = (AssetInBalance + cleanAmountIn)
825+ let feeAssetOutBalance = if ((feeAssetOut == AssetIn))
826+ then AssetInBalance2
827+ else if ((feeAssetOut == AssetOut))
828+ then AssetOutBalance2
829+ else tryGetInteger((("global_" + getAssetString(feeAssetOut)) + "_balance"))
830+ let feeAmountOut = calculateOutAmount(feeAmountIn, AssetIn, feeAssetOut, AssetInBalance, feeAssetOutBalance)
831+ if ((AssetOut == AssetIn))
832+ then throw("this swap is not allowed")
833+ else if ((0 > (AssetOutBalance - AmountOut)))
834+ then throw("contract is out of reserves")
835+ else if (isShutdown())
836+ then throw("contract is on stop")
837+ else $Tuple2(nil, AmountOut)
838+ }
839+
840+
841+
842+@Callable(i)
843+func transferOwnership (newOwnerAddress) = if ((toString(i.caller) != tryGetString("static_poolOwner")))
844+ then throw("this call available only for pool owner")
845+ else [StringEntry("static_poolOwner", newOwnerAddress)]
846+
847+

github/deemru/w8io/026f985 
40.48 ms