tx · BWrPjpKXpNiZtncGchV9mryyd8BKpaPr1cqvaQZSjy1p

3MqpghDrn9X96AXTro1agBNF4bjPGjTFqQG:  -0.01000000 Waves

2022.05.04 10:40 [2036651] smart account 3MqpghDrn9X96AXTro1agBNF4bjPGjTFqQG > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BWrPjpKXpNiZtncGchV9mryyd8BKpaPr1cqvaQZSjy1p",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1651650042920,
    "version": 2,
    "chainId": 84,
    "sender": "3MqpghDrn9X96AXTro1agBNF4bjPGjTFqQG",
    "senderPublicKey": "H7cLyENG3Lny5pE9EtuvpW7mUc8Ds92sQshADBVP4Zm6",
    "proofs": [
        "3CM2mWRqRXi945jNzd98v4hfQcLAi94MUK84EZhiTea4HcyqN9mXLZm48VeueA7w36z8rZ4rNKZXH5qbKee5BE5R"
    ],
    "script": "base64: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",
    "height": 2036651,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 6uEZG5YiuwUzHjiQkEj16Xdqa5WoHdmjsmQ13JDQnqT3

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let version = "1.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 kBalanceInitA = "A_asset_init"
19+
20+let kBalanceInitB = "B_asset_init"
21+
22+let kShareAssetId = "share_asset_id"
23+
24+let kShareAssetSupply = "share_asset_supply"
25+
26+let kFee = "commission"
27+
28+let kCause = "shutdown_cause"
29+
30+let kFirstHarvest = "first_harvest"
31+
32+let kFirstHarvestHeight = "first_harvest_height"
33+
34+let kShareLimit = "share_limit_on_first_harvest"
35+
36+let kBasePeriod = "base_period"
37+
38+let kPeriodLength = "period_length"
39+
40+let kStartHeight = "start_height"
41+
42+let kUSDNAddress = "staking_usdnnsbt_address"
43+
44+let kEURNAddress = "staking_eurn_address"
45+
46+let kLeasingPool = "leasing_address"
47+
48+let kLeasingAmount = "leasing_amount"
49+
50+let kLeasingId = "leasing_id"
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 oracle = Address(base58'3NBBWfzZtZtszaXbitTKnrB2xXwv26Bn7H9')
63+
64+func getBase58FromOracle (key) = match getString(oracle, key) {
65+    case string: String => 
66+        fromBase58String(string)
67+    case nothing => 
68+        throw((key + "is empty"))
69+}
70+
71+
72+let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
73+
74+let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
75+
76+let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
77+
78+let adminInvokePubKey = getBase58FromOracle(kAdminInvokePubKey)
79+
80+let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
81+
82+let votingAddress = Address(base58'3MrJgdL1GniipErHy44YF9idzLaUL2iX5DQ')
83+
84+let USDN = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
85+
86+let SWOP = base58'2HAJrwa8q4SxBx9cHYaBTQdBjdk5wwqdof7ccpAx2uhZ'
87+
88+let EURN = base58'ECBCkHS68DckpBrzLeoRgYbFg7sCVqR176mPqbXsj9pA'
89+
90+let stakingAssets = ["WAVES", toBase58String(USDN), toBase58String(EURN)]
91+
92+let stakingUSDNAddress = Address(getBase58FromOracle(kUSDNAddress))
93+
94+let stakingEURNAddress = Address(getBase58FromOracle(kEURNAddress))
95+
96+let basePeriod = valueOrErrorMessage(getInteger(votingAddress, kBasePeriod), "Empty kBasePeriod")
97+
98+let startHeight = valueOrErrorMessage(getInteger(votingAddress, kStartHeight), "Empty kStartHeight")
99+
100+let periodLength = valueOrErrorMessage(getInteger(votingAddress, kPeriodLength), "Empty kPeriodLength")
101+
102+let firstHarvestEndPeriod = ((basePeriod + ((height - startHeight) / periodLength)) + 3)
103+
104+let active = getBooleanValue(this, kActive)
105+
106+let strAssetIdA = getStringValue(this, kAssetIdA)
107+
108+let strAssetIdB = getStringValue(this, kAssetIdB)
109+
110+let assetIdA = if ((strAssetIdA == "WAVES"))
111+    then unit
112+    else fromBase58String(strAssetIdA)
113+
114+let assetIdB = if ((strAssetIdB == "WAVES"))
115+    then unit
116+    else fromBase58String(strAssetIdB)
117+
118+let assetNameA = match assetIdA {
119+    case id: ByteVector => 
120+        value(assetInfo(id)).name
121+    case waves: Unit => 
122+        "WAVES"
123+    case _ => 
124+        throw("Match error")
125+}
126+
127+let assetNameB = match assetIdB {
128+    case id: ByteVector => 
129+        value(assetInfo(id)).name
130+    case waves: Unit => 
131+        "WAVES"
132+    case _ => 
133+        throw("Match error")
134+}
135+
136+let balanceA = getIntegerValue(this, kBalanceA)
137+
138+let balanceB = getIntegerValue(this, kBalanceB)
139+
140+let shareAssetId = fromBase58String(getStringValue(this, kShareAssetId))
141+
142+let shareAssetSupply = getIntegerValue(this, kShareAssetSupply)
143+
144+let fee = getIntegerValue(this, kFee)
145+
146+let feeGovernance = fraction(fee, 40, 100)
147+
148+let feeScale6 = 1000000
149+
150+let scaleValue3 = 1000
151+
152+let scaleValue8 = 100000000
153+
154+let slippageToleranceDelimiter = 1000
155+
156+let scaleValue8Digits = 8
157+
158+func accountBalance (assetId) = match assetId {
159+    case id: ByteVector => 
160+        assetBalance(this, id)
161+    case waves: Unit => 
162+        wavesBalance(this).available
163+    case _ => 
164+        throw("Match error")
165+}
166+
167+
168+func stakedAmount (assetId) = {
169+    let stakedAmountCalculated =     match assetId {
170+        case aId: ByteVector => 
171+            if ((aId == USDN))
172+                then getInteger(stakingUSDNAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(this)))
173+                else if ((aId == EURN))
174+                    then getInteger(stakingEURNAddress, ((("%s%s%s__stakingBalance__" + toBase58String(aId)) + "__") + toString(this)))
175+                    else 0
176+        case _: Unit => 
177+            valueOrElse(getInteger(this, kLeasingAmount), 0)
178+        case _ => 
179+            throw("Match error")
180+    }
181+    match stakedAmountCalculated {
182+        case i: Int => 
183+            i
184+        case _ => 
185+            0
186+    }
187+    }
188+
189+
190+let stakedAmountA = stakedAmount(assetIdA)
191+
192+let stakedAmountB = stakedAmount(assetIdB)
193+
194+let assetInitA = getIntegerValue(this, kBalanceInitA)
195+
196+let assetInitB = getIntegerValue(this, kBalanceInitB)
197+
198+let availableBalanceA = (balanceA - stakedAmountA)
199+
200+let availableBalanceB = (balanceB - stakedAmountB)
201+
202+let accountBalanceWithStakedA = (accountBalance(assetIdA) + stakedAmountA)
203+
204+let accountBalanceWithStakedB = (accountBalance(assetIdB) + stakedAmountB)
205+
206+let hasEnoughBalance = if ((accountBalanceWithStakedA >= balanceA))
207+    then (accountBalanceWithStakedB >= balanceB)
208+    else false
209+
210+func getAssetInfo (assetId) = match assetId {
211+    case id: ByteVector => 
212+        let stringId = toBase58String(id)
213+        let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
214+        $Tuple3(stringId, info.name, info.decimals)
215+    case waves: Unit => 
216+        $Tuple3("WAVES", "WAVES", 8)
217+    case _ => 
218+        throw("Match error")
219+}
220+
221+
222+func getAssetInfoFromString (assetStr) = if ((assetStr == "WAVES"))
223+    then $Tuple3("WAVES", "WAVES", 8)
224+    else {
225+        let stringId = assetStr
226+        let id = fromBase58String(assetStr)
227+        let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
228+        $Tuple3(stringId, info.name, info.decimals)
229+        }
230+
231+
232+func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
233+
234+
235+func calcStakingFuncAndAddres (stake,assetId) = if (stake)
236+    then if ((assetId == USDN))
237+        then $Tuple2("lockNeutrino", stakingUSDNAddress)
238+        else $Tuple2("startStaking", stakingEURNAddress)
239+    else if ((assetId == USDN))
240+        then $Tuple2("unlockNeutrino", stakingUSDNAddress)
241+        else $Tuple2("stopStaking", stakingEURNAddress)
242+
243+
244+func calcStakingParams (stake,amount,assetId) = if (stake)
245+    then {
246+        let $t060896155 = calcStakingFuncAndAddres(stake, assetId)
247+        let call = $t060896155._1
248+        let stakingAddr = $t060896155._2
249+        $Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
250+        }
251+    else {
252+        let $t062416307 = calcStakingFuncAndAddres(stake, assetId)
253+        let call = $t062416307._1
254+        let stakingAddr = $t062416307._2
255+        $Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
256+        }
257+
258+
259+func calculateFees (pmtAmount,minAmountToReceive,tokenFrom,tokenTo) = {
260+    let amountWithoutFee = fraction(tokenTo, pmtAmount, (pmtAmount + tokenFrom))
261+    let amountWithFee = fraction(amountWithoutFee, (feeScale6 - fee), feeScale6)
262+    let governanceReward = fraction(amountWithoutFee, feeGovernance, feeScale6)
263+    if ((minAmountToReceive > amountWithFee))
264+        then throw(((("Calculated amount to receive " + toString(amountWithFee)) + " is less than specified minimum ") + toString(minAmountToReceive)))
265+        else $Tuple3(amountWithoutFee, amountWithFee, governanceReward)
266+    }
267+
268+
269+func suspendSuspicious () = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(accountBalanceWithStakedA)) + " ") + assetNameA) + ", ") + toString(accountBalanceWithStakedB)) + " ") + assetNameB) + ". State: ") + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB))
270+
271+
272+func isActive () = if (active)
273+    then unit
274+    else throw("DApp is inactive at this moment")
275+
276+
277+@Callable(i)
278+func init (firstHarvest) = {
279+    let $t074187495 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
280+    let pmtAmountA = $t074187495._1
281+    let pmtAssetIdA = $t074187495._2
282+    let $t075007577 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
283+    let pmtAmountB = $t075007577._1
284+    let pmtAssetIdB = $t075007577._2
285+    let $t075827659 = getAssetInfo(pmtAssetIdA)
286+    let pmtStrAssetIdA = $t075827659._1
287+    let pmtAssetNameA = $t075827659._2
288+    let pmtDecimalsA = $t075827659._3
289+    let $t076647741 = getAssetInfo(pmtAssetIdB)
290+    let pmtStrAssetIdB = $t076647741._1
291+    let pmtAssetNameB = $t076647741._2
292+    let pmtDecimalsB = $t076647741._3
293+    if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminInvokePubKey], i.callerPublicKey)))
294+        then throw("Only admin can call this function")
295+        else if (isDefined(getBoolean(this, kActive)))
296+            then throw("DApp is already active")
297+            else if ((pmtAssetIdA == pmtAssetIdB))
298+                then throw("Assets must be different")
299+                else {
300+                    let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
301+                    let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
302+                    let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
303+                    let arg1 = pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN)
304+                    let arg2 = pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN)
305+                    let arg3 = pow(10, 0, shareDecimals, 0, 0, DOWN)
306+                    let shareInitialSupply = fraction(arg1, arg2, arg3)
307+                    let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
308+                    let shareIssueId = calculateAssetId(shareIssue)
309+                    let stake1 = if (containsElement(stakingAssets, pmtStrAssetIdA))
310+                        then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
311+                        else 0
312+                    if ((stake1 == stake1))
313+                        then {
314+                            let stake2 = if (containsElement(stakingAssets, pmtStrAssetIdB))
315+                                then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
316+                                else 0
317+                            if ((stake2 == stake2))
318+                                then {
319+                                    let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceA, pmtAmountA), IntegerEntry(kBalanceB, pmtAmountB), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_cpmm")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
320+                                    if (firstHarvest)
321+                                        then (baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))])
322+                                        else baseEntry
323+                                    }
324+                                else throw("Strict value is not equal to itself.")
325+                            }
326+                        else throw("Strict value is not equal to itself.")
327+                    }
328+    }
329+
330+
331+
332+@Callable(i)
333+func initWithInitRatio (amtAssetA,amtAssetB,strAssetIdA,strAssetIdB,firstHarvest) = {
334+    let $t01024610333 = getAssetInfoFromString(strAssetIdA)
335+    let pmtStrAssetIdA = $t01024610333._1
336+    let pmtAssetNameA = $t01024610333._2
337+    let pmtDecimalsA = $t01024610333._3
338+    let $t01033810425 = getAssetInfoFromString(strAssetIdB)
339+    let pmtStrAssetIdB = $t01033810425._1
340+    let pmtAssetNameB = $t01033810425._2
341+    let pmtDecimalsB = $t01033810425._3
342+    if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminInvokePubKey], i.callerPublicKey)))
343+        then throw("Only admin can call this function")
344+        else if (isDefined(getBoolean(this, kActive)))
345+            then throw("DApp is already active")
346+            else if ((strAssetIdA == strAssetIdB))
347+                then throw("Assets must be different")
348+                else {
349+                    let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
350+                    let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
351+                    let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
352+                    let shareInitialSupply = 0
353+                    let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
354+                    let shareIssueId = calculateAssetId(shareIssue)
355+                    let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceInitA, amtAssetA), IntegerEntry(kBalanceInitB, amtAssetB), IntegerEntry(kBalanceA, 0), IntegerEntry(kBalanceB, 0), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_cpmm")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply)]
356+                    if (firstHarvest)
357+                        then (baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))])
358+                        else baseEntry
359+                    }
360+    }
361+
362+
363+
364+@Callable(i)
365+func keepLimitForFirstHarvest (shareLimit) = valueOrElse(isActive(), if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminInvokePubKey], i.callerPublicKey)))
366+    then throw("Only admin can call this function")
367+    else [IntegerEntry(kShareLimit, shareLimit)])
368+
369+
370+
371+@Callable(i)
372+func replenishWithTwoTokens (slippageTolerance) = valueOrElse(isActive(), {
373+    let pmtAssetIdA = i.payments[0].assetId
374+    let pmtAssetIdB = i.payments[1].assetId
375+    let pmtAmountA = i.payments[0].amount
376+    let pmtAmountB = i.payments[1].amount
377+    let $t01280412881 = getAssetInfo(pmtAssetIdA)
378+    let pmtStrAssetIdA = $t01280412881._1
379+    let pmtAssetNameA = $t01280412881._2
380+    let pmtDecimalsA = $t01280412881._3
381+    let $t01288612963 = getAssetInfo(pmtAssetIdB)
382+    let pmtStrAssetIdB = $t01288612963._1
383+    let pmtAssetNameB = $t01288612963._2
384+    let pmtDecimalsB = $t01288612963._3
385+    let inital = if (if ((balanceA == 0))
386+        then (balanceB == 0)
387+        else false)
388+        then true
389+        else false
390+    let tokenRatio = if (inital)
391+        then fraction(fraction(assetInitA, scaleValue8, pmtAmountA), scaleValue3, fraction(assetInitB, scaleValue8, pmtAmountB))
392+        else fraction(fraction(balanceA, scaleValue8, pmtAmountA), scaleValue3, fraction(balanceB, scaleValue8, pmtAmountB))
393+    let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
394+    let shareTokenToPayAmount = if (inital)
395+        then fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN), pow(10, 0, shareDecimals, 0, 0, DOWN))
396+        else fraction(min([fraction(pmtAmountA, scaleValue8, balanceA), fraction(pmtAmountB, scaleValue8, balanceB)]), shareAssetSupply, scaleValue8)
397+    if (if ((0 > slippageTolerance))
398+        then true
399+        else (slippageTolerance > slippageToleranceDelimiter))
400+        then throw(((("Slippage tolerance must be between 0 and " + toString(slippageToleranceDelimiter)) + " inclusively. Actual: ") + toString(slippageTolerance)))
401+        else if ((size(i.payments) != 2))
402+            then throw("Two attached assets expected")
403+            else if (if ((pmtAssetIdA != assetIdA))
404+                then true
405+                else (pmtAssetIdB != assetIdB))
406+                then throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
407+                else if (if ((((scaleValue3 * (slippageToleranceDelimiter - slippageTolerance)) / slippageToleranceDelimiter) > tokenRatio))
408+                    then true
409+                    else (tokenRatio > ((scaleValue3 * (slippageToleranceDelimiter + slippageTolerance)) / slippageToleranceDelimiter)))
410+                    then throw("Incorrect assets amount: amounts must have the contract ratio")
411+                    else if ((shareTokenToPayAmount == 0))
412+                        then throw("Too small amount to replenish")
413+                        else if (!(hasEnoughBalance))
414+                            then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
415+                            else {
416+                                let stake1 = if (containsElement(stakingAssets, pmtStrAssetIdA))
417+                                    then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
418+                                    else 0
419+                                if ((stake1 == stake1))
420+                                    then {
421+                                        let stake2 = if (containsElement(stakingAssets, pmtStrAssetIdB))
422+                                            then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
423+                                            else 0
424+                                        if ((stake2 == stake2))
425+                                            then [Reissue(shareAssetId, shareTokenToPayAmount, true), IntegerEntry(kBalanceA, (balanceA + pmtAmountA)), IntegerEntry(kBalanceB, (balanceB + pmtAmountB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId)]
426+                                            else throw("Strict value is not equal to itself.")
427+                                        }
428+                                    else throw("Strict value is not equal to itself.")
429+                                }
430+    })
431+
432+
433+
434+@Callable(i)
435+func withdraw () = valueOrElse(isActive(), {
436+    let $t01576315838 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
437+    let pmtAmount = $t01576315838._1
438+    let pmtAssetId = $t01576315838._2
439+    let amountToPayA = fraction(pmtAmount, balanceA, shareAssetSupply)
440+    let amountToPayB = fraction(pmtAmount, balanceB, shareAssetSupply)
441+    if ((size(i.payments) != 1))
442+        then throw("One attached payment expected")
443+        else if ((pmtAssetId != shareAssetId))
444+            then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
445+            else if (!(hasEnoughBalance))
446+                then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
447+                else {
448+                    let stake1 = if (containsElement(stakingAssets, strAssetIdA))
449+                        then invoke(this, "stakeUnstake", [false, amountToPayA, strAssetIdA], nil)
450+                        else 0
451+                    if ((stake1 == stake1))
452+                        then {
453+                            let stake2 = if (containsElement(stakingAssets, strAssetIdB))
454+                                then invoke(this, "stakeUnstake", [false, amountToPayB, strAssetIdB], nil)
455+                                else 0
456+                            if ((stake2 == stake2))
457+                                then [IntegerEntry(kBalanceA, (balanceA - amountToPayA)), IntegerEntry(kBalanceB, (balanceB - amountToPayB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply - pmtAmount)), Burn(shareAssetId, pmtAmount), ScriptTransfer(i.caller, amountToPayA, assetIdA), ScriptTransfer(i.caller, amountToPayB, assetIdB)]
458+                                else throw("Strict value is not equal to itself.")
459+                            }
460+                        else throw("Strict value is not equal to itself.")
461+                    }
462+    })
463+
464+
465+
466+@Callable(i)
467+func exchange (minAmountToReceive) = valueOrElse(isActive(), {
468+    let $t01713717212 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
469+    let pmtAmount = $t01713717212._1
470+    let pmtAssetId = $t01713717212._2
471+    if (if ((balanceA == 0))
472+        then true
473+        else (balanceB == 0))
474+        then throw("Can't exchange with zero balance")
475+        else if ((0 >= minAmountToReceive))
476+            then throw(("Minimal amount to receive must be positive. Actual: " + toString(minAmountToReceive)))
477+            else if ((size(i.payments) != 1))
478+                then throw("One attached payment expected")
479+                else if (!(hasEnoughBalance))
480+                    then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
481+                    else if ((pmtAssetId == assetIdA))
482+                        then {
483+                            let assetIdSend = assetIdB
484+                            let $t01776317885 = calculateFees(pmtAmount, minAmountToReceive, balanceA, balanceB)
485+                            let amountWithoutFee = $t01776317885._1
486+                            let amountWithFee = $t01776317885._2
487+                            let governanceReward = $t01776317885._3
488+                            let newBalanceA = (balanceA + pmtAmount)
489+                            let newBalanceB = ((balanceB - amountWithFee) - governanceReward)
490+                            let stake1 = if (containsElement(stakingAssets, strAssetIdA))
491+                                then invoke(this, "stakeUnstake", [true, pmtAmount, strAssetIdA], nil)
492+                                else 0
493+                            if ((stake1 == stake1))
494+                                then {
495+                                    let stake2 = if (containsElement(stakingAssets, strAssetIdB))
496+                                        then invoke(this, "stakeUnstake", [false, (amountWithFee + governanceReward), strAssetIdB], nil)
497+                                        else 0
498+                                    if ((stake2 == stake2))
499+                                        then $Tuple2([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(moneyBoxAddress, governanceReward, assetIdSend)], $Tuple2(amountWithFee, assetIdSend))
500+                                        else throw("Strict value is not equal to itself.")
501+                                    }
502+                                else throw("Strict value is not equal to itself.")
503+                            }
504+                        else if ((pmtAssetId == assetIdB))
505+                            then {
506+                                let assetIdSend = assetIdA
507+                                let $t01887718999 = calculateFees(pmtAmount, minAmountToReceive, balanceB, balanceA)
508+                                let amountWithoutFee = $t01887718999._1
509+                                let amountWithFee = $t01887718999._2
510+                                let governanceReward = $t01887718999._3
511+                                let newBalanceA = ((balanceA - amountWithFee) - governanceReward)
512+                                let newBalanceB = (balanceB + pmtAmount)
513+                                let stake1 = if (containsElement(stakingAssets, strAssetIdA))
514+                                    then invoke(this, "stakeUnstake", [false, (amountWithFee + governanceReward), strAssetIdA], nil)
515+                                    else 0
516+                                if ((stake1 == stake1))
517+                                    then {
518+                                        let stake2 = if (containsElement(stakingAssets, strAssetIdB))
519+                                            then invoke(this, "stakeUnstake", [true, pmtAmount, strAssetIdB], nil)
520+                                            else 0
521+                                        if ((stake2 == stake2))
522+                                            then $Tuple2([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(moneyBoxAddress, governanceReward, assetIdSend)], $Tuple2(amountWithFee, assetIdSend))
523+                                            else throw("Strict value is not equal to itself.")
524+                                        }
525+                                    else throw("Strict value is not equal to itself.")
526+                                }
527+                            else throw(((("Incorrect asset attached. Expected: " + strAssetIdA) + " or ") + strAssetIdB))
528+    })
529+
530+
531+
532+@Callable(i)
533+func shutdown () = if (!(active))
534+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, kCause), "the cause wasn't specified")))
535+    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey)))
536+        then throw("Only admin can call this function")
537+        else suspend("Paused by admin")
538+
539+
540+
541+@Callable(i)
542+func activate () = if (active)
543+    then throw("DApp is already active")
544+    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey)))
545+        then throw("Only admin can call this function")
546+        else [BooleanEntry(kActive, true), DeleteEntry(kCause)]
547+
548+
549+
550+@Callable(i)
551+func takeIntoAccountExtraFunds () = valueOrElse(isActive(), {
552+    let amountEnrollA = (accountBalanceWithStakedA - balanceA)
553+    let amountEnrollB = (accountBalanceWithStakedB - balanceB)
554+    if ((i.caller != moneyBoxAddress))
555+        then throw("Only the wallet can call this function")
556+        else if (if ((0 > amountEnrollA))
557+            then true
558+            else (0 > amountEnrollB))
559+            then suspend("Enroll amount negative")
560+            else if (if ((amountEnrollA == 0))
561+                then (amountEnrollB == 0)
562+                else false)
563+                then throw("No money to take")
564+                else {
565+                    let stake1 = if (containsElement(stakingAssets, strAssetIdA))
566+                        then invoke(this, "stakeUnstake", [true, amountEnrollA, strAssetIdA], nil)
567+                        else 0
568+                    if ((stake1 == stake1))
569+                        then {
570+                            let stake2 = if (containsElement(stakingAssets, strAssetIdB))
571+                                then invoke(this, "stakeUnstake", [true, amountEnrollB, strAssetIdB], nil)
572+                                else 0
573+                            if ((stake2 == stake2))
574+                                then [IntegerEntry(kBalanceA, (balanceA + amountEnrollA)), IntegerEntry(kBalanceB, (balanceB + amountEnrollB)), IntegerEntry(("last_income_" + strAssetIdA), amountEnrollA), IntegerEntry(("last_income_" + strAssetIdB), amountEnrollB)]
575+                                else throw("Strict value is not equal to itself.")
576+                            }
577+                        else throw("Strict value is not equal to itself.")
578+                    }
579+    })
580+
581+
582+
583+@Callable(i)
584+func stakeUnstake (stake,amount,assetIdString) = if ((i.caller != this))
585+    then throw("Only contract itself can invoke this function")
586+    else if ((assetIdString == "WAVES"))
587+        then {
588+            let pool = addressFromStringValue(valueOrErrorMessage(getString(oracle, kLeasingPool), "No leasing pool in oracle"))
589+            let leasingId = getBinary(this, kLeasingId)
590+            let leasingAmount = valueOrElse(getInteger(this, kLeasingAmount), 0)
591+            let newLeaseAmount = if (stake)
592+                then (leasingAmount + amount)
593+                else (leasingAmount - amount)
594+            let newLease = Lease(pool, newLeaseAmount)
595+            let newLeaseId = calculateLeaseId(newLease)
596+            let baseEtry = [newLease, BinaryEntry(kLeasingId, newLeaseId), IntegerEntry(kLeasingAmount, newLeaseAmount)]
597+            match leasingId {
598+                case lId: ByteVector => 
599+                    ([LeaseCancel(lId)] ++ baseEtry)
600+                case _ => 
601+                    baseEtry
602+            }
603+            }
604+        else {
605+            let $t02275322856 = calcStakingParams(stake, amount, fromBase58String(assetIdString))
606+            let call = $t02275322856._1
607+            let addr = $t02275322856._2
608+            let params = $t02275322856._3
609+            let payments = $t02275322856._4
610+            let inv = invoke(addr, call, params, payments)
611+            if ((inv == inv))
612+                then nil
613+                else throw("Strict value is not equal to itself.")
614+            }
615+
616+
617+
618+@Callable(i)
619+func stakeAll () = valueOrElse(isActive(), if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey)))
620+    then throw("Only admin can call this function")
621+    else {
622+        let stake1 = if (containsElement(stakingAssets, strAssetIdA))
623+            then {
624+                let amountA = (balanceA - stakedAmountA)
625+                if ((amountA > 0))
626+                    then invoke(this, "stakeUnstake", [true, amountA, strAssetIdA], nil)
627+                    else 0
628+                }
629+            else 0
630+        if ((stake1 == stake1))
631+            then {
632+                let stake2 = if (containsElement(stakingAssets, strAssetIdB))
633+                    then {
634+                        let amountB = (balanceB - stakedAmountB)
635+                        if ((amountB > 0))
636+                            then invoke(this, "stakeUnstake", [true, amountB, strAssetIdB], nil)
637+                            else 0
638+                        }
639+                    else 0
640+                if ((stake2 == stake2))
641+                    then nil
642+                    else throw("Strict value is not equal to itself.")
643+                }
644+            else throw("Strict value is not equal to itself.")
645+        })
646+
647+
648+@Verifier(tx)
649+func verify () = {
650+    let multiSignedByAdmins = {
651+        let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
652+            then 1
653+            else 0
654+        let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
655+            then 1
656+            else 0
657+        let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
658+            then 1
659+            else 0
660+        (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
661+        }
662+    match tx {
663+        case inv: InvokeScriptTransaction => 
664+            let callTakeIntoAccount = if ((inv.dApp == this))
665+                then (inv.function == "takeIntoAccountExtraFunds")
666+                else false
667+            let signedByAdmin = if (if (if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
668+                then true
669+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey2))
670+                then true
671+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey3))
672+                then true
673+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminInvokePubKey)
674+            if (if (callTakeIntoAccount)
675+                then signedByAdmin
676+                else false)
677+                then true
678+                else multiSignedByAdmins
679+        case _ => 
680+            multiSignedByAdmins
681+    }
682+    }
683+
github/deemru/w8io/026f985 
39.70 ms ◑