tx · HsGYFM1CyA3aDVBLqNPhNkLXKBjKgoj6tp28BmyUXxtb

3Mxseaa812ieNsKvCioJn9Zukgva3V7vToP:  -0.01000000 Waves

2021.09.07 15:30 [1692627] smart account 3Mxseaa812ieNsKvCioJn9Zukgva3V7vToP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HsGYFM1CyA3aDVBLqNPhNkLXKBjKgoj6tp28BmyUXxtb",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1631017803096,
    "version": 2,
    "chainId": 84,
    "sender": "3Mxseaa812ieNsKvCioJn9Zukgva3V7vToP",
    "senderPublicKey": "A3H5B1B2Bvo8tWFrEnfWTJRZn4EcnhM1WtEnaAAw354G",
    "proofs": [
        "4gKKHJ62i3a8rWcigsSBijkB6imVe5yAdDKRcfM5mTiEbyUdid22eqCrFiS2oprkQ1W2BAhtT1iQWTWRLxoU33QB"
    ],
    "script": "base64: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",
    "height": 1692627,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

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 keyVersion = "version"
7+
8+let keyActive = "active"
9+
10+let keyAssetIdA = "A_asset_id"
11+
12+let keyAssetIdB = "B_asset_id"
13+
14+let keyBalanceA = "A_asset_balance"
15+
16+let keyBalanceB = "B_asset_balance"
17+
18+let keyBalanceInitA = "A_asset_init"
19+
20+let keyBalanceInitB = "B_asset_init"
21+
22+let keyShareAssetId = "share_asset_id"
23+
24+let keyShareAssetSupply = "share_asset_supply"
25+
26+let keyCommission = "commission"
27+
28+let keyCommissionScaleDelimiter = "commission_scale_delimiter"
29+
30+let keyCause = "shutdown_cause"
31+
32+let keyFirstHarvest = "first_harvest"
33+
34+let keyFirstHarvestHeight = "first_harvest_height"
35+
36+let kShareLimit = "share_limit_on_first_harvest"
37+
38+let kBasePeriod = "base_period"
39+
40+let kPeriodLength = "period_length"
41+
42+let kStartHeight = "start_height"
43+
44+let kFirstHarvestHeight = "first_harvest_height"
45+
46+let keyAdminPubKey1 = "admin_pub_1"
47+
48+let keyAdminPubKey2 = "admin_pub_2"
49+
50+let keyAdminPubKey3 = "admin_pub_3"
51+
52+let oracle = Address(base58'3NBBWfzZtZtszaXbitTKnrB2xXwv26Bn7H9')
53+
54+func getAdminPub (keyAdminPub) = match getString(oracle, keyAdminPub) {
55+    case string: String => 
56+        fromBase58String(string)
57+    case nothing => 
58+        throw("Admin public key is empty")
59+}
60+
61+
62+let adminPubKey1 = getAdminPub(keyAdminPubKey1)
63+
64+let adminPubKey2 = getAdminPub(keyAdminPubKey2)
65+
66+let adminPubKey3 = getAdminPub(keyAdminPubKey3)
67+
68+let adminPubKeyStartStop = base58'Kn7NpzaG12dLZgcHf2ipUftU6hbJygmrhFqQYE4B7ZK'
69+
70+let adminPubKeyStaking = base58'Kn7NpzaG12dLZgcHf2ipUftU6hbJygmrhFqQYE4B7ZK'
71+
72+let walletAddress = Address(base58'3NAGTtZz6WpupSN89NZD5rMZwwziZEg4Kx4')
73+
74+let votingAddress = Address(base58'3MrJgdL1GniipErHy44YF9idzLaUL2iX5DQ')
75+
76+let USDN = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
77+
78+let NSBT = base58'36mg8NZTaFRDygiVwb8uBnLR51hetJruUCZcxhaVcHj9'
79+
80+let SWOP = base58'2HAJrwa8q4SxBx9cHYaBTQdBjdk5wwqdof7ccpAx2uhZ'
81+
82+let EURN = base58'ECBCkHS68DckpBrzLeoRgYbFg7sCVqR176mPqbXsj9pA'
83+
84+let stakingUSDNNSBTAddress = Address(base58'3N6q7sCGSSLBUXDdjBdYGTJbZGZfhhh8cNg')
85+
86+let stakingEURNAddress = Address(base58'3MyVqAbmKWh339gF6hy8faWw1jGeTV2wnGE')
87+
88+let USDNToWavesExchanger = Address(base58'3N77kfPbQyjXWpDALX3xjKw3iEGMWEctV37')
89+
90+let USDNToNSBTExchanger = Address(base58'3Mye9wVR7d2mc6Y5ZJTu11svzgUQ7o8H9dA')
91+
92+let stakingFeeInUSDN = 270000
93+
94+let stakingFeeInEURN = 234000
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 isActive = getBooleanValue(this, keyActive)
105+
106+let strAssetIdA = getStringValue(this, keyAssetIdA)
107+
108+let strAssetIdB = getStringValue(this, keyAssetIdB)
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, keyBalanceA)
137+
138+let balanceB = getIntegerValue(this, keyBalanceB)
139+
140+let shareAssetId = fromBase58String(getStringValue(this, keyShareAssetId))
141+
142+let shareAssetSupply = getIntegerValue(this, keyShareAssetSupply)
143+
144+let commission = 3000
145+
146+let commissionGovernance = 1200
147+
148+let commissionScaleDelimiter = 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 (if ((aId == USDN))
172+                then true
173+                else (aId == NSBT))
174+                then getInteger(stakingUSDNNSBTAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(this)))
175+                else if ((aId == EURN))
176+                    then getInteger(stakingEURNAddress, ((("%s%s%s__stakingBalance__" + toBase58String(aId)) + "__") + toString(this)))
177+                    else 0
178+        case _: Unit => 
179+            0
180+        case _ => 
181+            throw("Match error")
182+    }
183+    match stakedAmountCalculated {
184+        case i: Int => 
185+            i
186+        case _ => 
187+            0
188+    }
189+    }
190+
191+
192+let stakedAmountA = stakedAmount(assetIdA)
193+
194+let stakedAmountB = stakedAmount(assetIdB)
195+
196+let assetInitA = getIntegerValue(this, keyBalanceInitA)
197+
198+let assetInitB = getIntegerValue(this, keyBalanceInitB)
199+
200+let availableBalanceA = (balanceA - stakedAmountA)
201+
202+let availableBalanceB = (balanceB - stakedAmountB)
203+
204+let accountBalanceWithStakedA = (accountBalance(assetIdA) + stakedAmountA)
205+
206+let accountBalanceWithStakedB = (accountBalance(assetIdB) + stakedAmountB)
207+
208+let hasEnoughBalance = if ((accountBalanceWithStakedA >= balanceA))
209+    then (accountBalanceWithStakedB >= balanceB)
210+    else false
211+
212+func getAssetInfo (assetId) = match assetId {
213+    case id: ByteVector => 
214+        let stringId = toBase58String(id)
215+        let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
216+        $Tuple3(stringId, info.name, info.decimals)
217+    case waves: Unit => 
218+        $Tuple3("WAVES", "WAVES", 8)
219+    case _ => 
220+        throw("Match error")
221+}
222+
223+
224+func getAssetInfoFromString (assetStr) = if ((assetStr == "WAVES"))
225+    then $Tuple3("WAVES", "WAVES", 8)
226+    else {
227+        let stringId = assetStr
228+        let id = fromBase58String(assetStr)
229+        let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
230+        $Tuple3(stringId, info.name, info.decimals)
231+        }
232+
233+
234+func suspend (cause) = [BooleanEntry(keyActive, false), StringEntry(keyCause, cause)]
235+
236+
237+func deductStakingFee (amount,assetId,secondAssetId) = if (if ((assetId == USDN))
238+    then true
239+    else (assetId == EURN))
240+    then {
241+        let stakinFee = if ((assetId == USDN))
242+            then (stakingFeeInUSDN * (if ((secondAssetId == NSBT))
243+                then 2
244+                else 1))
245+            else if ((assetId == EURN))
246+                then stakingFeeInEURN
247+                else 0
248+        let result = (amount - stakinFee)
249+        if ((0 >= result))
250+            then throw((((("Insufficient amount " + toString(amount)) + " to deduct staking fee ") + toString(stakinFee)) + "USDN/EURN"))
251+            else result
252+        }
253+    else amount
254+
255+
256+func getStakingFee (assetId,secondAssetId) = if ((assetId == USDN))
257+    then (stakingFeeInUSDN * (if ((secondAssetId == NSBT))
258+        then 2
259+        else 1))
260+    else if ((assetId == EURN))
261+        then stakingFeeInEURN
262+        else 0
263+
264+
265+func throwInsufficientAvailableBalance (amount,available,assetName) = throw((((((((("Insufficient DApp balance to pay " + toString(amount)) + " ") + assetName) + " due to staking. Available: ") + toString(available)) + " ") + assetName) + ". Please contact support in Telegram: https://t.me/swopfisupport"))
266+
267+
268+func throwInsufficientAvailableBalances (amountA,amountB) = throw((((((((((((((((("Insufficient DApp balance to pay " + toString(amountA)) + " ") + assetNameA) + " and ") + toString(amountB)) + " ") + assetNameB) + " due to staking. Available: ") + toString(availableBalanceA)) + " ") + assetNameA) + " and ") + toString(availableBalanceB)) + " ") + assetNameB) + ". Please contact support in Telegram: https://t.me/swopfisupport"))
269+
270+
271+func suspendSuspicious () = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(accountBalanceWithStakedA)) + " ") + assetNameA) + ", ") + toString(accountBalanceWithStakedB)) + " ") + assetNameB) + ". State: ") + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB))
272+
273+
274+@Callable(i)
275+func init (firstHarvest) = {
276+    let $t080018078 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
277+    let pmtAmountA = $t080018078._1
278+    let pmtAssetIdA = $t080018078._2
279+    let $t080838160 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
280+    let pmtAmountB = $t080838160._1
281+    let pmtAssetIdB = $t080838160._2
282+    let $t081658242 = getAssetInfo(pmtAssetIdA)
283+    let pmtStrAssetIdA = $t081658242._1
284+    let pmtAssetNameA = $t081658242._2
285+    let pmtDecimalsA = $t081658242._3
286+    let $t082478324 = getAssetInfo(pmtAssetIdB)
287+    let pmtStrAssetIdB = $t082478324._1
288+    let pmtAssetNameB = $t082478324._2
289+    let pmtDecimalsB = $t082478324._3
290+    if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStaking], i.callerPublicKey)))
291+        then throw("Only admin can call this function")
292+        else if (isDefined(getBoolean(this, keyActive)))
293+            then throw("DApp is already active")
294+            else if ((pmtAssetIdA == pmtAssetIdB))
295+                then throw("Assets must be different")
296+                else {
297+                    let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
298+                    let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
299+                    let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
300+                    let arg1 = pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN)
301+                    let arg2 = pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN)
302+                    let arg3 = pow(10, 0, shareDecimals, 0, 0, DOWN)
303+                    let shareInitialSupply = fraction(arg1, arg2, arg3)
304+                    let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
305+                    let shareIssueId = calculateAssetId(shareIssue)
306+                    let baseEntry = [StringEntry(keyVersion, version), BooleanEntry(keyActive, true), StringEntry(keyAssetIdA, pmtStrAssetIdA), StringEntry(keyAssetIdB, pmtStrAssetIdB), IntegerEntry(keyBalanceA, pmtAmountA), IntegerEntry(keyBalanceB, pmtAmountB), IntegerEntry(keyCommission, commission), IntegerEntry(keyCommissionScaleDelimiter, commissionScaleDelimiter), shareIssue, StringEntry(keyShareAssetId, toBase58String(shareIssueId)), IntegerEntry(keyShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
307+                    if (firstHarvest)
308+                        then (baseEntry ++ [BooleanEntry(keyFirstHarvest, firstHarvest), IntegerEntry(keyFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))])
309+                        else baseEntry
310+                    }
311+    }
312+
313+
314+
315+@Callable(i)
316+func initWithInitRatio (amtAssetA,amtAssetB,strAssetIdA,strAssetIdB,firstHarvest) = {
317+    let $t01056910656 = getAssetInfoFromString(strAssetIdA)
318+    let pmtStrAssetIdA = $t01056910656._1
319+    let pmtAssetNameA = $t01056910656._2
320+    let pmtDecimalsA = $t01056910656._3
321+    let $t01066110748 = getAssetInfoFromString(strAssetIdB)
322+    let pmtStrAssetIdB = $t01066110748._1
323+    let pmtAssetNameB = $t01066110748._2
324+    let pmtDecimalsB = $t01066110748._3
325+    if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStaking], i.callerPublicKey)))
326+        then throw("Only admin can call this function")
327+        else if (isDefined(getBoolean(this, keyActive)))
328+            then throw("DApp is already active")
329+            else if ((strAssetIdA == strAssetIdB))
330+                then throw("Assets must be different")
331+                else {
332+                    let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
333+                    let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
334+                    let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
335+                    let shareInitialSupply = 0
336+                    let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
337+                    let shareIssueId = calculateAssetId(shareIssue)
338+                    let baseEntry = [StringEntry(keyVersion, version), BooleanEntry(keyActive, true), StringEntry(keyAssetIdA, pmtStrAssetIdA), StringEntry(keyAssetIdB, pmtStrAssetIdB), IntegerEntry(keyBalanceInitA, amtAssetA), IntegerEntry(keyBalanceInitB, amtAssetB), IntegerEntry(keyBalanceA, 0), IntegerEntry(keyBalanceB, 0), IntegerEntry(keyCommission, commission), IntegerEntry(keyCommissionScaleDelimiter, commissionScaleDelimiter), shareIssue, StringEntry(keyShareAssetId, toBase58String(shareIssueId)), IntegerEntry(keyShareAssetSupply, shareInitialSupply)]
339+                    if (firstHarvest)
340+                        then (baseEntry ++ [BooleanEntry(keyFirstHarvest, firstHarvest), IntegerEntry(keyFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))])
341+                        else baseEntry
342+                    }
343+    }
344+
345+
346+
347+@Callable(i)
348+func keepLimitForFirstHarvest (shareLimit) = if (!(isActive))
349+    then throw("DApp is inactive at this moment")
350+    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStaking], i.callerPublicKey)))
351+        then throw("Only admin can call this function")
352+        else [IntegerEntry(kShareLimit, shareLimit)]
353+
354+
355+
356+@Callable(i)
357+func replenishWithTwoTokens (slippageTolerance) = {
358+    let pmtAssetIdA = i.payments[0].assetId
359+    let pmtAssetIdB = i.payments[1].assetId
360+    let pmtAmountA = deductStakingFee(i.payments[0].amount, pmtAssetIdA, pmtAssetIdB)
361+    let pmtAmountB = deductStakingFee(i.payments[1].amount, pmtAssetIdB, pmtAssetIdA)
362+    if (if ((balanceA == 0))
363+        then (balanceB == 0)
364+        else false)
365+        then {
366+            let $t01345913536 = getAssetInfo(pmtAssetIdA)
367+            let pmtStrAssetIdA = $t01345913536._1
368+            let pmtAssetNameA = $t01345913536._2
369+            let pmtDecimalsA = $t01345913536._3
370+            let $t01354513622 = getAssetInfo(pmtAssetIdB)
371+            let pmtStrAssetIdB = $t01354513622._1
372+            let pmtAssetNameB = $t01354513622._2
373+            let pmtDecimalsB = $t01354513622._3
374+            let tokenRatio = fraction(fraction(assetInitA, scaleValue8, pmtAmountA), scaleValue3, fraction(assetInitB, scaleValue8, pmtAmountB))
375+            if ((pmtAssetIdA == pmtAssetIdB))
376+                then throw("Assets must be different")
377+                else {
378+                    let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
379+                    let shareInitialSupply = fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN), pow(10, 0, shareDecimals, 0, 0, DOWN))
380+                    if (!(isActive))
381+                        then throw("DApp is inactive at this moment")
382+                        else if (if ((0 > slippageTolerance))
383+                            then true
384+                            else (slippageTolerance > slippageToleranceDelimiter))
385+                            then throw(((("Slippage tolerance must be between 0 and " + toString(slippageToleranceDelimiter)) + " inclusively. Actual: ") + toString(slippageTolerance)))
386+                            else if ((size(i.payments) != 2))
387+                                then throw("Two attached assets expected")
388+                                else if (if ((((scaleValue3 * (slippageToleranceDelimiter - slippageTolerance)) / slippageToleranceDelimiter) > tokenRatio))
389+                                    then true
390+                                    else (tokenRatio > ((scaleValue3 * (slippageToleranceDelimiter + slippageTolerance)) / slippageToleranceDelimiter)))
391+                                    then throw("Incorrect assets amount: amounts must have the contract ratio")
392+                                    else if (if ((pmtAssetIdA != assetIdA))
393+                                        then true
394+                                        else (pmtAssetIdB != assetIdB))
395+                                        then throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
396+                                        else if ((shareInitialSupply == 0))
397+                                            then throw("Too small amount to replenish")
398+                                            else if (!(hasEnoughBalance))
399+                                                then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
400+                                                else [Reissue(shareAssetId, shareInitialSupply, true), IntegerEntry(keyBalanceA, pmtAmountA), IntegerEntry(keyBalanceB, pmtAmountB), IntegerEntry(keyShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareAssetId)]
401+                    }
402+            }
403+        else {
404+            let tokenRatio = fraction(fraction(balanceA, scaleValue8, pmtAmountA), scaleValue3, fraction(balanceB, scaleValue8, pmtAmountB))
405+            let ratioShareTokensInA = fraction(pmtAmountA, scaleValue8, balanceA)
406+            let ratioShareTokensInB = fraction(pmtAmountB, scaleValue8, balanceB)
407+            let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scaleValue8)
408+            if (!(isActive))
409+                then throw("DApp is inactive at this moment")
410+                else if (if ((0 > slippageTolerance))
411+                    then true
412+                    else (slippageTolerance > slippageToleranceDelimiter))
413+                    then throw(((("Slippage tolerance must be between 0 and " + toString(slippageToleranceDelimiter)) + " inclusively. Actual: ") + toString(slippageTolerance)))
414+                    else if ((size(i.payments) != 2))
415+                        then throw("Two attached assets expected")
416+                        else if (if ((pmtAssetIdA != assetIdA))
417+                            then true
418+                            else (pmtAssetIdB != assetIdB))
419+                            then throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
420+                            else if (if ((((scaleValue3 * (slippageToleranceDelimiter - slippageTolerance)) / slippageToleranceDelimiter) > tokenRatio))
421+                                then true
422+                                else (tokenRatio > ((scaleValue3 * (slippageToleranceDelimiter + slippageTolerance)) / slippageToleranceDelimiter)))
423+                                then throw("Incorrect assets amount: amounts must have the contract ratio")
424+                                else if ((shareTokenToPayAmount == 0))
425+                                    then throw("Too small amount to replenish")
426+                                    else if (!(hasEnoughBalance))
427+                                        then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
428+                                        else [IntegerEntry(keyBalanceA, (balanceA + pmtAmountA)), IntegerEntry(keyBalanceB, (balanceB + pmtAmountB)), IntegerEntry(keyShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId)]
429+            }
430+    }
431+
432+
433+
434+@Callable(i)
435+func withdraw () = {
436+    let $t01802118171 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
437+    let pmtAmount = $t01802118171._1
438+    let pmtAssetId = $t01802118171._2
439+    let amountToPayA = deductStakingFee(fraction(pmtAmount, balanceA, shareAssetSupply), assetIdA, assetIdB)
440+    let amountToPayB = deductStakingFee(fraction(pmtAmount, balanceB, shareAssetSupply), assetIdB, assetIdA)
441+    if (!(isActive))
442+        then throw("DApp is inactive at this moment")
443+        else if ((size(i.payments) != 1))
444+            then throw("One attached payment expected")
445+            else if ((pmtAssetId != shareAssetId))
446+                then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
447+                else if (!(hasEnoughBalance))
448+                    then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
449+                    else if (if ((amountToPayA > availableBalanceA))
450+                        then true
451+                        else (amountToPayB > availableBalanceB))
452+                        then throwInsufficientAvailableBalances(amountToPayA, amountToPayB)
453+                        else [IntegerEntry(keyBalanceA, (balanceA - amountToPayA)), IntegerEntry(keyBalanceB, (balanceB - amountToPayB)), IntegerEntry(keyShareAssetSupply, (shareAssetSupply - pmtAmount)), Burn(shareAssetId, pmtAmount), ScriptTransfer(i.caller, amountToPayA, assetIdA), ScriptTransfer(i.caller, amountToPayB, assetIdB)]
454+    }
455+
456+
457+
458+@Callable(i)
459+func exchange (minAmountToReceive) = {
460+    let $t01939719472 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
461+    let pmtAmount = $t01939719472._1
462+    let pmtAssetId = $t01939719472._2
463+    func calculateFees (tokenFrom,tokenTo) =     {
464+        let amountWithoutFee = fraction(tokenTo, pmtAmount, (pmtAmount + tokenFrom))
465+        let amountWithFee = fraction(amountWithoutFee, (commissionScaleDelimiter - commission), commissionScaleDelimiter)
466+        let governanceReward = fraction(amountWithoutFee, commissionGovernance, commissionScaleDelimiter)
467+        if ((minAmountToReceive > amountWithFee))
468+            then throw(((("Calculated amount to receive " + toString(amountWithFee)) + " is less than specified minimum ") + toString(minAmountToReceive)))
469+            else $Tuple3(amountWithoutFee, amountWithFee, governanceReward)
470+        }
471+
472+    if (!(isActive))
473+        then throw("DApp is inactive at this moment")
474+        else if (if ((balanceA == 0))
475+            then true
476+            else (balanceB == 0))
477+            then throw("Can't exchange with zero balance")
478+            else if ((0 >= minAmountToReceive))
479+                then throw(("Minimal amount to receive must be positive. Actual: " + toString(minAmountToReceive)))
480+                else if ((size(i.payments) != 1))
481+                    then throw("One attached payment expected")
482+                    else if (!(hasEnoughBalance))
483+                        then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
484+                        else if ((pmtAssetId == assetIdA))
485+                            then {
486+                                let assetIdSend = assetIdB
487+                                let $t02074620837 = calculateFees(balanceA, balanceB)
488+                                let amountWithoutFee = $t02074620837._1
489+                                let amountWithFee = $t02074620837._2
490+                                let governanceReward = $t02074620837._3
491+                                let newBalanceA = (balanceA + pmtAmount)
492+                                let newBalanceB = ((balanceB - amountWithFee) - governanceReward)
493+                                if (if ((stakedAmountA >= newBalanceA))
494+                                    then true
495+                                    else (stakedAmountB >= newBalanceB))
496+                                    then throwInsufficientAvailableBalance(amountWithFee, availableBalanceB, assetNameB)
497+                                    else [IntegerEntry(keyBalanceA, newBalanceA), IntegerEntry(keyBalanceB, newBalanceB), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(walletAddress, governanceReward, assetIdSend)]
498+                                }
499+                            else if ((pmtAssetId == assetIdB))
500+                                then {
501+                                    let assetIdSend = assetIdA
502+                                    let $t02165621747 = calculateFees(balanceB, balanceA)
503+                                    let amountWithoutFee = $t02165621747._1
504+                                    let amountWithFee = $t02165621747._2
505+                                    let governanceReward = $t02165621747._3
506+                                    let newBalanceA = ((balanceA - amountWithFee) - governanceReward)
507+                                    let newBalanceB = (balanceB + pmtAmount)
508+                                    if (if ((stakedAmountA >= newBalanceA))
509+                                        then true
510+                                        else (stakedAmountB >= newBalanceB))
511+                                        then throwInsufficientAvailableBalance(amountWithFee, availableBalanceA, assetNameA)
512+                                        else [IntegerEntry(keyBalanceA, newBalanceA), IntegerEntry(keyBalanceB, newBalanceB), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(walletAddress, governanceReward, assetIdSend)]
513+                                    }
514+                                else throw(((("Incorrect asset attached. Expected: " + strAssetIdA) + " or ") + strAssetIdB))
515+    }
516+
517+
518+
519+@Callable(i)
520+func shutdown () = if (!(isActive))
521+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, keyCause), "the cause wasn't specified")))
522+    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop], i.callerPublicKey)))
523+        then throw("Only admin can call this function")
524+        else suspend("Paused by admin")
525+
526+
527+
528+@Callable(i)
529+func activate () = if (isActive)
530+    then throw("DApp is already active")
531+    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop], i.callerPublicKey)))
532+        then throw("Only admin can call this function")
533+        else [BooleanEntry(keyActive, true), DeleteEntry(keyCause)]
534+
535+
536+
537+@Callable(i)
538+func takeIntoAccountExtraFunds (amountLeave) = {
539+    let uncountableAmountEnrollAssetA = (accountBalanceWithStakedA - balanceA)
540+    let uncountableAmountEnrollAssetB = (accountBalanceWithStakedB - balanceB)
541+    let amountEnrollA = (uncountableAmountEnrollAssetA - (if ((assetIdA == unit))
542+        then amountLeave
543+        else 0))
544+    let amountEnrollB = (uncountableAmountEnrollAssetB - (if ((assetIdB == unit))
545+        then amountLeave
546+        else 0))
547+    if (!(isActive))
548+        then throw("DApp is inactive at this moment")
549+        else if ((i.caller != this))
550+            then throw("Only the DApp itself can call this function")
551+            else if ((0 > amountLeave))
552+                then throw(("Argument 'amountLeave' cannot be negative. Actual: " + toString(amountLeave)))
553+                else if (if ((0 > uncountableAmountEnrollAssetA))
554+                    then true
555+                    else (0 > uncountableAmountEnrollAssetB))
556+                    then suspend("Enroll amount negative")
557+                    else if (if ((0 > amountEnrollA))
558+                        then true
559+                        else (0 > amountEnrollB))
560+                        then throw("Too large amountLeave")
561+                        else [IntegerEntry(keyBalanceA, (balanceA + amountEnrollA)), IntegerEntry(keyBalanceB, (balanceB + amountEnrollB)), IntegerEntry(("last_income_" + strAssetIdA), amountEnrollA), IntegerEntry(("last_income_" + strAssetIdB), amountEnrollB)]
562+    }
563+
564+
565+@Verifier(tx)
566+func verify () = {
567+    let multiSignedByAdmins = {
568+        let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
569+            then 1
570+            else 0
571+        let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
572+            then 1
573+            else 0
574+        let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
575+            then 1
576+            else 0
577+        (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
578+        }
579+    match tx {
580+        case inv: InvokeScriptTransaction => 
581+            let callTakeIntoAccount = if ((inv.dApp == this))
582+                then (inv.function == "takeIntoAccountExtraFunds")
583+                else false
584+            let callStaking = if (if ((inv.dApp == stakingUSDNNSBTAddress))
585+                then if (if (if (containsElement(["lockNeutrino", "lockNsbt"], inv.function))
586+                    then (size(inv.payments) == 1)
587+                    else false)
588+                    then if ((inv.payments[0].assetId == USDN))
589+                        then true
590+                        else (inv.payments[0].assetId == NSBT)
591+                    else false)
592+                    then true
593+                    else if (containsElement(["unlockNeutrino", "unlockNsbt"], inv.function))
594+                        then (size(inv.payments) == 0)
595+                        else false
596+                else false)
597+                then true
598+                else if ((inv.dApp == stakingEURNAddress))
599+                    then if (if (if ((inv.function == "startStaking"))
600+                        then (size(inv.payments) == 1)
601+                        else false)
602+                        then (inv.payments[0].assetId == EURN)
603+                        else false)
604+                        then true
605+                        else if ((inv.function == "stopStaking"))
606+                            then (size(inv.payments) == 0)
607+                            else false
608+                    else false
609+            let exchangeToWaves = if (if (if ((inv.dApp == USDNToWavesExchanger))
610+                then (inv.function == "exchange")
611+                else false)
612+                then (assetIdA == USDN)
613+                else false)
614+                then true
615+                else if (if ((assetIdB == USDN))
616+                    then (size(inv.payments) == 1)
617+                    else false)
618+                    then (inv.payments[0].assetId == USDN)
619+                    else false
620+            let exchangeToNSBTs = if (if (if ((inv.dApp == USDNToNSBTExchanger))
621+                then (inv.function == "exchange")
622+                else false)
623+                then (assetIdA == NSBT)
624+                else false)
625+                then true
626+                else if (if ((assetIdB == NSBT))
627+                    then (size(inv.payments) == 1)
628+                    else false)
629+                    then (inv.payments[0].assetId == USDN)
630+                    else false
631+            let signedByAdmin = if (if (if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
632+                then true
633+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey2))
634+                then true
635+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey3))
636+                then true
637+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKeyStaking)
638+            if (if (if (if (if (callTakeIntoAccount)
639+                then true
640+                else callStaking)
641+                then true
642+                else exchangeToWaves)
643+                then true
644+                else exchangeToNSBTs)
645+                then signedByAdmin
646+                else false)
647+                then true
648+                else multiSignedByAdmins
649+        case _ => 
650+            multiSignedByAdmins
651+    }
652+    }
653+
github/deemru/w8io/026f985 
70.03 ms ◑