tx · A39GaZW6jN363AdoaKKBJKb8j8a7gV5dGrA81BzYiNZE

3MpygN8qm376tUAHB6mhC5BxG5NKYortiyX:  -0.03100000 Waves

2022.10.28 15:50 [2292277] smart account 3MpygN8qm376tUAHB6mhC5BxG5NKYortiyX > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "A39GaZW6jN363AdoaKKBJKb8j8a7gV5dGrA81BzYiNZE",
    "fee": 3100000,
    "feeAssetId": null,
    "timestamp": 1666961449067,
    "version": 2,
    "chainId": 84,
    "sender": "3MpygN8qm376tUAHB6mhC5BxG5NKYortiyX",
    "senderPublicKey": "BjnLnkAMaJLYAK36vQqSepUNjGeMDHfZGfmdYwGcLbmg",
    "proofs": [
        "2CVZ1vYLKqeUk9SyTD5FbDjY3zYro6rCHpyJQanwYLgEvGrSVnvKsM5JQUEAM7vDXBUqKNtpsd7dcFhg9QtS8NbL"
    ],
    "script": "base64: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",
    "height": 2292277,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: CPJBNgiqCoi4X64H6kPiZV8k5jRgYMuRPHtNh9CMpnJ4

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let version = "2.0.0"
5+
6+let kVersion = "version"
7+
8+let kActive = "active"
9+
10+let kAssetIdA = "A_asset_id"
11+
12+let kAssetIdB = "B_asset_id"
13+
14+let kBalanceA = "A_asset_balance"
15+
16+let kBalanceB = "B_asset_balance"
17+
18+let kShareAssetId = "share_asset_id"
19+
20+let kShareAssetSupply = "share_asset_supply"
21+
22+let kFee = "commission"
23+
24+let kInvariant = "invariant"
25+
26+let kCause = "shutdown_cause"
27+
28+let kUSDNAddress = "staking_usdnnsbt_address"
29+
30+let kEURNAddress = "staking_eurn_address"
31+
32+let kDiscounts = "discounts"
33+
34+let kDiscountValues = "discount_values"
35+
36+let kUserSwopInGov = "_SWOP_amount"
37+
38+let kUserGSwopInGov = "_GSwop_amount"
39+
40+let kFirstHarvest = "first_harvest"
41+
42+let kFirstHarvestHeight = "first_harvest_height"
43+
44+let kShareLimit = "share_limit_on_first_harvest"
45+
46+let kBasePeriod = "base_period"
47+
48+let kPeriodLength = "period_length"
49+
50+let kStartHeight = "start_height"
51+
52+let kAdminPubKey1 = "admin_pub_1"
53+
54+let kAdminPubKey2 = "admin_pub_2"
55+
56+let kAdminPubKey3 = "admin_pub_3"
57+
58+let kAdminInvokePubKey = "admin_invoke_pub"
59+
60+let kMoneyBoxAddress = "money_box_address"
61+
62+let kGovAddress = "governance_address"
63+
64+let kFarmingAddress = "farming_address"
65+
66+let kVotingAddress = "voting_address"
67+
68+let kUSDNAssetId = "usdn_asset_id"
69+
70+let kStakingAssets = "staking_assets"
71+
72+let oracle = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
73+
74+func getBase58FromOracle (key) = match getString(oracle, key) {
75+    case string: String => 
76+        fromBase58String(string)
77+    case nothing => 
78+        throw((key + "is empty"))
79+}
80+
81+
82+let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
83+
84+let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
85+
86+let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
87+
88+let adminPubKeyInvoke = getBase58FromOracle(kAdminInvokePubKey)
89+
90+let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
91+
92+let govAddress = Address(getBase58FromOracle(kGovAddress))
93+
94+let stakingUSDNAddress = Address(getBase58FromOracle(kUSDNAddress))
95+
96+let votingAddress = Address(getBase58FromOracle(kVotingAddress))
97+
98+let farmingAddress = Address(getBase58FromOracle(kFarmingAddress))
99+
100+let USDN = getBase58FromOracle(kUSDNAssetId)
101+
102+let stakingAssets = getStringValue(oracle, kStakingAssets)
103+
104+let basePeriod = valueOrErrorMessage(getInteger(votingAddress, kBasePeriod), "Empty kBasePeriod")
105+
106+let startHeight = valueOrErrorMessage(getInteger(votingAddress, kStartHeight), "Empty kStartHeight")
107+
108+let periodLength = valueOrErrorMessage(getInteger(votingAddress, kPeriodLength), "Empty kPeriodLength")
109+
110+let firstHarvestEndPeriod = ((basePeriod + ((height - startHeight) / periodLength)) + 3)
111+
112+let active = getBooleanValue(this, kActive)
113+
114+let strAssetIdA = getStringValue(this, kAssetIdA)
115+
116+let strAssetIdB = getStringValue(this, kAssetIdB)
117+
118+let assetIdA = if ((strAssetIdA == "WAVES"))
119+    then unit
120+    else fromBase58String(strAssetIdA)
121+
122+let assetIdB = if ((strAssetIdB == "WAVES"))
123+    then unit
124+    else fromBase58String(strAssetIdB)
125+
126+let assetNameA = match assetIdA {
127+    case id: ByteVector => 
128+        value(assetInfo(id)).name
129+    case waves: Unit => 
130+        "WAVES"
131+    case _ => 
132+        throw("Match error")
133+}
134+
135+let assetNameB = match assetIdB {
136+    case id: ByteVector => 
137+        value(assetInfo(id)).name
138+    case waves: Unit => 
139+        "WAVES"
140+    case _ => 
141+        throw("Match error")
142+}
143+
144+let balanceA = getIntegerValue(this, kBalanceA)
145+
146+let balanceB = getIntegerValue(this, kBalanceB)
147+
148+let shareAssetId = fromBase58String(getStringValue(this, kShareAssetId))
149+
150+let shareAssetSupply = getIntegerValue(this, kShareAssetSupply)
151+
152+let invariant = getIntegerValue(this, kInvariant)
153+
154+let fee = getIntegerValue(this, kFee)
155+
156+let feeGovernance = fraction(fee, 40, 100)
157+
158+let feeScale6 = 1000000
159+
160+let scale3 = 1000
161+
162+let scale8 = 100000000
163+
164+let scale16 = 10000000000000000
165+
166+let digits8 = 8
167+
168+let dAppThreshold = 50
169+
170+let dAppThresholdScale2 = 100
171+
172+let exchangeRatioLimitMin = 90000000
173+
174+let exchangeRatioLimitMax = 110000000
175+
176+let alpha = 50
177+
178+let alphaDigits = 2
179+
180+let beta = 4600000000000000
181+
182+func accountBalance (assetId) = match assetId {
183+    case id: ByteVector => 
184+        assetBalance(this, id)
185+    case waves: Unit => 
186+        wavesBalance(this).available
187+    case _ => 
188+        throw("Match error")
189+}
190+
191+
192+func stakedAmount (assetId) = {
193+    let stakedAmountCalculated =     match assetId {
194+        case aId: ByteVector => 
195+            if ((aId == USDN))
196+                then getInteger(stakingUSDNAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(this)))
197+                else 0
198+        case _: Unit => 
199+            0
200+        case _ => 
201+            throw("Match error")
202+    }
203+    match stakedAmountCalculated {
204+        case i: Int => 
205+            i
206+        case _ => 
207+            0
208+    }
209+    }
210+
211+
212+let stakedAmountA = stakedAmount(assetIdA)
213+
214+let stakedAmountB = stakedAmount(assetIdB)
215+
216+let availableBalanceA = (balanceA - stakedAmountA)
217+
218+let availableBalanceB = (balanceB - stakedAmountB)
219+
220+let accountBalanceWithStakedA = (accountBalance(assetIdA) + stakedAmountA)
221+
222+let accountBalanceWithStakedB = (accountBalance(assetIdB) + stakedAmountB)
223+
224+let hasEnoughBalance = if ((accountBalanceWithStakedA >= balanceA))
225+    then (accountBalanceWithStakedB >= balanceB)
226+    else false
227+
228+func skewness (x,y) = ((fraction(scale16, x, y) + fraction(scale16, y, x)) / 2)
229+
230+
231+func invariantCalc (x,y) = {
232+    let sk = skewness(x, y)
233+    (fraction((x + y), scale16, pow(sk, digits8, alpha, alphaDigits, digits8, CEILING)) + (2 * fraction(toInt(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN)), pow((sk - beta), digits8, alpha, alphaDigits, digits8, DOWN), scale8)))
234+    }
235+
236+
237+func calculateSendAmount (amountToSendEstimated,minTokenReceiveAmount,tokenReceiveAmount,tokenId,balcA,balcB,invCur) = {
238+    let worstAllowedNewInvariantRatio = (scale16 - ((scale16 * 1) / 10000000))
239+    let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
240+    let x = (balcA + tokenReceiveAmount)
241+    let y = (balcB + tokenReceiveAmount)
242+    func getStepAmount (acc,step) =     if ((acc._1 == -1))
243+        then {
244+            let amountToSend = (amountToSendEstimated - (((step * deltaBetweenMaxAndMinSendValue) / 3) / scale3))
245+            let stepInvariant = if ((tokenId == assetIdA))
246+                then invariantCalc(x, (balcB - amountToSend))
247+                else invariantCalc((balcA - amountToSend), y)
248+            if ((stepInvariant > invCur))
249+                then $Tuple2(amountToSend, stepInvariant)
250+                else $Tuple2(-1, 0)
251+            }
252+        else acc
253+
254+    let amountToSendMin = getStepAmount($Tuple2(-1, 0), 3000)
255+    if ((0 > amountToSendMin._1))
256+        then throw("Price is worse than minReceived")
257+        else {
258+            let invEstimated = if ((tokenId == assetIdA))
259+                then invariantCalc(x, (balcB - amountToSendEstimated))
260+                else if ((tokenId == assetIdB))
261+                    then invariantCalc((balcA - amountToSendEstimated), y)
262+                    else throw("Wrong asset in payment")
263+            if ((invCur > invEstimated))
264+                then if ((worstAllowedNewInvariantRatio >= fraction(scale16, invCur, invEstimated)))
265+                    then throw("The requested price is too not profitable for user")
266+                    else {
267+                        let a = {
268+                            let $l = [25, 200, 500]
269+                            let $s = size($l)
270+                            let $acc0 = $Tuple2(-1, 0)
271+                            func $f0_1 ($a,$i) =                             if (($i >= $s))
272+                                then $a
273+                                else getStepAmount($a, $l[$i])
274+
275+                            func $f0_2 ($a,$i) =                             if (($i >= $s))
276+                                then $a
277+                                else throw("List size exceeds 3")
278+
279+                            $f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
280+                            }
281+                        if ((0 > a._1))
282+                            then amountToSendMin._1
283+                            else a._1
284+                        }
285+                else {
286+                    let a = {
287+                        let $l = [-500, -200, -25]
288+                        let $s = size($l)
289+                        let $acc0 = $Tuple2(-1, 0)
290+                        func $f0_1 ($a,$i) =                         if (($i >= $s))
291+                            then $a
292+                            else getStepAmount($a, $l[$i])
293+
294+                        func $f0_2 ($a,$i) =                         if (($i >= $s))
295+                            then $a
296+                            else throw("List size exceeds 3")
297+
298+                        $f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
299+                        }
300+                    let tupleSendBetter = if ((0 > a._1))
301+                        then $Tuple2(amountToSendEstimated, invEstimated)
302+                        else a
303+                    if ((worstAllowedNewInvariantRatio >= fraction(scale16, invCur, tupleSendBetter._2)))
304+                        then throw("The requested price is too not profitable for user")
305+                        else tupleSendBetter._1
306+                    }
307+            }
308+    }
309+
310+
311+func getAssetInfo (assetId) = match assetId {
312+    case id: ByteVector => 
313+        let stringId = toBase58String(id)
314+        let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
315+        $Tuple3(stringId, info.name, info.decimals)
316+    case waves: Unit => 
317+        $Tuple3("WAVES", "WAVES", 8)
318+    case _ => 
319+        throw("Match error")
320+}
321+
322+
323+func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
324+
325+
326+func throwIsActive () = throw("DApp is already active")
327+
328+
329+func isActive () = if (active)
330+    then unit
331+    else throw("DApp is inactive at this moment")
332+
333+
334+func isAdminCall (i) = if (containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey))
335+    then unit
336+    else throw("Only admin can call this function")
337+
338+
339+func isSelfCall (i) = if ((this == i.caller))
340+    then unit
341+    else throw("Only contract itself can call this function")
342+
343+
344+func throwAssets () = throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
345+
346+
347+func throwOnePayment () = throw("One attached payment expected")
348+
349+
350+func throwThreshold (threshold,amountA,amountB) = throw(((((((((("New balance in assets of the DApp is less than threshold " + toString(threshold)) + ": ") + toString(amountA)) + " ") + assetNameA) + ", ") + toString(amountB)) + " ") + assetNameB))
351+
352+
353+func suspendSuspicious () = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB) + ". State: ") + toString(accountBalance(assetIdA))) + " ") + assetNameA) + ", ") + toString(accountBalance(assetIdB))) + " ") + assetNameB))
354+
355+
356+func calcStakingFuncAndAddres (stake,assetId) = if (stake)
357+    then $Tuple2("lockNeutrino", stakingUSDNAddress)
358+    else $Tuple2("unlockNeutrino", stakingUSDNAddress)
359+
360+
361+func calcStakingParams (stake,amount,assetId) = if (stake)
362+    then {
363+        let $t01038310449 = calcStakingFuncAndAddres(stake, assetId)
364+        let call = $t01038310449._1
365+        let stakingAddr = $t01038310449._2
366+        $Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
367+        }
368+    else {
369+        let $t01053510601 = calcStakingFuncAndAddres(stake, assetId)
370+        let call = $t01053510601._1
371+        let stakingAddr = $t01053510601._2
372+        $Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
373+        }
374+
375+
376+func calculateFeeDiscount (userAddr) = {
377+    let swopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserSwopInGov)), 0)
378+    let gSwopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserGSwopInGov)), 0)
379+    let discountValues = split(getStringValue(oracle, kDiscountValues), ",")
380+    let discounts = split(getStringValue(oracle, kDiscounts), ",")
381+    if (if ((gSwopAmount >= parseIntValue(discountValues[0])))
382+        then (parseIntValue(discountValues[1]) > gSwopAmount)
383+        else false)
384+        then (feeScale6 - parseIntValue(discounts[0]))
385+        else if (if ((gSwopAmount >= parseIntValue(discountValues[1])))
386+            then (parseIntValue(discountValues[2]) > gSwopAmount)
387+            else false)
388+            then (feeScale6 - parseIntValue(discounts[1]))
389+            else if (if ((gSwopAmount >= parseIntValue(discountValues[2])))
390+                then (parseIntValue(discountValues[3]) > gSwopAmount)
391+                else false)
392+                then (feeScale6 - parseIntValue(discounts[2]))
393+                else if (if ((gSwopAmount >= parseIntValue(discountValues[3])))
394+                    then (parseIntValue(discountValues[4]) > gSwopAmount)
395+                    else false)
396+                    then (feeScale6 - parseIntValue(discounts[3]))
397+                    else if ((gSwopAmount >= parseIntValue(discountValues[4])))
398+                        then (feeScale6 - parseIntValue(discounts[4]))
399+                        else feeScale6
400+    }
401+
402+
403+@Callable(i)
404+func init (firstHarvest) = {
405+    let $t01190111978 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
406+    let pmtAmountA = $t01190111978._1
407+    let pmtAssetIdA = $t01190111978._2
408+    let $t01198312060 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
409+    let pmtAmountB = $t01198312060._1
410+    let pmtAssetIdB = $t01198312060._2
411+    let $t01206512142 = getAssetInfo(pmtAssetIdA)
412+    let pmtStrAssetIdA = $t01206512142._1
413+    let pmtAssetNameA = $t01206512142._2
414+    let pmtDecimalsA = $t01206512142._3
415+    let $t01214712224 = getAssetInfo(pmtAssetIdB)
416+    let pmtStrAssetIdB = $t01214712224._1
417+    let pmtAssetNameB = $t01214712224._2
418+    let pmtDecimalsB = $t01214712224._3
419+    if (isDefined(getBoolean(this, kActive)))
420+        then throwIsActive()
421+        else if ((pmtAssetIdA == pmtAssetIdB))
422+            then throw("Assets must be different")
423+            else {
424+                let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
425+                let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
426+                let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
427+                let shareInitialSupply = fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN), pow(10, 0, shareDecimals, 0, 0, DOWN))
428+                let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
429+                let shareIssueId = calculateAssetId(shareIssue)
430+                let invariantCalculated = invariantCalc(pmtAmountA, pmtAmountB)
431+                let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
432+                    then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
433+                    else 0
434+                if ((stake1 == stake1))
435+                    then {
436+                        let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
437+                            then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
438+                            else 0
439+                        if ((stake2 == stake2))
440+                            then {
441+                                let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceA, pmtAmountA), IntegerEntry(kBalanceB, pmtAmountB), IntegerEntry(kInvariant, invariantCalculated), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_flat")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
442+                                if (firstHarvest)
443+                                    then (baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))])
444+                                    else baseEntry
445+                                }
446+                            else throw("Strict value is not equal to itself.")
447+                        }
448+                    else throw("Strict value is not equal to itself.")
449+                }
450+    }
451+
452+
453+
454+@Callable(i)
455+func replenishWithTwoTokens (stakeFarming,lockType) = valueOrElse(isActive(), {
456+    let pmtAssetIdA = i.payments[0].assetId
457+    let pmtAssetIdB = i.payments[1].assetId
458+    let ratioShareTokensInA = fraction(scale8, i.payments[0].amount, balanceA)
459+    let ratioShareTokensInB = fraction(scale8, i.payments[1].amount, balanceB)
460+    let $t01519415271 = getAssetInfo(pmtAssetIdA)
461+    let pmtStrAssetIdA = $t01519415271._1
462+    let pmtAssetNameA = $t01519415271._2
463+    let pmtDecimalsA = $t01519415271._3
464+    let $t01527615393 = getAssetInfo(pmtAssetIdB)
465+    let pmtStrAssetIdB = $t01527615393._1
466+    let pmtAssetNameB = $t01527615393._2
467+    let pmtDecimalsB = $t01527615393._3
468+    let $t01539815902 = if ((ratioShareTokensInB > ratioShareTokensInA))
469+        then {
470+            let pmt = fraction(balanceB, ratioShareTokensInA, scale8, CEILING)
471+            $Tuple5(i.payments[0].amount, pmt, (i.payments[1].amount - pmt), pmtAssetIdB, ratioShareTokensInA)
472+            }
473+        else {
474+            let pmt = fraction(balanceA, ratioShareTokensInB, scale8, CEILING)
475+            $Tuple5(pmt, i.payments[1].amount, (i.payments[0].amount - pmt), pmtAssetIdA, ratioShareTokensInB)
476+            }
477+    let pmtAmountA = $t01539815902._1
478+    let pmtAmountB = $t01539815902._2
479+    let change = $t01539815902._3
480+    let changeAssetId = $t01539815902._4
481+    let shareTokenRatio = $t01539815902._5
482+    let shareTokenToPayAmount = fraction(shareTokenRatio, shareAssetSupply, scale8)
483+    if (if ((size(i.payments) != 2))
484+        then (size(i.payments) != 3)
485+        else false)
486+        then throw("Two or three payments expected")
487+        else if (if ((pmtAssetIdA != assetIdA))
488+            then true
489+            else (pmtAssetIdB != assetIdB))
490+            then throwAssets()
491+            else if ((shareTokenToPayAmount == 0))
492+                then throw("Too small amount to replenish")
493+                else if ((0 > change))
494+                    then throw("Change < 0")
495+                    else if (!(hasEnoughBalance))
496+                        then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
497+                        else {
498+                            let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
499+                                then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
500+                                else 0
501+                            if ((stake1 == stake1))
502+                                then {
503+                                    let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
504+                                        then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
505+                                        else 0
506+                                    if ((stake2 == stake2))
507+                                        then {
508+                                            let scriptActions = [IntegerEntry(kBalanceA, (balanceA + pmtAmountA)), IntegerEntry(kBalanceB, (balanceB + pmtAmountB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(kInvariant, invariantCalc((balanceA + pmtAmountA), (balanceB + pmtAmountB))), ScriptTransfer(i.caller, change, changeAssetId)]
509+                                            if (stakeFarming)
510+                                                then {
511+                                                    let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmount)] ++ (if ((size(i.payments) == 3))
512+                                                        then [AttachedPayment(i.payments[2].assetId, i.payments[2].amount)]
513+                                                        else nil))
514+                                                    let re = invoke(this, "reissueShare", [shareTokenToPayAmount], nil)
515+                                                    if ((re == re))
516+                                                        then {
517+                                                            let s = invoke(farmingAddress, "lockShareTokens", [toString(this), lockType], stPayments)
518+                                                            if ((s == s))
519+                                                                then scriptActions
520+                                                                else throw("Strict value is not equal to itself.")
521+                                                            }
522+                                                        else throw("Strict value is not equal to itself.")
523+                                                    }
524+                                                else (scriptActions ++ [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId)])
525+                                            }
526+                                        else throw("Strict value is not equal to itself.")
527+                                    }
528+                                else throw("Strict value is not equal to itself.")
529+                            }
530+    })
531+
532+
533+
534+@Callable(i)
535+func replenishWithOneToken (virtualSwapTokenPay,virtualSwapTokenGet,stakeFarming,lockType) = valueOrElse(isActive(), {
536+    let $t01828118356 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
537+    let pmtAmount = $t01828118356._1
538+    let pmtAssetId = $t01828118356._2
539+    let $t01836118434 = getAssetInfo(pmtAssetId)
540+    let pmtStrAssetId = $t01836118434._1
541+    let pmtAssetName = $t01836118434._2
542+    let pmtDecimals = $t01836118434._3
543+    let pmtMinThreshold = 5000000
544+    let thresholdValueForMinTolerance = 50000000
545+    let tolerance = if ((thresholdValueForMinTolerance > pmtAmount))
546+        then 100000
547+        else 1
548+    let slippageValueMinForReplenish = (scale8 - ((scale8 * tolerance) / 10000000))
549+    let slippageValueMaxForReplenish = (scale8 + ((scale8 * tolerance) / 10000000))
550+    let slippageValueMinForSwap = (scale8 - ((scale8 * 1) / 10000000))
551+    if ((pmtMinThreshold > pmtAmount))
552+        then throw((((("Payment amount " + toString(pmtAmount)) + " does not exceed the minimum amount of ") + toString(pmtMinThreshold)) + " tokens"))
553+        else if (if ((size(i.payments) != 1))
554+            then (size(i.payments) != 2)
555+            else false)
556+            then throw("One or two payments expected")
557+            else if (!(hasEnoughBalance))
558+                then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
559+                else if (if ((pmtAssetId != assetIdA))
560+                    then (pmtAssetId != assetIdB)
561+                    else false)
562+                    then throwAssets()
563+                    else {
564+                        let $t01944120083 = if ((pmtAssetId == assetIdA))
565+                            then $Tuple6((pmtAmount - virtualSwapTokenPay), virtualSwapTokenGet, (balanceA + virtualSwapTokenPay), (balanceB - virtualSwapTokenGet), (balanceA + pmtAmount), balanceB)
566+                            else $Tuple6(virtualSwapTokenGet, (pmtAmount - virtualSwapTokenPay), (balanceA - virtualSwapTokenGet), (balanceB + virtualSwapTokenPay), balanceA, (balanceB + pmtAmount))
567+                        let virtualReplenishA = $t01944120083._1
568+                        let virtualReplenishB = $t01944120083._2
569+                        let balanceAfterSwapA = $t01944120083._3
570+                        let balanceAfterSwapB = $t01944120083._4
571+                        let newBalanceA = $t01944120083._5
572+                        let newBalanceB = $t01944120083._6
573+                        let invariantNew = invariantCalc(balanceAfterSwapA, balanceAfterSwapB)
574+                        let ratioVirtualBalanceToVirtualReplenish = (fraction(scale16, balanceAfterSwapA, balanceAfterSwapB) / fraction(scale8, virtualReplenishA, virtualReplenishB))
575+                        let dAppThresholdAmount = fraction((newBalanceA + newBalanceB), dAppThreshold, (2 * dAppThresholdScale2))
576+                        if (if ((slippageValueMinForSwap >= fraction(scale8, invariant, invariantNew)))
577+                            then true
578+                            else (invariant > invariantNew))
579+                            then throw("Incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
580+                            else if (if ((slippageValueMinForReplenish > ratioVirtualBalanceToVirtualReplenish))
581+                                then true
582+                                else (ratioVirtualBalanceToVirtualReplenish > slippageValueMaxForReplenish))
583+                                then throw("Swap with virtualSwapTokenPay and virtualSwapTokenGet is possible, but ratio after virtual swap is incorrect")
584+                                else if (if ((dAppThresholdAmount > newBalanceA))
585+                                    then true
586+                                    else (dAppThresholdAmount > newBalanceB))
587+                                    then throwThreshold(dAppThresholdAmount, newBalanceA, newBalanceB)
588+                                    else {
589+                                        let ratioShareTokensInA = fraction(virtualReplenishA, scale8, balanceAfterSwapA)
590+                                        let ratioShareTokensInB = fraction(virtualReplenishB, scale8, balanceAfterSwapB)
591+                                        let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scale8)
592+                                        let shareTokenToPayAmountAfterFee = fraction(shareTokenToPayAmount, (feeScale6 - (fee / 2)), feeScale6)
593+                                        let shareTokenGovernanceReward = fraction(shareTokenToPayAmount, (feeGovernance / 2), feeScale6)
594+                                        let governanceRewardTokenA = fraction(shareTokenGovernanceReward, balanceA, shareAssetSupply)
595+                                        let governanceRewardTokenB = fraction(shareTokenGovernanceReward, balanceB, shareAssetSupply)
596+                                        let $t02207322368 = if ((pmtStrAssetId == strAssetIdA))
597+                                            then $Tuple3((pmtAmount - governanceRewardTokenA), governanceRewardTokenB, strAssetIdB)
598+                                            else $Tuple3((pmtAmount - governanceRewardTokenB), governanceRewardTokenA, strAssetIdA)
599+                                        let stakeAmount = $t02207322368._1
600+                                        let unstakeAmount = $t02207322368._2
601+                                        let unstakeAsset = $t02207322368._3
602+                                        let stake1 = if (contains(stakingAssets, pmtStrAssetId))
603+                                            then invoke(this, "stakeUnstake", [true, stakeAmount, pmtStrAssetId], nil)
604+                                            else 0
605+                                        if ((stake1 == stake1))
606+                                            then {
607+                                                let stake2 = if (contains(stakingAssets, unstakeAsset))
608+                                                    then invoke(this, "stakeUnstake", [false, unstakeAmount, unstakeAsset], nil)
609+                                                    else 0
610+                                                if ((stake2 == stake2))
611+                                                    then {
612+                                                        let scriptActions = [IntegerEntry(kBalanceA, (newBalanceA - governanceRewardTokenA)), IntegerEntry(kBalanceB, (newBalanceB - governanceRewardTokenB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmountAfterFee)), IntegerEntry(kInvariant, invariantCalc((newBalanceA - governanceRewardTokenA), (newBalanceB - governanceRewardTokenB))), ScriptTransfer(moneyBoxAddress, governanceRewardTokenA, assetIdA), ScriptTransfer(moneyBoxAddress, governanceRewardTokenB, assetIdB)]
613+                                                        if (stakeFarming)
614+                                                            then {
615+                                                                let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmountAfterFee)] ++ (if ((size(i.payments) == 2))
616+                                                                    then [AttachedPayment(i.payments[1].assetId, i.payments[1].amount)]
617+                                                                    else nil))
618+                                                                let re = invoke(this, "reissueShare", [shareTokenToPayAmountAfterFee], nil)
619+                                                                if ((re == re))
620+                                                                    then {
621+                                                                        let s = invoke(farmingAddress, "lockShareTokens", [toString(this), lockType], stPayments)
622+                                                                        if ((s == s))
623+                                                                            then scriptActions
624+                                                                            else throw("Strict value is not equal to itself.")
625+                                                                        }
626+                                                                    else throw("Strict value is not equal to itself.")
627+                                                                }
628+                                                            else (scriptActions ++ [Reissue(shareAssetId, shareTokenToPayAmountAfterFee, true), ScriptTransfer(i.caller, shareTokenToPayAmountAfterFee, shareAssetId)])
629+                                                        }
630+                                                    else throw("Strict value is not equal to itself.")
631+                                                }
632+                                            else throw("Strict value is not equal to itself.")
633+                                        }
634+                        }
635+    })
636+
637+
638+
639+@Callable(i)
640+func withdraw (unlockAmount) = valueOrElse(isActive(), {
641+    let $t02429724632 = if ((size(i.payments) == 1))
642+        then if ((i.payments[0].assetId != shareAssetId))
643+            then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
644+            else $Tuple2(i.payments[0].amount, i.payments[0].assetId)
645+        else $Tuple2(0, shareAssetId)
646+    let pmtAmount = $t02429724632._1
647+    let pmtAssetId = $t02429724632._2
648+    if (!(hasEnoughBalance))
649+        then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
650+        else {
651+            let unlock = if ((unlockAmount > 0))
652+                then invoke(farmingAddress, "withdrawShareTokens", [toString(this), unlockAmount], nil)
653+                else 0
654+            if ((unlock == unlock))
655+                then {
656+                    let withdrawAmount = (pmtAmount + unlockAmount)
657+                    let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
658+                    let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
659+                    let invariantCalculated = invariantCalc((balanceA - amountToPayA), (balanceB - amountToPayB))
660+                    let stake1 = if (contains(stakingAssets, strAssetIdA))
661+                        then invoke(this, "stakeUnstake", [false, amountToPayA, strAssetIdA], nil)
662+                        else 0
663+                    if ((stake1 == stake1))
664+                        then {
665+                            let stake2 = if (contains(stakingAssets, strAssetIdB))
666+                                then invoke(this, "stakeUnstake", [false, amountToPayB, strAssetIdB], nil)
667+                                else 0
668+                            if ((stake2 == stake2))
669+                                then [IntegerEntry(kBalanceA, (balanceA - amountToPayA)), IntegerEntry(kBalanceB, (balanceB - amountToPayB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), IntegerEntry(kInvariant, invariantCalculated), Burn(shareAssetId, withdrawAmount), ScriptTransfer(i.caller, amountToPayA, assetIdA), ScriptTransfer(i.caller, amountToPayB, assetIdB)]
670+                                else throw("Strict value is not equal to itself.")
671+                            }
672+                        else throw("Strict value is not equal to itself.")
673+                    }
674+                else throw("Strict value is not equal to itself.")
675+            }
676+    })
677+
678+
679+
680+@Callable(i)
681+func withdrawOneToken (unlockAmount,withdrawAsset,estimatedAmountToReceive,minAmountToReceive) = {
682+    let $t02624826583 = if ((size(i.payments) == 1))
683+        then if ((i.payments[0].assetId != shareAssetId))
684+            then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
685+            else $Tuple2(i.payments[0].amount, i.payments[0].assetId)
686+        else $Tuple2(0, shareAssetId)
687+    let pmtAmount = $t02624826583._1
688+    let pmtAssetId = $t02624826583._2
689+    if (if ((withdrawAsset != strAssetIdA))
690+        then (withdrawAsset != strAssetIdB)
691+        else false)
692+        then throw("Incorrect withdraw asset")
693+        else if (!(hasEnoughBalance))
694+            then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
695+            else {
696+                let unlock = if ((unlockAmount > 0))
697+                    then invoke(farmingAddress, "withdrawShareTokens", [toString(this), unlockAmount], nil)
698+                    else 0
699+                if ((unlock == unlock))
700+                    then {
701+                        let withdrawAmount = (pmtAmount + unlockAmount)
702+                        let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
703+                        let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
704+                        let newVirtBalcA = (balanceA - amountToPayA)
705+                        let newVirtBalcB = (balanceB - amountToPayB)
706+                        let feeDiscount = calculateFeeDiscount(i.originCaller)
707+                        let amountExchangedWithFee = if ((withdrawAsset == strAssetIdA))
708+                            then calculateSendAmount(estimatedAmountToReceive, minAmountToReceive, amountToPayB, assetIdB, newVirtBalcA, newVirtBalcB, invariantCalc(newVirtBalcA, newVirtBalcB))
709+                            else calculateSendAmount(estimatedAmountToReceive, minAmountToReceive, amountToPayA, assetIdA, newVirtBalcA, newVirtBalcB, invariantCalc(newVirtBalcA, newVirtBalcB))
710+                        let govReward = fraction(amountExchangedWithFee, fraction(feeGovernance, feeDiscount, feeScale6, CEILING), feeScale6)
711+                        let amountExchanged = fraction(amountExchangedWithFee, (feeScale6 - fraction(fee, feeDiscount, feeScale6, CEILING)), feeScale6)
712+                        let $t02809428423 = if ((withdrawAsset == strAssetIdA))
713+                            then $Tuple3((amountToPayA + amountExchanged), (((balanceA - amountToPayA) - amountExchanged) - govReward), balanceB)
714+                            else $Tuple3((amountToPayB + amountExchanged), balanceA, (((balanceB - amountToPayB) - amountExchanged) - govReward))
715+                        let amountToPay = $t02809428423._1
716+                        let balanceANew = $t02809428423._2
717+                        let balanceBNew = $t02809428423._3
718+                        let invariantCalculated = invariantCalc(balanceANew, balanceBNew)
719+                        let stake1 = if (contains(stakingAssets, withdrawAsset))
720+                            then invoke(this, "stakeUnstake", [false, (amountToPay + govReward), withdrawAsset], nil)
721+                            else 0
722+                        if ((stake1 == stake1))
723+                            then [IntegerEntry(kBalanceA, balanceANew), IntegerEntry(kBalanceB, balanceBNew), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), IntegerEntry(kInvariant, invariantCalculated), Burn(shareAssetId, withdrawAmount), ScriptTransfer(i.caller, amountToPay, fromBase58String(withdrawAsset)), ScriptTransfer(moneyBoxAddress, govReward, fromBase58String(withdrawAsset))]
724+                            else throw("Strict value is not equal to itself.")
725+                        }
726+                    else throw("Strict value is not equal to itself.")
727+                }
728+    }
729+
730+
731+
732+@Callable(i)
733+func exchange (estimatedAmountToReceive,minAmountToReceive) = valueOrElse(isActive(), {
734+    let $t02929529370 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
735+    let pmtAmount = $t02929529370._1
736+    let pmtAssetId = $t02929529370._2
737+    if ((0 >= estimatedAmountToReceive))
738+        then throw(("Estimated amount must be positive. Actual: " + toString(estimatedAmountToReceive)))
739+        else if ((minAmountToReceive > estimatedAmountToReceive))
740+            then throw("Minimal amount can't be greater than estimated.")
741+            else if ((size(i.payments) != 1))
742+                then throwOnePayment()
743+                else if (!(hasEnoughBalance))
744+                    then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
745+                    else if (if ((pmtAssetId != assetIdA))
746+                        then (pmtAssetId != assetIdB)
747+                        else false)
748+                        then throwAssets()
749+                        else if ((10000000 > pmtAmount))
750+                            then throw("Only swap of 10.000000 or more tokens is allowed")
751+                            else if (if ((exchangeRatioLimitMin > fraction(scale8, minAmountToReceive, pmtAmount)))
752+                                then true
753+                                else (fraction(scale8, estimatedAmountToReceive, pmtAmount) > exchangeRatioLimitMax))
754+                                then throw("Incorrect args and pmt ratio")
755+                                else {
756+                                    let sendAssetId = if ((pmtAssetId == assetIdA))
757+                                        then assetIdB
758+                                        else assetIdA
759+                                    let amount = calculateSendAmount(estimatedAmountToReceive, minAmountToReceive, pmtAmount, pmtAssetId, balanceA, balanceB, invariant)
760+                                    let feeDiscount = calculateFeeDiscount(i.originCaller)
761+                                    let governanceReward = fraction(amount, fraction(feeGovernance, feeDiscount, feeScale6, CEILING), feeScale6)
762+                                    let amountMinusFee = fraction(amount, (feeScale6 - fraction(fee, feeDiscount, feeScale6, CEILING)), feeScale6)
763+                                    let $t03085431116 = if ((pmtAssetId == assetIdA))
764+                                        then $Tuple2((balanceA + pmtAmount), ((balanceB - amountMinusFee) - governanceReward))
765+                                        else $Tuple2(((balanceA - amountMinusFee) - governanceReward), (balanceB + pmtAmount))
766+                                    let newBalanceA = $t03085431116._1
767+                                    let newBalanceB = $t03085431116._2
768+                                    let dAppThresholdAmount = fraction((newBalanceA + newBalanceB), dAppThreshold, (2 * dAppThresholdScale2))
769+                                    if (if ((dAppThresholdAmount > newBalanceA))
770+                                        then true
771+                                        else (dAppThresholdAmount > newBalanceB))
772+                                        then throwThreshold(dAppThresholdAmount, newBalanceA, newBalanceB)
773+                                        else {
774+                                            let $t03141531488 = getAssetInfo(pmtAssetId)
775+                                            let pmtStrAssetId = $t03141531488._1
776+                                            let pmtAssetName = $t03141531488._2
777+                                            let pmtDecimals = $t03141531488._3
778+                                            let $t03150131578 = getAssetInfo(sendAssetId)
779+                                            let sendStrAssetId = $t03150131578._1
780+                                            let sendAssetName = $t03150131578._2
781+                                            let sendDecimals = $t03150131578._3
782+                                            let stake1 = if (contains(stakingAssets, pmtStrAssetId))
783+                                                then invoke(this, "stakeUnstake", [true, pmtAmount, pmtStrAssetId], nil)
784+                                                else 0
785+                                            if ((stake1 == stake1))
786+                                                then {
787+                                                    let stake2 = if (contains(stakingAssets, sendStrAssetId))
788+                                                        then invoke(this, "stakeUnstake", [false, (amountMinusFee + governanceReward), sendStrAssetId], nil)
789+                                                        else 0
790+                                                    if ((stake2 == stake2))
791+                                                        then $Tuple2([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), IntegerEntry(kInvariant, invariantCalc(newBalanceA, newBalanceB)), ScriptTransfer(i.caller, amountMinusFee, sendAssetId), ScriptTransfer(moneyBoxAddress, governanceReward, sendAssetId)], [amountMinusFee, sendAssetId])
792+                                                        else throw("Strict value is not equal to itself.")
793+                                                    }
794+                                                else throw("Strict value is not equal to itself.")
795+                                            }
796+                                    }
797+    })
798+
799+
800+
801+@Callable(msg)
802+func reissueShare (amount) = valueOrElse(isSelfCall(msg), [Reissue(shareAssetId, amount, true)])
803+
804+
805+
806+@Callable(i)
807+func shutdown () = valueOrElse(isAdminCall(i), if (!(active))
808+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, kCause), "the cause wasn't specified")))
809+    else suspend("Paused by admin"))
810+
811+
812+
813+@Callable(i)
814+func activate () = valueOrElse(isAdminCall(i), if (active)
815+    then throwIsActive()
816+    else [BooleanEntry(kActive, true), DeleteEntry(kCause)])
817+
818+
819+
820+@Callable(i)
821+func takeIntoAccountExtraFunds () = valueOrElse(isActive(), {
822+    let amountEnrollA = (accountBalanceWithStakedA - balanceA)
823+    let amountEnrollB = (accountBalanceWithStakedB - balanceB)
824+    let invariantNew = invariantCalc((balanceA + amountEnrollA), (balanceB + amountEnrollB))
825+    if ((i.caller != moneyBoxAddress))
826+        then throw("Only the money box can call this function")
827+        else if (if ((0 > amountEnrollA))
828+            then true
829+            else (0 > amountEnrollB))
830+            then suspend("Enroll amount negative")
831+            else if (if ((amountEnrollA == 0))
832+                then (amountEnrollB == 0)
833+                else false)
834+                then throw("No money to take")
835+                else {
836+                    let stake1 = if (if (contains(stakingAssets, strAssetIdA))
837+                        then (amountEnrollA > 0)
838+                        else false)
839+                        then invoke(this, "stakeUnstake", [true, amountEnrollA, strAssetIdA], nil)
840+                        else 0
841+                    if ((stake1 == stake1))
842+                        then {
843+                            let stake2 = if (if (contains(stakingAssets, strAssetIdB))
844+                                then (amountEnrollB > 0)
845+                                else false)
846+                                then invoke(this, "stakeUnstake", [true, amountEnrollB, strAssetIdB], nil)
847+                                else 0
848+                            if ((stake2 == stake2))
849+                                then [IntegerEntry(kInvariant, invariantNew), IntegerEntry(kBalanceA, (balanceA + amountEnrollA)), IntegerEntry(kBalanceB, (balanceB + amountEnrollB))]
850+                                else throw("Strict value is not equal to itself.")
851+                            }
852+                        else throw("Strict value is not equal to itself.")
853+                    }
854+    })
855+
856+
857+
858+@Callable(i)
859+func keepLimitForFirstHarvest (shareLimit) = valueOrElse(isActive(), valueOrElse(isAdminCall(i), [IntegerEntry(kShareLimit, shareLimit)]))
860+
861+
862+
863+@Callable(i)
864+func stakeUnstake (stake,amount,assetIdString) = if ((i.caller != this))
865+    then throw("Only contract itself can invoke this function")
866+    else {
867+        let $t03488034983 = calcStakingParams(stake, amount, fromBase58String(assetIdString))
868+        let call = $t03488034983._1
869+        let addr = $t03488034983._2
870+        let params = $t03488034983._3
871+        let payments = $t03488034983._4
872+        let inv = invoke(addr, call, params, payments)
873+        if ((inv == inv))
874+            then nil
875+            else throw("Strict value is not equal to itself.")
876+        }
877+
878+
879+@Verifier(tx)
880+func verify () = {
881+    let multiSignedByAdmins = {
882+        let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
883+            then 1
884+            else 0
885+        let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
886+            then 1
887+            else 0
888+        let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
889+            then 1
890+            else 0
891+        (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
892+        }
893+    match tx {
894+        case inv: InvokeScriptTransaction => 
895+            let callTakeIntoAccount = if ((inv.dApp == this))
896+                then (inv.function == "takeIntoAccountExtraFunds")
897+                else false
898+            let signedByAdmin = if (if (if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
899+                then true
900+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey2))
901+                then true
902+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey3))
903+                then true
904+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKeyInvoke)
905+            if (if (callTakeIntoAccount)
906+                then signedByAdmin
907+                else false)
908+                then true
909+                else multiSignedByAdmins
910+        case _ => 
911+            multiSignedByAdmins
912+    }
913+    }
914+
github/deemru/w8io/026f985 
46.05 ms ◑