tx · 6zMrSnh1QwfVD8rRMvm6MpzapTu8SPYuDjovuK4BKxq8

3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP:  -0.03000000 Waves

2023.08.18 10:24 [2715739] smart account 3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6zMrSnh1QwfVD8rRMvm6MpzapTu8SPYuDjovuK4BKxq8",
    "fee": 3000000,
    "feeAssetId": null,
    "timestamp": 1692343513613,
    "version": 1,
    "sender": "3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP",
    "senderPublicKey": "AoKo4segKHU4DeJnxXQYJj2u7J6XJeux6r8KLW52cd2Q",
    "proofs": [
        "3jraVKHLpZSJv6dJ9Aux2s9Mjk5bJQyXoKHPfY5AwSd5HEJ9bQkk75Kvtoqeh3FEfoVfraEYtsQ3LtBBB2pNPGTp"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2715739,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: C6nJEhHC3gt1HYmX8YKGzcowMBD5bxC3E9FJhmPW4W6T
Next: 2ERVgNQCKUuV6ebrqq37auJs3tAFugjYQbWrY6qoxNmo

Full: 

OldNewDifferences
1-{-# STDLIB_VERSION 6 #-}
1+{-# STDLIB_VERSION 7 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
4-func test () = {
5-    let list = [$Tuple2("a", 0), $Tuple2("b", 1), $Tuple2("c", 2)]
6-    func bar (acc,next) =     {
7-        let $t0191208 = next
8-        let a = $t0191208._1
9-        let b = $t0191208._2
10-        let c = invoke(this, "foo", [a, b], nil)
11-        if ((c == c))
12-            then 0
13-            else throw("Strict value is not equal to itself.")
4+let SEP = "__"
5+
6+let CONTRACT_NAME = "calculator.ride"
7+
8+let SCALE8 = 100000000
9+
10+let PENDING = "PENDING"
11+
12+let WAVES = "WAVES"
13+
14+func wrapErr (s) = ((CONTRACT_NAME + ": ") + s)
15+
16+
17+func throwErr (s) = throw(wrapErr(s))
18+
19+
20+func assetIdToString (assetId) = match assetId {
21+    case b: ByteVector => 
22+        toBase58String(b)
23+    case _: Unit => 
24+        WAVES
25+    case _ => 
26+        throw("Match error")
27+}
28+
29+
30+func stringToAssetId (s) = if ((s == WAVES))
31+    then unit
32+    else fromBase58String(s)
33+
34+
35+func abs (n) = if ((0 > n))
36+    then -(n)
37+    else n
38+
39+
40+func keyFactoryAddress () = makeString(["%s", "factory"], SEP)
41+
42+
43+func keyManagerPublicKey () = makeString(["%s", "managerPublicKey"], SEP)
44+
45+
46+func keyLpAssetId () = makeString(["%s", "lpAssetId"], SEP)
47+
48+
49+func keyProxyTreasuryAddress () = makeString(["%s", "proxyTreasury"], SEP)
50+
51+
52+func keyMainTreasuryAddress () = makeString(["%s", "mainTreasury"], SEP)
53+
54+
55+func keyBusinessTreasuryAddress () = makeString(["%s", "businessTreasury"], SEP)
56+
57+
58+func keyBusinessTreasuryPart () = makeString(["%s", "businessTreasuryPart"], SEP)
59+
60+
61+func keyPowerContractAddress () = makeString(["%s", "powerContract"], SEP)
62+
63+
64+func keyPowerShareRatio () = makeString(["%s", "powerShareRatio"], SEP)
65+
66+
67+func keyPowerAssetId () = makeString(["%s", "powerAssetId"], SEP)
68+
69+
70+func keyInvested (assetId) = makeString(["%s%s", "invested", assetIdToString(assetId)], SEP)
71+
72+
73+func keyDonated (assetId) = makeString(["%s%s", "donated", assetIdToString(assetId)], SEP)
74+
75+
76+func keyAvailable (userAddress) = makeString(["%s%s", "available", toString(userAddress)], SEP)
77+
78+
79+func keyClaimed (userAddress) = makeString(["%s%s", "claimed", toString(userAddress)], SEP)
80+
81+
82+func keyCurrentPeriod () = makeString(["%s", "currentPeriod"], SEP)
83+
84+
85+func keyPriceForPeriod (period) = makeString(["%s%d", "price", toString(period)], SEP)
86+
87+
88+func keyStartHeight (period) = makeString(["%s%d", "startHeight", toString(period)], SEP)
89+
90+
91+func keyPowerManagerBonus (period) = makeString(["%s%d", "powerManagerBonus", toString(period)], SEP)
92+
93+
94+func keyClaimWavesAmount (period) = makeString(["%s%d", "claimWavesAmount", toString(period)], SEP)
95+
96+
97+func keyPeriodLength () = "%s__periodLength"
98+
99+
100+func keyInvestPeriodLength () = "%s__investPeriodLength"
101+
102+
103+func keyBlockProcessingReward () = "%s__blockProcessingReward"
104+
105+
106+func keyNextBlockToProcess () = "%s__nextBlockToProcess"
107+
108+
109+func keyBlockProcessed (height) = makeString(["%s%d", "blockProcessed", toString(height)], SEP)
110+
111+
112+func keyWithdrawal () = "%s__withdrawal"
113+
114+
115+func keyWithdrawalRequest (userAddress,txId) = makeString(["%s%s%s", "withdrawal", toString(userAddress), toBase58String(txId)], SEP)
116+
117+
118+func valueWithdrawalRequest (status,lpAssetAmount,targetPeriod,claimTxId) = {
119+    let claimTxIdStr =     match claimTxId {
120+        case b: ByteVector => 
121+            toBase58String(b)
122+        case _: Unit => 
123+            "SOON"
124+        case _ => 
125+            throw("Match error")
126+    }
127+    makeString(["%s%d%d%s", status, toString(lpAssetAmount), toString(targetPeriod), claimTxIdStr], SEP)
128+    }
129+
130+
131+func keyWithdrawalHistory (userAddress,txId) = makeString(["%s%s%s", "withdrawalHistory", toString(userAddress), toBase58String(txId)], SEP)
132+
133+
134+func keyPeriodWithdrawalAssetIds (period) = makeString(["%s%d", "periodReward", toString(period)], SEP)
135+
136+
137+func keyPeriodWithdrawalAmounts (period) = makeString(["%s%d", "periodRewardAmount", toString(period)], SEP)
138+
139+
140+func parseWithdrawalRequestValueOrFail (s) = {
141+    let parts = split(s, SEP)
142+    if ((size(parts) == 5))
143+        then {
144+            let status = parts[1]
145+            let lpAssetAmount = valueOrErrorMessage(parseInt(parts[2]), wrapErr("invalid lpAssetAmount"))
146+            let targetPeriod = valueOrErrorMessage(parseInt(parts[3]), wrapErr("invalid targetPeriod"))
147+            let claimTxId = parts[4]
148+            $Tuple4(status, lpAssetAmount, targetPeriod, claimTxId)
149+            }
150+        else throwErr("invalid withdrawal request value")
151+    }
152+
153+
154+let factoryAddressOption = match getString(this, keyFactoryAddress()) {
155+    case s: String => 
156+        addressFromString(s)
157+    case _: Unit => 
158+        unit
159+    case _ => 
160+        throw("Match error")
161+}
162+
163+let factoryAddressOrFail = valueOrErrorMessage(factoryAddressOption, wrapErr("invalid factory address"))
164+
165+let lpAssetIdOption = match factoryAddressOption {
166+    case a: Address => 
167+        match getString(a, keyLpAssetId()) {
168+            case s: String => 
169+                fromBase58String(s)
170+            case _: Unit => 
171+                unit
172+            case _ => 
173+                throw("Match error")
14174         }
175+    case _: Unit => 
176+        unit
177+    case _ => 
178+        throw("Match error")
179+}
15180 
16-    let $l = list
17-    let $s = size($l)
18-    let $acc0 = 0
19-    func $f0_1 ($a,$i) =     if (($i >= $s))
20-        then $a
21-        else bar($a, $l[$i])
181+let lpAssetIdOrFail = valueOrErrorMessage(lpAssetIdOption, wrapErr("invalid lpAssetId"))
22182 
23-    func $f0_2 ($a,$i) =     if (($i >= $s))
24-        then $a
25-        else throw("List size exceeds 10")
183+let proxyTreasuryAddressOption = match factoryAddressOption {
184+    case a: Address => 
185+        match getString(a, keyProxyTreasuryAddress()) {
186+            case s: String => 
187+                addressFromString(s)
188+            case _: Unit => 
189+                unit
190+            case _ => 
191+                throw("Match error")
192+        }
193+    case _: Unit => 
194+        unit
195+    case _ => 
196+        throw("Match error")
197+}
26198 
27-    $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)
199+let proxyTreasuryAddressOrFail = valueOrErrorMessage(proxyTreasuryAddressOption, wrapErr("invalid proxy treasury address"))
200+
201+let mainTreasuryAddressOption = match factoryAddressOption {
202+    case a: Address => 
203+        match getString(a, keyMainTreasuryAddress()) {
204+            case s: String => 
205+                addressFromString(s)
206+            case _: Unit => 
207+                unit
208+            case _ => 
209+                throw("Match error")
210+        }
211+    case _: Unit => 
212+        unit
213+    case _ => 
214+        throw("Match error")
215+}
216+
217+let businessTreasuryAddressOption = match factoryAddressOption {
218+    case a: Address => 
219+        match getString(a, keyBusinessTreasuryAddress()) {
220+            case s: String => 
221+                addressFromString(s)
222+            case _: Unit => 
223+                unit
224+            case _ => 
225+                throw("Match error")
226+        }
227+    case _: Unit => 
228+        unit
229+    case _ => 
230+        throw("Match error")
231+}
232+
233+let mainTreasuryAddressOrFail = valueOrErrorMessage(mainTreasuryAddressOption, wrapErr("invalid main treasury address"))
234+
235+let businessTreasuryAddressOrFail = valueOrErrorMessage(businessTreasuryAddressOption, wrapErr("invalid business treasury address"))
236+
237+let powerContractAddressOption = match factoryAddressOption {
238+    case a: Address => 
239+        match getString(a, keyPowerContractAddress()) {
240+            case s: String => 
241+                addressFromString(s)
242+            case _: Unit => 
243+                unit
244+            case _ => 
245+                throw("Match error")
246+        }
247+    case _: Unit => 
248+        unit
249+    case _ => 
250+        throw("Match error")
251+}
252+
253+let powerContractAddressOrFail = valueOrErrorMessage(powerContractAddressOption, wrapErr("invalid power contract address"))
254+
255+let powerAssetIdStringOrFail = valueOrErrorMessage(getString(factoryAddressOrFail, keyPowerAssetId()), wrapErr("power asset id not found"))
256+
257+func getManagerPublicKeyOrUnit () = match factoryAddressOption {
258+    case fa: Address => 
259+        match getString(fa, keyManagerPublicKey()) {
260+            case pub: String => 
261+                fromBase58String(pub)
262+            case _ => 
263+                unit
264+        }
265+    case _ => 
266+        unit
267+}
268+
269+
270+func onlyAddress (i,address) = if ((i.caller == address))
271+    then true
272+    else throwErr("permission denied")
273+
274+
275+func onlyFactory (i) = onlyAddress(i, factoryAddressOrFail)
276+
277+
278+func rewardForOption (rewards,target) = {
279+    let s = size(rewards)
280+    let $t066316656 = rewards[0]
281+    let a0 = $t066316656._1
282+    let r0 = $t066316656._2
283+    let $t066596684 = rewards[1]
284+    let a1 = $t066596684._1
285+    let r1 = $t066596684._2
286+    let $t066876712 = rewards[2]
287+    let a2 = $t066876712._1
288+    let r2 = $t066876712._2
289+    if (if ((s > 0))
290+        then (a0 == target)
291+        else false)
292+        then r0
293+        else if (if ((s > 1))
294+            then (a1 == target)
295+            else false)
296+            then r1
297+            else if (if ((s > 2))
298+                then (a2 == target)
299+                else false)
300+                then r2
301+                else unit
302+    }
303+
304+
305+func calculatePrice (lpPartInWaves) = {
306+    let lpAssetAmountToBurn = valueOrElse(getInteger(factoryAddressOrFail, keyWithdrawal()), 0)
307+    let lpAssetQuantity = valueOrErrorMessage(assetInfo(lpAssetIdOrFail), wrapErr("invalid lpAsset info")).quantity
308+    let newPrice = fraction(lpPartInWaves, SCALE8, (lpAssetQuantity - lpAssetAmountToBurn))
309+    let checkIfPriceNotZero = if ((newPrice != 0))
310+        then true
311+        else throwErr("LP price cannot be 0")
312+    if ((checkIfPriceNotZero == checkIfPriceNotZero))
313+        then {
314+            let lpAssetFinalQuantity = (lpAssetQuantity - lpAssetAmountToBurn)
315+            $Tuple3(newPrice, lpAssetAmountToBurn, lpAssetFinalQuantity)
316+            }
317+        else throw("Strict value is not equal to itself.")
318+    }
319+
320+
321+func claimCollateralINTERNAL (userAddressBytes,txId) = {
322+    let userAddress = Address(userAddressBytes)
323+    let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
324+    let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
325+    let $t078797992 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
326+    let status = $t078797992._1
327+    let lpAssetAmount = $t078797992._2
328+    let targetPeriod = $t078797992._3
329+    let claimTxId = $t078797992._4
330+    if ((targetPeriod > currentPeriodOrFail))
331+        then throwErr("invalid withdrawal request period")
332+        else {
333+            let priceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(targetPeriod)), wrapErr("invalid price"))
334+            let wavesAmount = if ((priceOrFail > 0))
335+                then fraction(lpAssetAmount, priceOrFail, SCALE8)
336+                else 0
337+            let assetsString = getStringValue(factoryAddressOrFail, keyPeriodWithdrawalAssetIds(currentPeriodOrFail))
338+            let amountsString = getStringValue(factoryAddressOrFail, keyPeriodWithdrawalAmounts(currentPeriodOrFail))
339+            $Tuple6(userAddress, lpAssetAmount, targetPeriod, wavesAmount, assetsString, amountsString)
340+            }
341+    }
342+
343+
344+func claimCollateralREADONLYStringResponse (userAddressBytes,txId) = {
345+    let $t087798945 = claimCollateralINTERNAL(userAddressBytes, txId)
346+    let userAddress = $t087798945._1
347+    let lpAssetAmount = $t087798945._2
348+    let targetPeriod = $t087798945._3
349+    let wavesAmount = $t087798945._4
350+    let assetsString = $t087798945._5
351+    let amountsString = $t087798945._6
352+    let assets = makeString(removeByIndex(split_51C(assetsString, SEP), 0), ":")
353+    let amounts = makeString(removeByIndex(split_51C(amountsString, SEP), 0), ":")
354+    makeString(["%d%s%s", toString(wavesAmount), assets, amounts], SEP)
28355     }
29356 
30357 
31358 @Callable(i)
32-func foo (a,b) = [IntegerEntry(a, b)]
359+func claimLP (userAddressBytes) = {
360+    let checkCaller = onlyFactory(i)
361+    if ((checkCaller == checkCaller))
362+        then {
363+            let userAddress = Address(userAddressBytes)
364+            let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(userAddress)), 0)
365+            let claimed = valueOrElse(getInteger(factoryAddressOrFail, keyClaimed(userAddress)), 0)
366+            let factoryActions = if ((available > 0))
367+                then [invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, available, lpAssetIdOrFail], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(userAddress), 0], nil), invoke(factoryAddressOrFail, "integerEntry", [keyClaimed(userAddress), (claimed + available)], nil)]
368+                else throwErr("nothing to claim")
369+            $Tuple2(nil, factoryActions)
370+            }
371+        else throw("Strict value is not equal to itself.")
372+    }
33373 
34374 
35375 
36376 @Callable(i)
37-func a () = {
38-    let a = test()
39-    if ((a == a))
40-        then nil
377+func finalize (userAddressBytes,donationPartInWaves,lpPartInWaves,claimPartInWaves,powerStakePartInWaves) = {
378+    let checkCaller = onlyFactory(i)
379+    if ((checkCaller == checkCaller))
380+        then {
381+            let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
382+            let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
383+            let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
384+            let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
385+            let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
386+            let periodEndHeight = ((currentStartHeight + periodLength) - 1)
387+            let checks = [if ((i.originCaller == mainTreasuryAddressOrFail))
388+                then true
389+                else throwErr("permission denied"), if ((nextBlockToProcess > periodEndHeight))
390+                then true
391+                else throwErr("unprocessed blocks"), if ((donationPartInWaves >= 0))
392+                then true
393+                else throwErr("invalid donation part"), if ((lpPartInWaves >= 0))
394+                then true
395+                else throwErr("invalid lp part"), if ((claimPartInWaves >= 0))
396+                then true
397+                else throwErr("invalid claim part"), if ((powerStakePartInWaves >= 0))
398+                then true
399+                else throwErr("invalid PWR stake part")]
400+            if ((checks == checks))
401+                then {
402+                    let $t01150211607 = calculatePrice(lpPartInWaves)
403+                    let newPrice = $t01150211607._1
404+                    let lpAssetAmountToBurn = $t01150211607._2
405+                    let lpAssetFinalQuantity = $t01150211607._3
406+                    let newPeriod = (currentPeriodOrFail + 1)
407+                    func addNewAction (actions,payment) =                     {
408+                        let $t01175511817 = actions
409+                        let scriptTransfers = $t01175511817._1
410+                        let assetIdsString = $t01175511817._2
411+                        let amountsString = $t01175511817._3
412+                        let paymentAmount = payment.amount
413+                        let paymentAssetId = payment.assetId
414+                        let newAssetIdsString = ("%s" + makeString([assetIdsString, assetIdToString(paymentAssetId)], SEP))
415+                        let newAmountsString = ("%d" + makeString([amountsString, toString(paymentAmount)], SEP))
416+                        let newScriptTransfer = ScriptTransfer(factoryAddressOrFail, paymentAmount, paymentAssetId)
417+                        $Tuple3((scriptTransfers :+ newScriptTransfer), newAssetIdsString, newAmountsString)
418+                        }
419+
420+                    let $t01227712368 = {
421+                        let $l = i.payments
422+                        let $s = size($l)
423+                        let $acc0 = $Tuple3(nil, "", "")
424+                        func $f0_1 ($a,$i) =                         if (($i >= $s))
425+                            then $a
426+                            else addNewAction($a, $l[$i])
427+
428+                        func $f0_2 ($a,$i) =                         if (($i >= $s))
429+                            then $a
430+                            else throw("List size exceeds 10")
431+
432+                        $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)
433+                        }
434+                    let scriptTransfers = $t01227712368._1
435+                    let AssetIds = $t01227712368._2
436+                    let Amounts = $t01227712368._3
437+                    let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyPowerManagerBonus(currentPeriodOrFail), powerStakePartInWaves], nil), invoke(factoryAddressOrFail, "integerEntry", [keyClaimWavesAmount(currentPeriodOrFail), claimPartInWaves], nil), invoke(factoryAddressOrFail, "integerEntry", [keyCurrentPeriod(), newPeriod], nil), invoke(factoryAddressOrFail, "integerEntry", [keyPriceForPeriod(newPeriod), newPrice], nil), invoke(factoryAddressOrFail, "integerEntry", [keyStartHeight(newPeriod), (periodEndHeight + 1)], nil), invoke(factoryAddressOrFail, "burn", [lpAssetAmountToBurn], nil), invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawal(), 0], nil), invoke(factoryAddressOrFail, "integerEntry", [keyInvested(unit), lpPartInWaves], nil), invoke(factoryAddressOrFail, "integerEntry", [keyDonated(unit), donationPartInWaves], nil), invoke(factoryAddressOrFail, "stringEntry", [keyPeriodWithdrawalAssetIds(newPeriod), AssetIds], nil), invoke(factoryAddressOrFail, "stringEntry", [keyPeriodWithdrawalAmounts(newPeriod), Amounts], nil)]
438+                    $Tuple2(scriptTransfers, factoryActions)
439+                    }
440+                else throw("Strict value is not equal to itself.")
441+            }
41442         else throw("Strict value is not equal to itself.")
42443     }
43444 
445+
446+
447+@Callable(i)
448+func finalizeREADONLY (donationPartInWaves,lpPartInWaves,claimPartInWaves,powerStakePartInWaves) = {
449+    let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
450+    let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
451+    let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
452+    let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
453+    let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
454+    let periodEndHeight = ((currentStartHeight + periodLength) - 1)
455+    let checks = [if ((nextBlockToProcess > periodEndHeight))
456+        then true
457+        else throwErr("unprocessed blocks"), if ((donationPartInWaves >= 0))
458+        then true
459+        else throwErr("invalid donation part"), if ((lpPartInWaves >= 0))
460+        then true
461+        else throwErr("invalid lp part"), if ((claimPartInWaves >= 0))
462+        then true
463+        else throwErr("invalid claim part"), if ((powerStakePartInWaves >= 0))
464+        then true
465+        else throwErr("invalid PWR stake part")]
466+    if ((checks == checks))
467+        then {
468+            let $t01524715352 = calculatePrice(lpPartInWaves)
469+            let newPrice = $t01524715352._1
470+            let lpAssetAmountToBurn = $t01524715352._2
471+            let lpAssetFinalQuantity = $t01524715352._3
472+            $Tuple2(nil, $Tuple6(claimPartInWaves, lpPartInWaves, donationPartInWaves, newPrice, lpAssetAmountToBurn, lpAssetFinalQuantity))
473+            }
474+        else throw("Strict value is not equal to itself.")
475+    }
476+
477+
478+
479+@Callable(i)
480+func invest (userAddressBytes) = {
481+    let checkCaller = onlyFactory(i)
482+    if ((checkCaller == checkCaller))
483+        then {
484+            let userAddress = Address(userAddressBytes)
485+            let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
486+            let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
487+            let investPeriodLength = getIntegerValue(factoryAddressOrFail, keyInvestPeriodLength())
488+            let heightCheck = if (((currentStartHeight + investPeriodLength) > height))
489+                then true
490+                else throwErr("too late to invest in this period")
491+            if ((heightCheck == heightCheck))
492+                then {
493+                    let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
494+                    let payment = if ((size(i.payments) == 1))
495+                        then i.payments[0]
496+                        else throwErr("invalid payments")
497+                    let $t01646116638 = if (if ((payment.assetId == unit))
498+                        then (payment.amount > 0)
499+                        else false)
500+                        then $Tuple2(payment.amount, payment.assetId)
501+                        else throwErr("invalid payment amount")
502+                    let paymentAmount = $t01646116638._1
503+                    let paymentAssetId = $t01646116638._2
504+                    let treasuryPart = valueOrElse(getInteger(factoryAddressOrFail, keyBusinessTreasuryPart()), 0)
505+                    let paymentsWithoutTreasuryPart = fraction(paymentAmount, (SCALE8 - treasuryPart), SCALE8)
506+                    let lpAssetAmount = if ((currentPriceOrFail > 0))
507+                        then fraction(paymentsWithoutTreasuryPart, SCALE8, currentPriceOrFail)
508+                        else 0
509+                    let invested = valueOrElse(getInteger(factoryAddressOrFail, keyInvested(unit)), 0)
510+                    let actions = [ScriptTransfer(mainTreasuryAddressOrFail, paymentsWithoutTreasuryPart, paymentAssetId), ScriptTransfer(businessTreasuryAddressOrFail, treasuryPart, paymentAssetId)]
511+                    let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyInvested(unit), (invested + paymentsWithoutTreasuryPart)], nil), invoke(factoryAddressOrFail, "reissue", [lpAssetAmount], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil)]
512+                    $Tuple2(actions, factoryActions)
513+                    }
514+                else throw("Strict value is not equal to itself.")
515+            }
516+        else throw("Strict value is not equal to itself.")
517+    }
518+
519+
520+
521+@Callable(i)
522+func withdraw (userAddressBytes) = {
523+    let checkCaller = onlyFactory(i)
524+    if ((checkCaller == checkCaller))
525+        then {
526+            let userAddress = Address(userAddressBytes)
527+            let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
528+            let payment = if ((size(i.payments) == 1))
529+                then i.payments[0]
530+                else throwErr(wrapErr("invalid payments"))
531+            let paymentAssetId = if ((payment.assetId == lpAssetIdOrFail))
532+                then lpAssetIdOrFail
533+                else throwErr("invalid payment asset")
534+            let paymentAmount = if ((payment.amount > 0))
535+                then payment.amount
536+                else throwErr("invalid payment amount")
537+            let withdrawal = valueOrElse(getInteger(factoryAddressOrFail, keyWithdrawal()), 0)
538+            let actions = [ScriptTransfer(factoryAddressOrFail, paymentAmount, paymentAssetId)]
539+            let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawal(), (withdrawal + paymentAmount)], nil), invoke(factoryAddressOrFail, "stringEntry", [keyWithdrawalRequest(userAddress, i.transactionId), valueWithdrawalRequest(PENDING, paymentAmount, (currentPeriodOrFail + 1), unit)], nil)]
540+            if ((factoryActions == factoryActions))
541+                then $Tuple2(actions, factoryActions)
542+                else throw("Strict value is not equal to itself.")
543+            }
544+        else throw("Strict value is not equal to itself.")
545+    }
546+
547+
548+
549+@Callable(i)
550+func cancelWithdraw (userAddressBytes,txId) = {
551+    let checkCaller = onlyFactory(i)
552+    if ((checkCaller == checkCaller))
553+        then {
554+            let userAddress = Address(userAddressBytes)
555+            let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
556+            let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
557+            let $t01937219485 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
558+            let status = $t01937219485._1
559+            let lpAssetAmount = $t01937219485._2
560+            let targetPeriod = $t01937219485._3
561+            let claimTxId = $t01937219485._4
562+            let checks = [if ((status == PENDING))
563+                then true
564+                else throwErr("invalid withdrawal request status"), if ((targetPeriod > currentPeriodOrFail))
565+                then true
566+                else throwErr("invalid withdrawal request period")]
567+            if ((checks == checks))
568+                then {
569+                    let withdrawal = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyWithdrawal()), wrapErr("invalid total withdrawal amount"))
570+                    let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawal(), if ((withdrawal >= lpAssetAmount))
571+                        then (withdrawal - lpAssetAmount)
572+                        else throwErr("invalid withdrawal amount")], nil), invoke(factoryAddressOrFail, "deleteEntry", [keyWithdrawalRequest(userAddress, txId)], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil)]
573+                    if ((factoryActions == factoryActions))
574+                        then $Tuple2(nil, factoryActions)
575+                        else throw("Strict value is not equal to itself.")
576+                    }
577+                else throw("Strict value is not equal to itself.")
578+            }
579+        else throw("Strict value is not equal to itself.")
580+    }
581+
582+
583+
584+@Callable(i)
585+func claimCollateral (userAddressBytes,txId) = {
586+    let checkCaller = onlyFactory(i)
587+    if ((checkCaller == checkCaller))
588+        then {
589+            let $t02047120656 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
590+            let userAddress = $t02047120656._1
591+            let lpAssetAmount = $t02047120656._2
592+            let targetPeriod = $t02047120656._3
593+            let wavesAmount = $t02047120656._4
594+            let assetsString = $t02047120656._5
595+            let amountsString = $t02047120656._6
596+            let assetsList = removeByIndex(split_51C(assetsString, SEP), 0)
597+            let amountsList = removeByIndex(split_51C(amountsString, SEP), 0)
598+            let factoryActions = [invoke(factoryAddressOrFail, "deleteEntry", [keyWithdrawalRequest(userAddress, fromBase58String(txId))], nil), invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawalHistory(userAddress, fromBase58String(txId)), lpAssetAmount], nil), invoke(factoryAddressOrFail, "transferAssets", [userAddressBytes, assetsList, amountsList], nil)]
599+            $Tuple2(nil, factoryActions)
600+            }
601+        else throw("Strict value is not equal to itself.")
602+    }
603+
604+
605+
606+@Callable(i)
607+func claimCollateralBulk (userAddressBytes,txIds) = {
608+    let checkCaller = onlyFactory(i)
609+    if ((checkCaller == checkCaller))
610+        then {
611+            func addNewAction (state,txId) =             {
612+                let $t02141421613 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
613+                let userAddress = $t02141421613._1
614+                let lpAssetAmount = $t02141421613._2
615+                let targetPeriod = $t02141421613._3
616+                let wavesAmount = $t02141421613._4
617+                let assetsString = $t02141421613._5
618+                let amountsString = $t02141421613._6
619+                let assetsList = removeByIndex(split_51C(assetsString, SEP), 0)
620+                let amountsList = removeByIndex(split_51C(amountsString, SEP), 0)
621+                let newActions = [invoke(factoryAddressOrFail, "deleteEntry", [keyWithdrawalRequest(userAddress, fromBase58String(txId))], nil), invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawalHistory(userAddress, fromBase58String(txId)), lpAssetAmount], nil), invoke(factoryAddressOrFail, "transferAssets", [userAddressBytes, assetsList, amountsList], nil)]
622+                (state ++ newActions)
623+                }
624+
625+            let allFactoryActions = {
626+                let $l = txIds
627+                let $s = size($l)
628+                let $acc0 = nil
629+                func $f0_1 ($a,$i) =                 if (($i >= $s))
630+                    then $a
631+                    else addNewAction($a, $l[$i])
632+
633+                func $f0_2 ($a,$i) =                 if (($i >= $s))
634+                    then $a
635+                    else throw("List size exceeds 10")
636+
637+                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
638+                }
639+            $Tuple2(nil, allFactoryActions)
640+            }
641+        else throw("Strict value is not equal to itself.")
642+    }
643+
644+
645+
646+@Callable(i)
647+func claimCollateralREADONLY (userAddressBytes,txId) = {
648+    let response = claimCollateralREADONLYStringResponse(userAddressBytes, fromBase58String(txId))
649+    $Tuple2(nil, response)
650+    }
651+
652+
653+
654+@Callable(i)
655+func claimCollateralBulkREADONLY (userAddressBytes,txIds) = {
656+    func processTxId (state,txId) =     {
657+        let response = claimCollateralREADONLYStringResponse(userAddressBytes, fromBase58String(txId))
658+        (state :+ response)
659+        }
660+
661+    let allResponses = {
662+        let $l = txIds
663+        let $s = size($l)
664+        let $acc0 = nil
665+        func $f0_1 ($a,$i) =         if (($i >= $s))
666+            then $a
667+            else processTxId($a, $l[$i])
668+
669+        func $f0_2 ($a,$i) =         if (($i >= $s))
670+            then $a
671+            else throw("List size exceeds 10")
672+
673+        $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)
674+        }
675+    $Tuple2(nil, allResponses)
676+    }
677+
678+
679+
680+@Callable(i)
681+func processBlocks (userAddressBytes) = {
682+    let checkCaller = onlyFactory(i)
683+    if ((checkCaller == checkCaller))
684+        then {
685+            let userAddress = Address(userAddressBytes)
686+            let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
687+            let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
688+            let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
689+            let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
690+            let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
691+            let periodEndHeight = ((currentStartHeight + periodLength) - 1)
692+            let blocksProcessingBatchSizeMax = 20
693+            let blocksProcessingBatchSize = if (if (if ((height >= nextBlockToProcess))
694+                then if ((nextBlockToProcess >= currentStartHeight))
695+                    then true
696+                    else (currentPeriodOrFail == 0)
697+                else false)
698+                then (periodEndHeight >= nextBlockToProcess)
699+                else false)
700+                then min([((periodEndHeight - nextBlockToProcess) + 1), blocksProcessingBatchSizeMax])
701+                else throwErr(wrapErr("invalid target block"))
702+            let blockProcessingReward = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
703+            let blockProcessingRewardByGenerator = (blockProcessingReward / blocksProcessingBatchSize)
704+            let blockProcessingRewardByGeneratorRemainder = (blockProcessingReward - (blockProcessingRewardByGenerator * blocksProcessingBatchSize))
705+            func map (acc,inc) =             if ((inc >= blocksProcessingBatchSize))
706+                then acc
707+                else {
708+                    let targetBlockHeight = (nextBlockToProcess + inc)
709+                    let targetBlockInfo = valueOrErrorMessage(blockInfoByHeight(targetBlockHeight), wrapErr("invalid block info"))
710+                    let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, proxyTreasuryAddressOrFail), wrapErr(("invalid treasury reward for height " + toString(targetBlockHeight))))
711+                    let generator = targetBlockInfo.generator
712+                    let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(generator)), 0)
713+                    let callerReward = if ((inc == (blocksProcessingBatchSize - 1)))
714+                        then (blockProcessingRewardByGenerator + blockProcessingRewardByGeneratorRemainder)
715+                        else blockProcessingRewardByGenerator
716+                    let powerShareRatio = max([0, min([valueOrElse(getInteger(factoryAddressOrFail, keyPowerShareRatio()), 0), SCALE8])])
717+                    let shareAmountToPower = fraction((treasuryRewardOrFail - callerReward), powerShareRatio, SCALE8)
718+                    let lpAssetAmount = if ((currentPriceOrFail > 0))
719+                        then fraction(((treasuryRewardOrFail - callerReward) - shareAmountToPower), SCALE8, currentPriceOrFail)
720+                        else 0
721+                    let factoryActionsSingle = [invoke(factoryAddressOrFail, "stringEntry", [keyBlockProcessed(targetBlockHeight), makeString([toBase58String(i.transactionId), toString(currentPeriodOrFail), toString(generator), toBase58String(userAddressBytes), toString(treasuryRewardOrFail), toString(callerReward), toString(lpAssetAmount), toString(shareAmountToPower)], SEP)], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(generator), (available + lpAssetAmount)], nil)]
722+                    if ((factoryActionsSingle == factoryActionsSingle))
723+                        then {
724+                            let $t02670426758 = acc
725+                            let lpAssetAcc = $t02670426758._1
726+                            let rewardAcc = $t02670426758._2
727+                            let powerShareDataTuple = $t02670426758._3
728+                            let $t02676526831 = powerShareDataTuple
729+                            let powerShareAcc = $t02676526831._1
730+                            let generatorPowerShareList = $t02676526831._2
731+                            let newGeneratorPowerShareList = (generatorPowerShareList :+ $Tuple2(toString(generator), shareAmountToPower))
732+                            $Tuple3((lpAssetAcc + lpAssetAmount), (rewardAcc + treasuryRewardOrFail), $Tuple2((powerShareAcc + shareAmountToPower), newGeneratorPowerShareList))
733+                            }
734+                        else throw("Strict value is not equal to itself.")
735+                    }
736+
737+            let list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
738+            let $t02718627292 = {
739+                let $l = list
740+                let $s = size($l)
741+                let $acc0 = $Tuple3(0, 0, $Tuple2(0, nil))
742+                func $f0_1 ($a,$i) =                 if (($i >= $s))
743+                    then $a
744+                    else map($a, $l[$i])
745+
746+                func $f0_2 ($a,$i) =                 if (($i >= $s))
747+                    then $a
748+                    else throw("List size exceeds 20")
749+
750+                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
751+                }
752+            if (($t02718627292 == $t02718627292))
753+                then {
754+                    let powerShareDataTuple = $t02718627292._3
755+                    let rewardAmountTotal = $t02718627292._2
756+                    let lpAssetAmountTotal = $t02718627292._1
757+                    let $t02729627365 = powerShareDataTuple
758+                    let amountToPowerTotal = $t02729627365._1
759+                    let powerShareAmountsList = $t02729627365._2
760+                    let businessTreasuryPart = valueOrElse(getInteger(factoryAddressOrFail, keyBusinessTreasuryPart()), 0)
761+                    let rewardToBusinessTreasuryAmount = fraction(rewardAmountTotal, businessTreasuryPart, SCALE8)
762+                    let rewardToMainTreasuryAmount = (((rewardAmountTotal - rewardToBusinessTreasuryAmount) - blockProcessingReward) - amountToPowerTotal)
763+                    let invested = valueOrElse(getInteger(factoryAddressOrFail, keyInvested(unit)), 0)
764+                    let powerShareActions = if ((amountToPowerTotal > 0))
765+                        then {
766+                            let transferAction = [invoke(factoryAddressOrFail, "transferFromProxyTreasury", [factoryAddressOrFail.bytes, amountToPowerTotal], nil)]
767+                            if ((transferAction == transferAction))
768+                                then {
769+                                    let totalPowerAmount = invoke(factoryAddressOrFail, "swap", [powerAssetIdStringOrFail], [AttachedPayment(unit, amountToPowerTotal)])
770+                                    if ((totalPowerAmount == totalPowerAmount))
771+                                        then {
772+                                            let totalPowerAmountInt =                                             match totalPowerAmount {
773+                                                case pAmount: Int => 
774+                                                    pAmount
775+                                                case _ => 
776+                                                    0
777+                                            }
778+                                            func stakePowerInvoke (acc,next) =                                             {
779+                                                let $t02844328478 = next
780+                                                let generator = $t02844328478._1
781+                                                let shareAmount = $t02844328478._2
782+                                                if ((amountToPowerTotal > 0))
783+                                                    then {
784+                                                        let powerAmount = fraction(shareAmount, totalPowerAmountInt, amountToPowerTotal)
785+                                                        let inv = invoke(factoryAddressOrFail, "powerStake", [fromBase58String(generator)], [AttachedPayment(fromBase58String(powerAssetIdStringOrFail), powerAmount)])
786+                                                        if ((inv == inv))
787+                                                            then nil
788+                                                            else throw("Strict value is not equal to itself.")
789+                                                        }
790+                                                    else nil
791+                                                }
792+
793+                                            let powerStakesActions = {
794+                                                let $l = powerShareAmountsList
795+                                                let $s = size($l)
796+                                                let $acc0 = 0
797+                                                func $f1_1 ($a,$i) =                                                 if (($i >= $s))
798+                                                    then $a
799+                                                    else stakePowerInvoke($a, $l[$i])
800+
801+                                                func $f1_2 ($a,$i) =                                                 if (($i >= $s))
802+                                                    then $a
803+                                                    else throw("List size exceeds 20")
804+
805+                                                $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($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), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
806+                                                }
807+                                            if ((powerStakesActions == powerStakesActions))
808+                                                then nil
809+                                                else throw("Strict value is not equal to itself.")
810+                                            }
811+                                        else throw("Strict value is not equal to itself.")
812+                                    }
813+                                else throw("Strict value is not equal to itself.")
814+                            }
815+                        else nil
816+                    if ((powerShareActions == powerShareActions))
817+                        then {
818+                            let actions = [invoke(factoryAddressOrFail, "reissue", [lpAssetAmountTotal], nil), invoke(factoryAddressOrFail, "integerEntry", [keyNextBlockToProcess(), (nextBlockToProcess + blocksProcessingBatchSize)], nil), invoke(factoryAddressOrFail, "transferFromProxyTreasury", [mainTreasuryAddressOrFail.bytes, rewardToMainTreasuryAmount], nil), invoke(factoryAddressOrFail, "transferFromProxyTreasury", [userAddressBytes, blockProcessingReward], nil), invoke(factoryAddressOrFail, "transferFromProxyTreasury", [businessTreasuryAddressOrFail.bytes, rewardToBusinessTreasuryAmount], nil), invoke(factoryAddressOrFail, "integerEntry", [keyInvested(unit), (invested + rewardToMainTreasuryAmount)], nil)]
819+                            if ((actions == actions))
820+                                then $Tuple2(nil, unit)
821+                                else throw("Strict value is not equal to itself.")
822+                            }
823+                        else throw("Strict value is not equal to itself.")
824+                    }
825+                else throw("Strict value is not equal to itself.")
826+            }
827+        else throw("Strict value is not equal to itself.")
828+    }
829+
830+
831+@Verifier(tx)
832+func verify () = {
833+    let publicKey =     match getManagerPublicKeyOrUnit() {
834+        case pub: ByteVector => 
835+            pub
836+        case _ => 
837+            tx.senderPublicKey
838+    }
839+    sigVerify(tx.bodyBytes, tx.proofs[0], publicKey)
840+    }
44841 
github/deemru/w8io/169f3d6 
65.35 ms ◑