tx · CphUDDL8wy6DDW4P13GA5Up16NHqiMwP9TkSLAjEchGk

3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP:  -0.03500000 Waves

2023.08.18 14:21 [2715971] smart account 3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CphUDDL8wy6DDW4P13GA5Up16NHqiMwP9TkSLAjEchGk",
    "fee": 3500000,
    "feeAssetId": null,
    "timestamp": 1692357753347,
    "version": 1,
    "sender": "3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP",
    "senderPublicKey": "AoKo4segKHU4DeJnxXQYJj2u7J6XJeux6r8KLW52cd2Q",
    "proofs": [
        "2HeqLyDNkmdqsRdHYn8QYSFmzqZHCnxESrhKmLBEvTX7F2MgGiA1Mo9RCg6ue7ayZivYkq3rf7bSFAHeQqLSRsX5"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2715971,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 6rLD4CDndN4tFiVth23tXZQL7cguVsyQKC2KWQgMH7a2
Next: UjJCzcnHprUqHuKsr9t26qme7EGxkVFTk6RhRg3UjwU

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 7 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "__"
55 
66 let CONTRACT_NAME = "calculator.ride"
77 
88 let SCALE8 = 100000000
99 
1010 let PENDING = "PENDING"
1111 
1212 let WAVES = "WAVES"
1313 
1414 func wrapErr (s) = ((CONTRACT_NAME + ": ") + s)
1515 
1616 
1717 func throwErr (s) = throw(wrapErr(s))
1818 
1919 
2020 func assetIdToString (assetId) = match assetId {
2121     case b: ByteVector => 
2222         toBase58String(b)
2323     case _: Unit => 
2424         WAVES
2525     case _ => 
2626         throw("Match error")
2727 }
2828 
2929 
3030 func stringToAssetId (s) = if ((s == WAVES))
3131     then unit
3232     else fromBase58String(s)
3333 
3434 
3535 func abs (n) = if ((0 > n))
3636     then -(n)
3737     else n
3838 
3939 
4040 func keyFactoryAddress () = makeString(["%s", "factory"], SEP)
4141 
4242 
4343 func keyManagerPublicKey () = makeString(["%s", "managerPublicKey"], SEP)
4444 
4545 
4646 func keyLpAssetId () = makeString(["%s", "lpAssetId"], SEP)
4747 
4848 
4949 func keyProxyTreasuryAddress () = makeString(["%s", "proxyTreasury"], SEP)
5050 
5151 
5252 func keyMainTreasuryAddress () = makeString(["%s", "mainTreasury"], SEP)
5353 
5454 
5555 func keyBusinessTreasuryAddress () = makeString(["%s", "businessTreasury"], SEP)
5656 
5757 
5858 func keyBusinessTreasuryPart () = makeString(["%s", "businessTreasuryPart"], SEP)
5959 
6060 
6161 func keyPowerContractAddress () = makeString(["%s", "powerContract"], SEP)
6262 
6363 
6464 func keyPowerShareRatio () = makeString(["%s", "powerShareRatio"], SEP)
6565 
6666 
6767 func keyPowerAssetId () = makeString(["%s", "powerAssetId"], SEP)
6868 
6969 
7070 func keyInvested (assetId) = makeString(["%s%s", "invested", assetIdToString(assetId)], SEP)
7171 
7272 
7373 func keyDonated (assetId) = makeString(["%s%s", "donated", assetIdToString(assetId)], SEP)
7474 
7575 
7676 func keyAvailable (userAddress) = makeString(["%s%s", "available", toString(userAddress)], SEP)
7777 
7878 
7979 func keyClaimed (userAddress) = makeString(["%s%s", "claimed", toString(userAddress)], SEP)
8080 
8181 
8282 func keyCurrentPeriod () = makeString(["%s", "currentPeriod"], SEP)
8383 
8484 
8585 func keyPriceForPeriod (period) = makeString(["%s%d", "price", toString(period)], SEP)
8686 
8787 
8888 func keyStartHeight (period) = makeString(["%s%d", "startHeight", toString(period)], SEP)
8989 
9090 
9191 func keyPowerManagerBonus (period) = makeString(["%s%d", "powerManagerBonus", toString(period)], SEP)
9292 
9393 
9494 func keyClaimWavesAmount (period) = makeString(["%s%d", "claimWavesAmount", toString(period)], SEP)
9595 
9696 
9797 func keyPeriodLength () = "%s__periodLength"
9898 
9999 
100100 func keyInvestPeriodLength () = "%s__investPeriodLength"
101101 
102102 
103103 func keyBlockProcessingReward () = "%s__blockProcessingReward"
104104 
105105 
106106 func keyNextBlockToProcess () = "%s__nextBlockToProcess"
107107 
108108 
109109 func keyBlockProcessed (height) = makeString(["%s%d", "blockProcessed", toString(height)], SEP)
110110 
111111 
112112 func keyWithdrawal () = "%s__withdrawal"
113113 
114114 
115115 func keyWithdrawalRequest (userAddress,txId) = makeString(["%s%s%s", "withdrawal", toString(userAddress), toBase58String(txId)], SEP)
116116 
117117 
118118 func valueWithdrawalRequest (status,lpAssetAmount,targetPeriod,claimTxId) = {
119119     let claimTxIdStr =     match claimTxId {
120120         case b: ByteVector => 
121121             toBase58String(b)
122122         case _: Unit => 
123123             "SOON"
124124         case _ => 
125125             throw("Match error")
126126     }
127127     makeString(["%s%d%d%s", status, toString(lpAssetAmount), toString(targetPeriod), claimTxIdStr], SEP)
128128     }
129129 
130130 
131131 func keyWithdrawalHistory (userAddress,txId) = makeString(["%s%s%s", "withdrawalHistory", toString(userAddress), toBase58String(txId)], SEP)
132132 
133133 
134134 func keyPeriodWithdrawalAssetIds (period) = makeString(["%s%d", "periodReward", toString(period)], SEP)
135135 
136136 
137137 func keyPeriodWithdrawalAmounts (period) = makeString(["%s%d", "periodRewardAmount", toString(period)], SEP)
138138 
139139 
140140 func parseWithdrawalRequestValueOrFail (s) = {
141141     let parts = split(s, SEP)
142142     if ((size(parts) == 5))
143143         then {
144144             let status = parts[1]
145145             let lpAssetAmount = valueOrErrorMessage(parseInt(parts[2]), wrapErr("invalid lpAssetAmount"))
146146             let targetPeriod = valueOrErrorMessage(parseInt(parts[3]), wrapErr("invalid targetPeriod"))
147147             let claimTxId = parts[4]
148148             $Tuple4(status, lpAssetAmount, targetPeriod, claimTxId)
149149             }
150150         else throwErr("invalid withdrawal request value")
151151     }
152152 
153153 
154154 let factoryAddressOption = match getString(this, keyFactoryAddress()) {
155155     case s: String => 
156156         addressFromString(s)
157157     case _: Unit => 
158158         unit
159159     case _ => 
160160         throw("Match error")
161161 }
162162 
163163 let factoryAddressOrFail = valueOrErrorMessage(factoryAddressOption, wrapErr("invalid factory address"))
164164 
165165 let lpAssetIdOption = match factoryAddressOption {
166166     case a: Address => 
167167         match getString(a, keyLpAssetId()) {
168168             case s: String => 
169169                 fromBase58String(s)
170170             case _: Unit => 
171171                 unit
172172             case _ => 
173173                 throw("Match error")
174174         }
175175     case _: Unit => 
176176         unit
177177     case _ => 
178178         throw("Match error")
179179 }
180180 
181181 let lpAssetIdOrFail = valueOrErrorMessage(lpAssetIdOption, wrapErr("invalid lpAssetId"))
182182 
183183 let proxyTreasuryAddressOption = match factoryAddressOption {
184184     case a: Address => 
185185         match getString(a, keyProxyTreasuryAddress()) {
186186             case s: String => 
187187                 addressFromString(s)
188188             case _: Unit => 
189189                 unit
190190             case _ => 
191191                 throw("Match error")
192192         }
193193     case _: Unit => 
194194         unit
195195     case _ => 
196196         throw("Match error")
197197 }
198198 
199199 let proxyTreasuryAddressOrFail = valueOrErrorMessage(proxyTreasuryAddressOption, wrapErr("invalid proxy treasury address"))
200200 
201201 let mainTreasuryAddressOption = match factoryAddressOption {
202202     case a: Address => 
203203         match getString(a, keyMainTreasuryAddress()) {
204204             case s: String => 
205205                 addressFromString(s)
206206             case _: Unit => 
207207                 unit
208208             case _ => 
209209                 throw("Match error")
210210         }
211211     case _: Unit => 
212212         unit
213213     case _ => 
214214         throw("Match error")
215215 }
216216 
217217 let businessTreasuryAddressOption = match factoryAddressOption {
218218     case a: Address => 
219219         match getString(a, keyBusinessTreasuryAddress()) {
220220             case s: String => 
221221                 addressFromString(s)
222222             case _: Unit => 
223223                 unit
224224             case _ => 
225225                 throw("Match error")
226226         }
227227     case _: Unit => 
228228         unit
229229     case _ => 
230230         throw("Match error")
231231 }
232232 
233233 let mainTreasuryAddressOrFail = valueOrErrorMessage(mainTreasuryAddressOption, wrapErr("invalid main treasury address"))
234234 
235235 let businessTreasuryAddressOrFail = valueOrErrorMessage(businessTreasuryAddressOption, wrapErr("invalid business treasury address"))
236236 
237237 let powerContractAddressOption = match factoryAddressOption {
238238     case a: Address => 
239239         match getString(a, keyPowerContractAddress()) {
240240             case s: String => 
241241                 addressFromString(s)
242242             case _: Unit => 
243243                 unit
244244             case _ => 
245245                 throw("Match error")
246246         }
247247     case _: Unit => 
248248         unit
249249     case _ => 
250250         throw("Match error")
251251 }
252252 
253253 let powerContractAddressOrFail = valueOrErrorMessage(powerContractAddressOption, wrapErr("invalid power contract address"))
254254 
255255 let powerAssetIdStringOrFail = valueOrErrorMessage(getString(factoryAddressOrFail, keyPowerAssetId()), wrapErr("power asset id not found"))
256256 
257257 func getManagerPublicKeyOrUnit () = match factoryAddressOption {
258258     case fa: Address => 
259259         match getString(fa, keyManagerPublicKey()) {
260260             case pub: String => 
261261                 fromBase58String(pub)
262262             case _ => 
263263                 unit
264264         }
265265     case _ => 
266266         unit
267267 }
268268 
269269 
270270 func onlyAddress (i,address) = if ((i.caller == address))
271271     then true
272272     else throwErr("permission denied")
273273 
274274 
275275 func onlyFactory (i) = onlyAddress(i, factoryAddressOrFail)
276276 
277277 
278278 func rewardForOption (rewards,target) = {
279279     let s = size(rewards)
280280     let $t066316656 = rewards[0]
281281     let a0 = $t066316656._1
282282     let r0 = $t066316656._2
283283     let $t066596684 = rewards[1]
284284     let a1 = $t066596684._1
285285     let r1 = $t066596684._2
286286     let $t066876712 = rewards[2]
287287     let a2 = $t066876712._1
288288     let r2 = $t066876712._2
289289     if (if ((s > 0))
290290         then (a0 == target)
291291         else false)
292292         then r0
293293         else if (if ((s > 1))
294294             then (a1 == target)
295295             else false)
296296             then r1
297297             else if (if ((s > 2))
298298                 then (a2 == target)
299299                 else false)
300300                 then r2
301301                 else unit
302302     }
303303 
304304 
305305 func calculatePrice (lpPartInWaves) = {
306306     let lpAssetAmountToBurn = valueOrElse(getInteger(factoryAddressOrFail, keyWithdrawal()), 0)
307307     let lpAssetQuantity = valueOrErrorMessage(assetInfo(lpAssetIdOrFail), wrapErr("invalid lpAsset info")).quantity
308308     let newPrice = fraction(lpPartInWaves, SCALE8, (lpAssetQuantity - lpAssetAmountToBurn))
309309     let checkIfPriceNotZero = if ((newPrice != 0))
310310         then true
311311         else throwErr("LP price cannot be 0")
312312     if ((checkIfPriceNotZero == checkIfPriceNotZero))
313313         then {
314314             let lpAssetFinalQuantity = (lpAssetQuantity - lpAssetAmountToBurn)
315315             $Tuple3(newPrice, lpAssetAmountToBurn, lpAssetFinalQuantity)
316316             }
317317         else throw("Strict value is not equal to itself.")
318318     }
319319 
320320 
321321 func claimCollateralINTERNAL (userAddressBytes,txId) = {
322322     let userAddress = Address(userAddressBytes)
323323     let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
324324     let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
325325     let $t078797992 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
326326     let status = $t078797992._1
327327     let lpAssetAmount = $t078797992._2
328328     let targetPeriod = $t078797992._3
329329     let claimTxId = $t078797992._4
330330     if ((targetPeriod > currentPeriodOrFail))
331331         then throwErr("invalid withdrawal request period")
332332         else {
333333             let priceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(targetPeriod)), wrapErr("invalid price"))
334334             let wavesAmount = if ((priceOrFail > 0))
335335                 then fraction(lpAssetAmount, priceOrFail, SCALE8)
336336                 else 0
337337             let assetsString = getStringValue(factoryAddressOrFail, keyPeriodWithdrawalAssetIds(currentPeriodOrFail))
338338             let amountsString = getStringValue(factoryAddressOrFail, keyPeriodWithdrawalAmounts(currentPeriodOrFail))
339339             $Tuple6(userAddress, lpAssetAmount, targetPeriod, wavesAmount, assetsString, amountsString)
340340             }
341341     }
342342 
343343 
344344 func claimCollateralREADONLYStringResponse (userAddressBytes,txId) = {
345345     let $t087798945 = claimCollateralINTERNAL(userAddressBytes, txId)
346346     let userAddress = $t087798945._1
347347     let lpAssetAmount = $t087798945._2
348348     let targetPeriod = $t087798945._3
349349     let wavesAmount = $t087798945._4
350350     let assetsString = $t087798945._5
351351     let amountsString = $t087798945._6
352352     let assets = makeString(removeByIndex(split_51C(assetsString, SEP), 0), ":")
353353     let amounts = makeString(removeByIndex(split_51C(amountsString, SEP), 0), ":")
354354     makeString(["%d%s%s", toString(wavesAmount), assets, amounts], SEP)
355355     }
356356 
357357 
358358 func getRewardSplit (generatorRewardAmount) = {
359359     let powerShareRatio = max([0, min([valueOrElse(getInteger(factoryAddressOrFail, keyPowerShareRatio()), 0), SCALE8])])
360360     let businessPartRatio = max([0, min([valueOrElse(getInteger(factoryAddressOrFail, keyBusinessTreasuryPart()), 0), SCALE8])])
361361     let amountToPowerPart = fraction(generatorRewardAmount, powerShareRatio, SCALE8)
362362     let businessTreasuryAmountPart = fraction(generatorRewardAmount, businessPartRatio, SCALE8)
363363     let rewardRemainder = ((generatorRewardAmount - amountToPowerPart) - businessTreasuryAmountPart)
364364     if ((rewardRemainder > 0))
365365         then $Tuple3(amountToPowerPart, businessTreasuryAmountPart, rewardRemainder)
366366         else throwErr("amount to main treasury cannot be negative")
367367     }
368368 
369369 
370370 func calcRewardSplitForAmount (amount) = {
371371     let blocksProcessingBatchSizeMax = 20
372372     let $t01008410177 = getRewardSplit(amount)
373373     let amountToPowerPart = $t01008410177._1
374374     let businessTreasuryAmountPart = $t01008410177._2
375375     let rewardRemainder = $t01008410177._3
376376     let blockProcessingReward = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
377377     let blockProcessingRewardByGenerator = (blockProcessingReward / blocksProcessingBatchSizeMax)
378378     let toLpAmount = (rewardRemainder - blockProcessingReward)
379379     $Tuple5(amountToPowerPart, businessTreasuryAmountPart, blockProcessingReward, toLpAmount, amount)
380380     }
381381 
382382 
383383 @Callable(i)
384384 func rewardSplitREADONLY () = {
385385     let targetBlockHeight = (height - 1)
386386     let targetBlockInfo = valueOrErrorMessage(blockInfoByHeight(targetBlockHeight), wrapErr("invalid block info"))
387387     let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, proxyTreasuryAddressOrFail), wrapErr(("invalid treasury reward for height " + toString(targetBlockHeight))))
388388     $Tuple2(nil, calcRewardSplitForAmount(treasuryRewardOrFail))
389389     }
390390 
391391 
392392 
393393 @Callable(i)
394394 func claimLP (userAddressBytes) = {
395395     let checkCaller = onlyFactory(i)
396396     if ((checkCaller == checkCaller))
397397         then {
398398             let userAddress = Address(userAddressBytes)
399399             let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(userAddress)), 0)
400400             let claimed = valueOrElse(getInteger(factoryAddressOrFail, keyClaimed(userAddress)), 0)
401401             let factoryActions = if ((available > 0))
402402                 then [invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, available, lpAssetIdOrFail], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(userAddress), 0], nil), invoke(factoryAddressOrFail, "integerEntry", [keyClaimed(userAddress), (claimed + available)], nil)]
403403                 else throwErr("nothing to claim")
404404             $Tuple2(nil, factoryActions)
405405             }
406406         else throw("Strict value is not equal to itself.")
407407     }
408408 
409409 
410410 
411411 @Callable(i)
412412 func finalize (userAddressBytes,donationPartInWaves,lpPartInWaves,claimPartInWaves,powerStakePartInWaves) = {
413413     let checkCaller = onlyFactory(i)
414414     if ((checkCaller == checkCaller))
415415         then {
416416             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
417417             let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
418418             let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
419419             let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
420420             let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
421421             let periodEndHeight = ((currentStartHeight + periodLength) - 1)
422422             let checks = [if ((i.originCaller == mainTreasuryAddressOrFail))
423423                 then true
424424                 else throwErr("permission denied"), if ((nextBlockToProcess > periodEndHeight))
425425                 then true
426426                 else throwErr("unprocessed blocks"), if ((donationPartInWaves >= 0))
427427                 then true
428428                 else throwErr("invalid donation part"), if ((lpPartInWaves >= 0))
429429                 then true
430430                 else throwErr("invalid lp part"), if ((claimPartInWaves >= 0))
431431                 then true
432432                 else throwErr("invalid claim part"), if ((powerStakePartInWaves >= 0))
433433                 then true
434434                 else throwErr("invalid PWR stake part")]
435435             if ((checks == checks))
436436                 then {
437437                     let $t01351513620 = calculatePrice(lpPartInWaves)
438438                     let newPrice = $t01351513620._1
439439                     let lpAssetAmountToBurn = $t01351513620._2
440440                     let lpAssetFinalQuantity = $t01351513620._3
441441                     let newPeriod = (currentPeriodOrFail + 1)
442442                     func addNewAction (actions,payment) =                     {
443443                         let $t01376813830 = actions
444444                         let scriptTransfers = $t01376813830._1
445445                         let assetIdsString = $t01376813830._2
446446                         let amountsString = $t01376813830._3
447447                         let paymentAmount = payment.amount
448448                         let paymentAssetId = payment.assetId
449449                         let newAssetIdsString = ("%s" + makeString([assetIdsString, assetIdToString(paymentAssetId)], SEP))
450450                         let newAmountsString = ("%d" + makeString([amountsString, toString(paymentAmount)], SEP))
451451                         let newScriptTransfer = ScriptTransfer(factoryAddressOrFail, paymentAmount, paymentAssetId)
452452                         $Tuple3((scriptTransfers :+ newScriptTransfer), newAssetIdsString, newAmountsString)
453453                         }
454454 
455455                     let $t01429014381 = {
456456                         let $l = i.payments
457457                         let $s = size($l)
458458                         let $acc0 = $Tuple3(nil, "", "")
459459                         func $f0_1 ($a,$i) =                         if (($i >= $s))
460460                             then $a
461461                             else addNewAction($a, $l[$i])
462462 
463463                         func $f0_2 ($a,$i) =                         if (($i >= $s))
464464                             then $a
465465                             else throw("List size exceeds 10")
466466 
467467                         $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)
468468                         }
469469                     let scriptTransfers = $t01429014381._1
470470                     let AssetIds = $t01429014381._2
471471                     let Amounts = $t01429014381._3
472472                     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)]
473473                     $Tuple2(scriptTransfers, factoryActions)
474474                     }
475475                 else throw("Strict value is not equal to itself.")
476476             }
477477         else throw("Strict value is not equal to itself.")
478478     }
479479 
480480 
481481 
482482 @Callable(i)
483483 func finalizeREADONLY (donationPartInWaves,lpPartInWaves,claimPartInWaves,powerStakePartInWaves) = {
484484     let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
485485     let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
486486     let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
487487     let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
488488     let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
489489     let periodEndHeight = ((currentStartHeight + periodLength) - 1)
490490     let checks = [if ((nextBlockToProcess > periodEndHeight))
491491         then true
492492         else throwErr("unprocessed blocks"), if ((donationPartInWaves >= 0))
493493         then true
494494         else throwErr("invalid donation part"), if ((lpPartInWaves >= 0))
495495         then true
496496         else throwErr("invalid lp part"), if ((claimPartInWaves >= 0))
497497         then true
498498         else throwErr("invalid claim part"), if ((powerStakePartInWaves >= 0))
499499         then true
500500         else throwErr("invalid PWR stake part")]
501501     if ((checks == checks))
502502         then {
503503             let $t01726017365 = calculatePrice(lpPartInWaves)
504504             let newPrice = $t01726017365._1
505505             let lpAssetAmountToBurn = $t01726017365._2
506506             let lpAssetFinalQuantity = $t01726017365._3
507507             $Tuple2(nil, $Tuple6(claimPartInWaves, lpPartInWaves, donationPartInWaves, newPrice, lpAssetAmountToBurn, lpAssetFinalQuantity))
508508             }
509509         else throw("Strict value is not equal to itself.")
510510     }
511511 
512512 
513513 
514514 @Callable(i)
515515 func invest (userAddressBytes) = {
516516     let checkCaller = onlyFactory(i)
517517     if ((checkCaller == checkCaller))
518518         then {
519519             let userAddress = Address(userAddressBytes)
520520             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
521521             let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
522522             let investPeriodLength = getIntegerValue(factoryAddressOrFail, keyInvestPeriodLength())
523523             let heightCheck = if (((currentStartHeight + investPeriodLength) > height))
524524                 then true
525525                 else throwErr("too late to invest in this period")
526526             if ((heightCheck == heightCheck))
527527                 then {
528528                     let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
529529                     let payment = if ((size(i.payments) == 1))
530530                         then i.payments[0]
531531                         else throwErr("invalid payments")
532532                     let $t01847418651 = if (if ((payment.assetId == unit))
533533                         then (payment.amount > 0)
534534                         else false)
535535                         then $Tuple2(payment.amount, payment.assetId)
536536                         else throwErr("invalid payment amount")
537537                     let paymentAmount = $t01847418651._1
538538                     let paymentAssetId = $t01847418651._2
539539                     let treasuryPart = valueOrElse(getInteger(factoryAddressOrFail, keyBusinessTreasuryPart()), 0)
540540                     let paymentsWithoutTreasuryPart = fraction(paymentAmount, (SCALE8 - treasuryPart), SCALE8)
541541                     let lpAssetAmount = if ((currentPriceOrFail > 0))
542542                         then fraction(paymentsWithoutTreasuryPart, SCALE8, currentPriceOrFail)
543543                         else 0
544544                     let invested = valueOrElse(getInteger(factoryAddressOrFail, keyInvested(unit)), 0)
545545                     let actions = [ScriptTransfer(mainTreasuryAddressOrFail, paymentsWithoutTreasuryPart, paymentAssetId), ScriptTransfer(businessTreasuryAddressOrFail, treasuryPart, paymentAssetId)]
546546                     let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyInvested(unit), (invested + paymentsWithoutTreasuryPart)], nil), invoke(factoryAddressOrFail, "reissue", [lpAssetAmount], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil)]
547547                     $Tuple2(actions, factoryActions)
548548                     }
549549                 else throw("Strict value is not equal to itself.")
550550             }
551551         else throw("Strict value is not equal to itself.")
552552     }
553553 
554554 
555555 
556556 @Callable(i)
557557 func withdraw (userAddressBytes) = {
558558     let checkCaller = onlyFactory(i)
559559     if ((checkCaller == checkCaller))
560560         then {
561561             let userAddress = Address(userAddressBytes)
562562             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
563563             let payment = if ((size(i.payments) == 1))
564564                 then i.payments[0]
565565                 else throwErr(wrapErr("invalid payments"))
566566             let paymentAssetId = if ((payment.assetId == lpAssetIdOrFail))
567567                 then lpAssetIdOrFail
568568                 else throwErr("invalid payment asset")
569569             let paymentAmount = if ((payment.amount > 0))
570570                 then payment.amount
571571                 else throwErr("invalid payment amount")
572572             let withdrawal = valueOrElse(getInteger(factoryAddressOrFail, keyWithdrawal()), 0)
573573             let actions = [ScriptTransfer(factoryAddressOrFail, paymentAmount, paymentAssetId)]
574574             let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawal(), (withdrawal + paymentAmount)], nil), invoke(factoryAddressOrFail, "stringEntry", [keyWithdrawalRequest(userAddress, i.transactionId), valueWithdrawalRequest(PENDING, paymentAmount, (currentPeriodOrFail + 1), unit)], nil)]
575575             if ((factoryActions == factoryActions))
576576                 then $Tuple2(actions, factoryActions)
577577                 else throw("Strict value is not equal to itself.")
578578             }
579579         else throw("Strict value is not equal to itself.")
580580     }
581581 
582582 
583583 
584584 @Callable(i)
585585 func cancelWithdraw (userAddressBytes,txId) = {
586586     let checkCaller = onlyFactory(i)
587587     if ((checkCaller == checkCaller))
588588         then {
589589             let userAddress = Address(userAddressBytes)
590590             let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
591591             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
592592             let $t02138521498 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
593593             let status = $t02138521498._1
594594             let lpAssetAmount = $t02138521498._2
595595             let targetPeriod = $t02138521498._3
596596             let claimTxId = $t02138521498._4
597597             let checks = [if ((status == PENDING))
598598                 then true
599599                 else throwErr("invalid withdrawal request status"), if ((targetPeriod > currentPeriodOrFail))
600600                 then true
601601                 else throwErr("invalid withdrawal request period")]
602602             if ((checks == checks))
603603                 then {
604604                     let withdrawal = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyWithdrawal()), wrapErr("invalid total withdrawal amount"))
605605                     let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawal(), if ((withdrawal >= lpAssetAmount))
606606                         then (withdrawal - lpAssetAmount)
607607                         else throwErr("invalid withdrawal amount")], nil), invoke(factoryAddressOrFail, "deleteEntry", [keyWithdrawalRequest(userAddress, txId)], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil)]
608608                     if ((factoryActions == factoryActions))
609609                         then $Tuple2(nil, factoryActions)
610610                         else throw("Strict value is not equal to itself.")
611611                     }
612612                 else throw("Strict value is not equal to itself.")
613613             }
614614         else throw("Strict value is not equal to itself.")
615615     }
616616 
617617 
618618 
619619 @Callable(i)
620620 func claimCollateral (userAddressBytes,txId) = {
621621     let checkCaller = onlyFactory(i)
622622     if ((checkCaller == checkCaller))
623623         then {
624624             let $t02248422669 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
625625             let userAddress = $t02248422669._1
626626             let lpAssetAmount = $t02248422669._2
627627             let targetPeriod = $t02248422669._3
628628             let wavesAmount = $t02248422669._4
629629             let assetsString = $t02248422669._5
630630             let amountsString = $t02248422669._6
631631             let assetsList = removeByIndex(split_51C(assetsString, SEP), 0)
632632             let amountsList = removeByIndex(split_51C(amountsString, SEP), 0)
633633             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)]
634634             $Tuple2(nil, factoryActions)
635635             }
636636         else throw("Strict value is not equal to itself.")
637637     }
638638 
639639 
640640 
641641 @Callable(i)
642642 func claimCollateralBulk (userAddressBytes,txIds) = {
643643     let checkCaller = onlyFactory(i)
644644     if ((checkCaller == checkCaller))
645645         then {
646646             func addNewAction (state,txId) =             {
647647                 let $t02342723626 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
648648                 let userAddress = $t02342723626._1
649649                 let lpAssetAmount = $t02342723626._2
650650                 let targetPeriod = $t02342723626._3
651651                 let wavesAmount = $t02342723626._4
652652                 let assetsString = $t02342723626._5
653653                 let amountsString = $t02342723626._6
654654                 let assetsList = removeByIndex(split_51C(assetsString, SEP), 0)
655655                 let amountsList = removeByIndex(split_51C(amountsString, SEP), 0)
656656                 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)]
657657                 (state ++ newActions)
658658                 }
659659 
660660             let allFactoryActions = {
661661                 let $l = txIds
662662                 let $s = size($l)
663663                 let $acc0 = nil
664664                 func $f0_1 ($a,$i) =                 if (($i >= $s))
665665                     then $a
666666                     else addNewAction($a, $l[$i])
667667 
668668                 func $f0_2 ($a,$i) =                 if (($i >= $s))
669669                     then $a
670670                     else throw("List size exceeds 10")
671671 
672672                 $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)
673673                 }
674674             $Tuple2(nil, allFactoryActions)
675675             }
676676         else throw("Strict value is not equal to itself.")
677677     }
678678 
679679 
680680 
681681 @Callable(i)
682682 func claimCollateralREADONLY (userAddressBytes,txId) = {
683683     let response = claimCollateralREADONLYStringResponse(userAddressBytes, fromBase58String(txId))
684684     $Tuple2(nil, response)
685685     }
686686 
687687 
688688 
689689 @Callable(i)
690690 func claimCollateralBulkREADONLY (userAddressBytes,txIds) = {
691691     func processTxId (state,txId) =     {
692692         let response = claimCollateralREADONLYStringResponse(userAddressBytes, fromBase58String(txId))
693693         (state :+ response)
694694         }
695695 
696696     let allResponses = {
697697         let $l = txIds
698698         let $s = size($l)
699699         let $acc0 = nil
700700         func $f0_1 ($a,$i) =         if (($i >= $s))
701701             then $a
702702             else processTxId($a, $l[$i])
703703 
704704         func $f0_2 ($a,$i) =         if (($i >= $s))
705705             then $a
706706             else throw("List size exceeds 10")
707707 
708708         $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)
709709         }
710710     $Tuple2(nil, allResponses)
711711     }
712712 
713713 
714714 
715715 @Callable(i)
716716 func processBlocks (userAddressBytes) = {
717717     let checkCaller = onlyFactory(i)
718718     if ((checkCaller == checkCaller))
719719         then {
720720             let userAddress = Address(userAddressBytes)
721721             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
722722             let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
723723             let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
724724             let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
725725             let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
726726             let periodEndHeight = ((currentStartHeight + periodLength) - 1)
727727             let blocksProcessingBatchSizeMax = 20
728728             let blocksProcessingBatchSize = if (if (if ((height >= nextBlockToProcess))
729729                 then if ((nextBlockToProcess >= currentStartHeight))
730730                     then true
731731                     else (currentPeriodOrFail == 0)
732732                 else false)
733733                 then (periodEndHeight >= nextBlockToProcess)
734734                 else false)
735735                 then min([((periodEndHeight - nextBlockToProcess) + 1), blocksProcessingBatchSizeMax])
736736                 else throwErr(wrapErr("invalid target block"))
737737             let blockProcessingReward = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
738738             let blockProcessingRewardByGenerator = (blockProcessingReward / blocksProcessingBatchSize)
739739             let blockProcessingRewardByGeneratorRemainder = (blockProcessingReward - (blockProcessingRewardByGenerator * blocksProcessingBatchSize))
740740             func map (acc,inc) =             if ((inc >= blocksProcessingBatchSize))
741741                 then acc
742742                 else {
743743                     let targetBlockHeight = (nextBlockToProcess + inc)
744744                     let targetBlockInfo = valueOrErrorMessage(blockInfoByHeight(targetBlockHeight), wrapErr("invalid block info"))
745745                     let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, proxyTreasuryAddressOrFail), wrapErr(("invalid treasury reward for height " + toString(targetBlockHeight))))
746746                     let generator = targetBlockInfo.generator
747747                     let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(generator)), 0)
748748                     let callerReward = if ((inc == (blocksProcessingBatchSize - 1)))
749749                         then (blockProcessingRewardByGenerator + blockProcessingRewardByGeneratorRemainder)
750750                         else blockProcessingRewardByGenerator
751751                     let $t02756627674 = getRewardSplit(treasuryRewardOrFail)
752752                     let shareAmountToPower = $t02756627674._1
753753                     let businessTreasuryAmountPart = $t02756627674._2
754754                     let rewardRemainder = $t02756627674._3
755755                     let lpAssetAmount = if ((currentPriceOrFail > 0))
756756                         then fraction((rewardRemainder - callerReward), SCALE8, currentPriceOrFail)
757757                         else 0
758758                     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)]
759759                     if ((factoryActionsSingle == factoryActionsSingle))
760760                         then {
761761                             let $t02852228597 = acc
762762                             let lpAssetAcc = $t02852228597._1
763763                             let rewardAcc = $t02852228597._2
764764                             let businessTreasuryAcc = $t02852228597._3
765765                             let powerShareDataTuple = $t02852228597._4
766766                             let $t02860428670 = powerShareDataTuple
767767                             let powerShareAcc = $t02860428670._1
768768                             let generatorPowerShareList = $t02860428670._2
769769                             let newGeneratorPowerShareList = (generatorPowerShareList :+ $Tuple2(toString(generator), shareAmountToPower))
770770                             $Tuple4((lpAssetAcc + lpAssetAmount), (rewardAcc + treasuryRewardOrFail), (businessTreasuryAcc + businessTreasuryAmountPart), $Tuple2((powerShareAcc + shareAmountToPower), newGeneratorPowerShareList))
771771                             }
772772                         else throw("Strict value is not equal to itself.")
773773                     }
774774 
775775             let list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
776776             let $t02911829280 = {
777777                 let $l = list
778778                 let $s = size($l)
779779                 let $acc0 = $Tuple4(0, 0, 0, $Tuple2(0, nil))
780780                 func $f0_1 ($a,$i) =                 if (($i >= $s))
781781                     then $a
782782                     else map($a, $l[$i])
783783 
784784                 func $f0_2 ($a,$i) =                 if (($i >= $s))
785785                     then $a
786786                     else throw("List size exceeds 20")
787787 
788788                 $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)
789789                 }
790790             if (($t02911829280 == $t02911829280))
791791                 then {
792792                     let powerShareDataTuple = $t02911829280._4
793793                     let rewardToBusinessTreasuryAmount = $t02911829280._3
794794                     let rewardAmountTotal = $t02911829280._2
795795                     let lpAssetAmountTotal = $t02911829280._1
796796                     let $t02928429353 = powerShareDataTuple
797797                     let amountToPowerTotal = $t02928429353._1
798798                     let powerShareAmountsList = $t02928429353._2
799799                     let rewardToMainTreasuryAmount = (((rewardAmountTotal - rewardToBusinessTreasuryAmount) - blockProcessingReward) - amountToPowerTotal)
800800                     let invested = valueOrElse(getInteger(factoryAddressOrFail, keyInvested(unit)), 0)
801801                     let powerShareActions = if ((amountToPowerTotal > 0))
802802                         then {
803803                             let transferAction = [invoke(factoryAddressOrFail, "transferFromProxyTreasury", [factoryAddressOrFail.bytes, amountToPowerTotal], nil)]
804804                             if ((transferAction == transferAction))
805805                                 then {
806806                                     let totalPowerAmount = invoke(factoryAddressOrFail, "swap", [powerAssetIdStringOrFail, WAVES, amountToPowerTotal], nil)
807807                                     if ((totalPowerAmount == totalPowerAmount))
808808                                         then {
809809                                             let totalPowerAmountInt =                                             match totalPowerAmount {
810810                                                 case pAmount: Int => 
811811                                                     pAmount
812812                                                 case _ => 
813813                                                     0
814814                                             }
815815                                             func stakePowerInvoke (acc,next) =                                             {
816816                                                 let $t03022730262 = next
817817                                                 let generator = $t03022730262._1
818818                                                 let shareAmount = $t03022730262._2
819819                                                 if ((amountToPowerTotal > 0))
820820                                                     then {
821821                                                         let powerAmount = fraction(shareAmount, totalPowerAmountInt, amountToPowerTotal)
822822                                                         let inv = invoke(factoryAddressOrFail, "powerStake", [fromBase58String(generator), fromBase58String(powerAssetIdStringOrFail), powerAmount], nil)
823823                                                         if ((inv == inv))
824824                                                             then nil
825825                                                             else throw("Strict value is not equal to itself.")
826826                                                         }
827827                                                     else nil
828828                                                 }
829829 
830830                                             let powerStakesActions = {
831831                                                 let $l = powerShareAmountsList
832832                                                 let $s = size($l)
833833                                                 let $acc0 = 0
834834                                                 func $f1_1 ($a,$i) =                                                 if (($i >= $s))
835835                                                     then $a
836836                                                     else stakePowerInvoke($a, $l[$i])
837837 
838838                                                 func $f1_2 ($a,$i) =                                                 if (($i >= $s))
839839                                                     then $a
840840                                                     else throw("List size exceeds 20")
841841 
842842                                                 $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)
843843                                                 }
844844                                             if ((powerStakesActions == powerStakesActions))
845845                                                 then nil
846846                                                 else throw("Strict value is not equal to itself.")
847847                                             }
848848                                         else throw("Strict value is not equal to itself.")
849849                                     }
850850                                 else throw("Strict value is not equal to itself.")
851851                             }
852852                         else nil
853853                     if ((powerShareActions == powerShareActions))
854854                         then {
855855                             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)]
856856                             if ((actions == actions))
857857                                 then $Tuple2(nil, unit)
858858                                 else throw("Strict value is not equal to itself.")
859859                             }
860860                         else throw("Strict value is not equal to itself.")
861861                     }
862862                 else throw("Strict value is not equal to itself.")
863863             }
864864         else throw("Strict value is not equal to itself.")
865865     }
866866 
867867 
868868 @Verifier(tx)
869869 func verify () = {
870870     let publicKey =     match getManagerPublicKeyOrUnit() {
871871         case pub: ByteVector => 
872872             pub
873873         case _ => 
874874             tx.senderPublicKey
875875     }
876876     sigVerify(tx.bodyBytes, tx.proofs[0], publicKey)
877877     }
878878 
github/deemru/w8io/169f3d6 
76.50 ms ◑