tx · BBCfTzyhhaeei8fNmciGaKXhJi6c3sy5cF1UhirxUSpd

3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP:  -0.03600000 Waves

2023.12.07 09:58 [2875900] smart account 3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BBCfTzyhhaeei8fNmciGaKXhJi6c3sy5cF1UhirxUSpd",
    "fee": 3600000,
    "feeAssetId": null,
    "timestamp": 1701932334956,
    "version": 1,
    "sender": "3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP",
    "senderPublicKey": "AoKo4segKHU4DeJnxXQYJj2u7J6XJeux6r8KLW52cd2Q",
    "proofs": [
        "jbcvS7oKqCcE9s8xUWhhGEGit6GKkTXc883nfdVuDFyfmnqtSJhfq9cnpWnsUYxYagn6xfPZzsNjQx1w6oCgu7G"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2875900,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GGfNRyb2Jq2rjishgH4p2bBw8zubDfr5KvzLeZwqvnQm
Next: none

Full: 

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