tx · 24znsQu78djqUjuzcZqNfwNNPLHLKE7ediudd43EdhWy

3N9ZSF3BcaWTsMaokkwcK8qAaVEkczDVhJi:  -0.01000000 Waves

2022.01.28 10:27 [1898503] smart account 3N9ZSF3BcaWTsMaokkwcK8qAaVEkczDVhJi > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "24znsQu78djqUjuzcZqNfwNNPLHLKE7ediudd43EdhWy",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1643354821720,
    "version": 2,
    "chainId": 84,
    "sender": "3N9ZSF3BcaWTsMaokkwcK8qAaVEkczDVhJi",
    "senderPublicKey": "8BffS68u8iZTcQPPi1RwNCV7SegfEaePQ8bcjEKirvQE",
    "proofs": [
        "4iL4roBP4AfXEZ3wyRYj45KbNLpgUh1NdBKnyagosuGUjughRpoC2UQnLJuQJXQjAVuMtFPvqZYxVU69pMPj2ivx"
    ],
    "script": "base64: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",
    "height": 1898503,
    "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 keyUSDNNSBTAddress = "staking_usdnnsbt_address"
47+
48+let keyEURNAddress = "staking_eurn_address"
49+
50+let keyLeasingPool = "leasing_address"
51+
52+let keyLeasingAmount = "leasing_amount"
53+
54+let keyLeasingId = "leasing_id"
55+
56+let keyAdminPubKey1 = "admin_pub_1"
57+
58+let keyAdminPubKey2 = "admin_pub_2"
59+
60+let keyAdminPubKey3 = "admin_pub_3"
61+
62+let oracle = Address(base58'3NBBWfzZtZtszaXbitTKnrB2xXwv26Bn7H9')
63+
64+func getAdminPub (keyAdminPub) = match getString(oracle, keyAdminPub) {
65+    case string: String => 
66+        fromBase58String(string)
67+    case nothing => 
68+        throw("Admin public key is empty")
69+}
70+
71+
72+let adminPubKey1 = getAdminPub(keyAdminPubKey1)
73+
74+let adminPubKey2 = getAdminPub(keyAdminPubKey2)
75+
76+let adminPubKey3 = getAdminPub(keyAdminPubKey3)
77+
78+let adminPubKeyStartStop = base58'Kn7NpzaG12dLZgcHf2ipUftU6hbJygmrhFqQYE4B7ZK'
79+
80+let adminPubKeyStaking = base58'Kn7NpzaG12dLZgcHf2ipUftU6hbJygmrhFqQYE4B7ZK'
81+
82+let walletAddress = Address(base58'3NAGTtZz6WpupSN89NZD5rMZwwziZEg4Kx4')
83+
84+let votingAddress = Address(base58'3MrJgdL1GniipErHy44YF9idzLaUL2iX5DQ')
85+
86+let USDN = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
87+
88+let NSBT = base58'36mg8NZTaFRDygiVwb8uBnLR51hetJruUCZcxhaVcHj9'
89+
90+let SWOP = base58'2HAJrwa8q4SxBx9cHYaBTQdBjdk5wwqdof7ccpAx2uhZ'
91+
92+let EURN = base58'ECBCkHS68DckpBrzLeoRgYbFg7sCVqR176mPqbXsj9pA'
93+
94+let stakingAssets = ["WAVES", toBase58String(USDN), toBase58String(NSBT), toBase58String(EURN)]
95+
96+let stakingUSDNNSBTAddress = Address(fromBase58String(valueOrErrorMessage(getString(oracle, keyUSDNNSBTAddress), "no usdn staking address")))
97+
98+let stakingEURNAddress = Address(fromBase58String(valueOrErrorMessage(getString(oracle, keyEURNAddress), "no eurn staking address")))
99+
100+let USDNToWavesExchanger = Address(base58'3N8PGkzXhbtTvEwEQTtE2xiTJmsDEQ9XfoZ')
101+
102+let USDNToNSBTExchanger = Address(base58'3MqW1t2cxdYy2emEMk3YtZkRwQPhHaTfWRe')
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, keyActive)
113+
114+let strAssetIdA = getStringValue(this, keyAssetIdA)
115+
116+let strAssetIdB = getStringValue(this, keyAssetIdB)
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, keyBalanceA)
145+
146+let balanceB = getIntegerValue(this, keyBalanceB)
147+
148+let shareAssetId = fromBase58String(getStringValue(this, keyShareAssetId))
149+
150+let shareAssetSupply = getIntegerValue(this, keyShareAssetSupply)
151+
152+let commission = 3000
153+
154+let commissionGovernance = 1200
155+
156+let commissionScaleDelimiter = 1000000
157+
158+let scaleValue3 = 1000
159+
160+let scaleValue8 = 100000000
161+
162+let slippageToleranceDelimiter = 1000
163+
164+let scaleValue8Digits = 8
165+
166+func accountBalance (assetId) = match assetId {
167+    case id: ByteVector => 
168+        assetBalance(this, id)
169+    case waves: Unit => 
170+        wavesBalance(this).available
171+    case _ => 
172+        throw("Match error")
173+}
174+
175+
176+func stakedAmount (assetId) = {
177+    let stakedAmountCalculated =     match assetId {
178+        case aId: ByteVector => 
179+            if (if ((aId == USDN))
180+                then true
181+                else (aId == NSBT))
182+                then getInteger(stakingUSDNNSBTAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(this)))
183+                else if ((aId == EURN))
184+                    then getInteger(stakingEURNAddress, ((("%s%s%s__stakingBalance__" + toBase58String(aId)) + "__") + toString(this)))
185+                    else 0
186+        case _: Unit => 
187+            valueOrElse(getInteger(this, keyLeasingAmount), 0)
188+        case _ => 
189+            throw("Match error")
190+    }
191+    match stakedAmountCalculated {
192+        case i: Int => 
193+            i
194+        case _ => 
195+            0
196+    }
197+    }
198+
199+
200+let stakedAmountA = stakedAmount(assetIdA)
201+
202+let stakedAmountB = stakedAmount(assetIdB)
203+
204+let assetInitA = getIntegerValue(this, keyBalanceInitA)
205+
206+let assetInitB = getIntegerValue(this, keyBalanceInitB)
207+
208+let availableBalanceA = (balanceA - stakedAmountA)
209+
210+let availableBalanceB = (balanceB - stakedAmountB)
211+
212+let accountBalanceWithStakedA = (accountBalance(assetIdA) + stakedAmountA)
213+
214+let accountBalanceWithStakedB = (accountBalance(assetIdB) + stakedAmountB)
215+
216+let hasEnoughBalance = if ((accountBalanceWithStakedA >= balanceA))
217+    then (accountBalanceWithStakedB >= balanceB)
218+    else false
219+
220+func getAssetInfo (assetId) = match assetId {
221+    case id: ByteVector => 
222+        let stringId = toBase58String(id)
223+        let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
224+        $Tuple3(stringId, info.name, info.decimals)
225+    case waves: Unit => 
226+        $Tuple3("WAVES", "WAVES", 8)
227+    case _ => 
228+        throw("Match error")
229+}
230+
231+
232+func getAssetInfoFromString (assetStr) = if ((assetStr == "WAVES"))
233+    then $Tuple3("WAVES", "WAVES", 8)
234+    else {
235+        let stringId = assetStr
236+        let id = fromBase58String(assetStr)
237+        let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
238+        $Tuple3(stringId, info.name, info.decimals)
239+        }
240+
241+
242+func suspend (cause) = [BooleanEntry(keyActive, false), StringEntry(keyCause, cause)]
243+
244+
245+func calcStakingFuncAndAddres (stake,assetId) = if (stake)
246+    then if ((assetId == USDN))
247+        then $Tuple2("lockNeutrino", stakingUSDNNSBTAddress)
248+        else if ((assetId == NSBT))
249+            then $Tuple2("lockNsbt", stakingUSDNNSBTAddress)
250+            else $Tuple2("startStaking", stakingEURNAddress)
251+    else if ((assetId == USDN))
252+        then $Tuple2("unlockNeutrino", stakingUSDNNSBTAddress)
253+        else if ((assetId == NSBT))
254+            then $Tuple2("unlockNsbt", stakingUSDNNSBTAddress)
255+            else $Tuple2("stopStaking", stakingEURNAddress)
256+
257+
258+func calcStakingParams (stake,amount,assetId) = if (stake)
259+    then {
260+        let $t069226988 = calcStakingFuncAndAddres(stake, assetId)
261+        let call = $t069226988._1
262+        let stakingAddr = $t069226988._2
263+        $Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
264+        }
265+    else {
266+        let $t070747140 = calcStakingFuncAndAddres(stake, assetId)
267+        let call = $t070747140._1
268+        let stakingAddr = $t070747140._2
269+        $Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
270+        }
271+
272+
273+func calculateFees (pmtAmount,minAmountToReceive,tokenFrom,tokenTo) = {
274+    let amountWithoutFee = fraction(tokenTo, pmtAmount, (pmtAmount + tokenFrom))
275+    let amountWithFee = fraction(amountWithoutFee, (commissionScaleDelimiter - commission), commissionScaleDelimiter)
276+    let governanceReward = fraction(amountWithoutFee, commissionGovernance, commissionScaleDelimiter)
277+    if ((minAmountToReceive > amountWithFee))
278+        then throw(((("Calculated amount to receive " + toString(amountWithFee)) + " is less than specified minimum ") + toString(minAmountToReceive)))
279+        else $Tuple3(amountWithoutFee, amountWithFee, governanceReward)
280+    }
281+
282+
283+func suspendSuspicious () = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(accountBalanceWithStakedA)) + " ") + assetNameA) + ", ") + toString(accountBalanceWithStakedB)) + " ") + assetNameB) + ". State: ") + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB))
284+
285+
286+func isActive () = if (active)
287+    then unit
288+    else throw("DApp is inactive at this moment")
289+
290+
291+@Callable(i)
292+func init (firstHarvest) = {
293+    let $t083108387 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
294+    let pmtAmountA = $t083108387._1
295+    let pmtAssetIdA = $t083108387._2
296+    let $t083928469 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
297+    let pmtAmountB = $t083928469._1
298+    let pmtAssetIdB = $t083928469._2
299+    let $t084748551 = getAssetInfo(pmtAssetIdA)
300+    let pmtStrAssetIdA = $t084748551._1
301+    let pmtAssetNameA = $t084748551._2
302+    let pmtDecimalsA = $t084748551._3
303+    let $t085568633 = getAssetInfo(pmtAssetIdB)
304+    let pmtStrAssetIdB = $t085568633._1
305+    let pmtAssetNameB = $t085568633._2
306+    let pmtDecimalsB = $t085568633._3
307+    if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStaking], i.callerPublicKey)))
308+        then throw("Only admin can call this function")
309+        else if (isDefined(getBoolean(this, keyActive)))
310+            then throw("DApp is already active")
311+            else if ((pmtAssetIdA == pmtAssetIdB))
312+                then throw("Assets must be different")
313+                else {
314+                    let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
315+                    let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
316+                    let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
317+                    let arg1 = pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN)
318+                    let arg2 = pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN)
319+                    let arg3 = pow(10, 0, shareDecimals, 0, 0, DOWN)
320+                    let shareInitialSupply = fraction(arg1, arg2, arg3)
321+                    let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
322+                    let shareIssueId = calculateAssetId(shareIssue)
323+                    let stake1 = if (containsElement(stakingAssets, pmtStrAssetIdA))
324+                        then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
325+                        else 0
326+                    if ((stake1 == stake1))
327+                        then {
328+                            let stake2 = if (containsElement(stakingAssets, pmtStrAssetIdB))
329+                                then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
330+                                else 0
331+                            if ((stake2 == stake2))
332+                                then {
333+                                    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)]
334+                                    if (firstHarvest)
335+                                        then (baseEntry ++ [BooleanEntry(keyFirstHarvest, firstHarvest), IntegerEntry(keyFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))])
336+                                        else baseEntry
337+                                    }
338+                                else throw("Strict value is not equal to itself.")
339+                            }
340+                        else throw("Strict value is not equal to itself.")
341+                    }
342+    }
343+
344+
345+
346+@Callable(i)
347+func initWithInitRatio (amtAssetA,amtAssetB,strAssetIdA,strAssetIdB,firstHarvest) = {
348+    let $t01122211309 = getAssetInfoFromString(strAssetIdA)
349+    let pmtStrAssetIdA = $t01122211309._1
350+    let pmtAssetNameA = $t01122211309._2
351+    let pmtDecimalsA = $t01122211309._3
352+    let $t01131411401 = getAssetInfoFromString(strAssetIdB)
353+    let pmtStrAssetIdB = $t01131411401._1
354+    let pmtAssetNameB = $t01131411401._2
355+    let pmtDecimalsB = $t01131411401._3
356+    if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStaking], i.callerPublicKey)))
357+        then throw("Only admin can call this function")
358+        else if (isDefined(getBoolean(this, keyActive)))
359+            then throw("DApp is already active")
360+            else if ((strAssetIdA == strAssetIdB))
361+                then throw("Assets must be different")
362+                else {
363+                    let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
364+                    let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
365+                    let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
366+                    let shareInitialSupply = 0
367+                    let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
368+                    let shareIssueId = calculateAssetId(shareIssue)
369+                    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)]
370+                    if (firstHarvest)
371+                        then (baseEntry ++ [BooleanEntry(keyFirstHarvest, firstHarvest), IntegerEntry(keyFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))])
372+                        else baseEntry
373+                    }
374+    }
375+
376+
377+
378+@Callable(i)
379+func keepLimitForFirstHarvest (shareLimit) = valueOrElse(isActive(), if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStaking], i.callerPublicKey)))
380+    then throw("Only admin can call this function")
381+    else [IntegerEntry(kShareLimit, shareLimit)])
382+
383+
384+
385+@Callable(i)
386+func replenishWithTwoTokens (slippageTolerance) = valueOrElse(isActive(), {
387+    let pmtAssetIdA = i.payments[0].assetId
388+    let pmtAssetIdB = i.payments[1].assetId
389+    let pmtAmountA = i.payments[0].amount
390+    let pmtAmountB = i.payments[1].amount
391+    let $t01386913946 = getAssetInfo(pmtAssetIdA)
392+    let pmtStrAssetIdA = $t01386913946._1
393+    let pmtAssetNameA = $t01386913946._2
394+    let pmtDecimalsA = $t01386913946._3
395+    let $t01395114028 = getAssetInfo(pmtAssetIdB)
396+    let pmtStrAssetIdB = $t01395114028._1
397+    let pmtAssetNameB = $t01395114028._2
398+    let pmtDecimalsB = $t01395114028._3
399+    let inital = if (if ((balanceA == 0))
400+        then (balanceB == 0)
401+        else false)
402+        then true
403+        else false
404+    let tokenRatio = if (inital)
405+        then fraction(fraction(assetInitA, scaleValue8, pmtAmountA), scaleValue3, fraction(assetInitB, scaleValue8, pmtAmountB))
406+        else fraction(fraction(balanceA, scaleValue8, pmtAmountA), scaleValue3, fraction(balanceB, scaleValue8, pmtAmountB))
407+    let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
408+    let shareTokenToPayAmount = if (inital)
409+        then fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN), pow(10, 0, shareDecimals, 0, 0, DOWN))
410+        else fraction(min([fraction(pmtAmountA, scaleValue8, balanceA), fraction(pmtAmountB, scaleValue8, balanceB)]), shareAssetSupply, scaleValue8)
411+    if (if ((0 > slippageTolerance))
412+        then true
413+        else (slippageTolerance > slippageToleranceDelimiter))
414+        then throw(((("Slippage tolerance must be between 0 and " + toString(slippageToleranceDelimiter)) + " inclusively. Actual: ") + toString(slippageTolerance)))
415+        else if ((size(i.payments) != 2))
416+            then throw("Two attached assets expected")
417+            else if (if ((pmtAssetIdA != assetIdA))
418+                then true
419+                else (pmtAssetIdB != assetIdB))
420+                then throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
421+                else if (if ((((scaleValue3 * (slippageToleranceDelimiter - slippageTolerance)) / slippageToleranceDelimiter) > tokenRatio))
422+                    then true
423+                    else (tokenRatio > ((scaleValue3 * (slippageToleranceDelimiter + slippageTolerance)) / slippageToleranceDelimiter)))
424+                    then throw("Incorrect assets amount: amounts must have the contract ratio")
425+                    else if ((shareTokenToPayAmount == 0))
426+                        then throw("Too small amount to replenish")
427+                        else if (!(hasEnoughBalance))
428+                            then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
429+                            else {
430+                                let stake1 = if (containsElement(stakingAssets, pmtStrAssetIdA))
431+                                    then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
432+                                    else 0
433+                                if ((stake1 == stake1))
434+                                    then {
435+                                        let stake2 = if (containsElement(stakingAssets, pmtStrAssetIdB))
436+                                            then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
437+                                            else 0
438+                                        if ((stake2 == stake2))
439+                                            then [Reissue(shareAssetId, shareTokenToPayAmount, true), IntegerEntry(keyBalanceA, (balanceA + pmtAmountA)), IntegerEntry(keyBalanceB, (balanceB + pmtAmountB)), IntegerEntry(keyShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId)]
440+                                            else throw("Strict value is not equal to itself.")
441+                                        }
442+                                    else throw("Strict value is not equal to itself.")
443+                                }
444+    })
445+
446+
447+
448+@Callable(i)
449+func withdraw () = valueOrElse(isActive(), {
450+    let $t01683416909 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
451+    let pmtAmount = $t01683416909._1
452+    let pmtAssetId = $t01683416909._2
453+    let amountToPayA = fraction(pmtAmount, balanceA, shareAssetSupply)
454+    let amountToPayB = fraction(pmtAmount, balanceB, shareAssetSupply)
455+    if ((size(i.payments) != 1))
456+        then throw("One attached payment expected")
457+        else if ((pmtAssetId != shareAssetId))
458+            then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
459+            else if (!(hasEnoughBalance))
460+                then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
461+                else {
462+                    let stake1 = if (containsElement(stakingAssets, strAssetIdA))
463+                        then invoke(this, "stakeUnstake", [false, amountToPayA, strAssetIdA], nil)
464+                        else 0
465+                    if ((stake1 == stake1))
466+                        then {
467+                            let stake2 = if (containsElement(stakingAssets, strAssetIdB))
468+                                then invoke(this, "stakeUnstake", [false, amountToPayB, strAssetIdB], nil)
469+                                else 0
470+                            if ((stake2 == stake2))
471+                                then [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)]
472+                                else throw("Strict value is not equal to itself.")
473+                            }
474+                        else throw("Strict value is not equal to itself.")
475+                    }
476+    })
477+
478+
479+
480+@Callable(i)
481+func exchange (minAmountToReceive) = valueOrElse(isActive(), {
482+    let $t01821518290 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
483+    let pmtAmount = $t01821518290._1
484+    let pmtAssetId = $t01821518290._2
485+    if (if ((balanceA == 0))
486+        then true
487+        else (balanceB == 0))
488+        then throw("Can't exchange with zero balance")
489+        else if ((0 >= minAmountToReceive))
490+            then throw(("Minimal amount to receive must be positive. Actual: " + toString(minAmountToReceive)))
491+            else if ((size(i.payments) != 1))
492+                then throw("One attached payment expected")
493+                else if (!(hasEnoughBalance))
494+                    then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
495+                    else if ((pmtAssetId == assetIdA))
496+                        then {
497+                            let assetIdSend = assetIdB
498+                            let $t01884518967 = calculateFees(pmtAmount, minAmountToReceive, balanceA, balanceB)
499+                            let amountWithoutFee = $t01884518967._1
500+                            let amountWithFee = $t01884518967._2
501+                            let governanceReward = $t01884518967._3
502+                            let newBalanceA = (balanceA + pmtAmount)
503+                            let newBalanceB = ((balanceB - amountWithFee) - governanceReward)
504+                            let stake1 = if (containsElement(stakingAssets, strAssetIdA))
505+                                then invoke(this, "stakeUnstake", [true, pmtAmount, strAssetIdA], nil)
506+                                else 0
507+                            if ((stake1 == stake1))
508+                                then {
509+                                    let stake2 = if (containsElement(stakingAssets, strAssetIdB))
510+                                        then invoke(this, "stakeUnstake", [false, (amountWithFee + governanceReward), strAssetIdB], nil)
511+                                        else 0
512+                                    if ((stake2 == stake2))
513+                                        then [IntegerEntry(keyBalanceA, newBalanceA), IntegerEntry(keyBalanceB, newBalanceB), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(walletAddress, governanceReward, assetIdSend)]
514+                                        else throw("Strict value is not equal to itself.")
515+                                    }
516+                                else throw("Strict value is not equal to itself.")
517+                            }
518+                        else if ((pmtAssetId == assetIdB))
519+                            then {
520+                                let assetIdSend = assetIdA
521+                                let $t01992220044 = calculateFees(pmtAmount, minAmountToReceive, balanceB, balanceA)
522+                                let amountWithoutFee = $t01992220044._1
523+                                let amountWithFee = $t01992220044._2
524+                                let governanceReward = $t01992220044._3
525+                                let newBalanceA = ((balanceA - amountWithFee) - governanceReward)
526+                                let newBalanceB = (balanceB + pmtAmount)
527+                                let stake1 = if (containsElement(stakingAssets, strAssetIdA))
528+                                    then invoke(this, "stakeUnstake", [false, (amountWithFee + governanceReward), strAssetIdA], nil)
529+                                    else 0
530+                                if ((stake1 == stake1))
531+                                    then {
532+                                        let stake2 = if (containsElement(stakingAssets, strAssetIdB))
533+                                            then invoke(this, "stakeUnstake", [true, pmtAmount, strAssetIdB], nil)
534+                                            else 0
535+                                        if ((stake2 == stake2))
536+                                            then [IntegerEntry(keyBalanceA, newBalanceA), IntegerEntry(keyBalanceB, newBalanceB), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(walletAddress, governanceReward, assetIdSend)]
537+                                            else throw("Strict value is not equal to itself.")
538+                                        }
539+                                    else throw("Strict value is not equal to itself.")
540+                                }
541+                            else throw(((("Incorrect asset attached. Expected: " + strAssetIdA) + " or ") + strAssetIdB))
542+    })
543+
544+
545+
546+@Callable(i)
547+func shutdown () = if (!(active))
548+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, keyCause), "the cause wasn't specified")))
549+    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop], i.callerPublicKey)))
550+        then throw("Only admin can call this function")
551+        else suspend("Paused by admin")
552+
553+
554+
555+@Callable(i)
556+func activate () = if (active)
557+    then throw("DApp is already active")
558+    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop], i.callerPublicKey)))
559+        then throw("Only admin can call this function")
560+        else [BooleanEntry(keyActive, true), DeleteEntry(keyCause)]
561+
562+
563+
564+@Callable(i)
565+func takeIntoAccountExtraFunds () = valueOrElse(isActive(), {
566+    let amountEnrollA = (accountBalanceWithStakedA - balanceA)
567+    let amountEnrollB = (accountBalanceWithStakedB - balanceB)
568+    if ((i.caller != walletAddress))
569+        then throw("Only the wallet can call this function")
570+        else if (if ((0 > amountEnrollA))
571+            then true
572+            else (0 > amountEnrollB))
573+            then suspend("Enroll amount negative")
574+            else if (if ((amountEnrollA == 0))
575+                then (amountEnrollB == 0)
576+                else false)
577+                then throw("No money to take")
578+                else {
579+                    let stake1 = if (containsElement(stakingAssets, strAssetIdA))
580+                        then invoke(this, "stakeUnstake", [true, amountEnrollA, strAssetIdA], nil)
581+                        else 0
582+                    if ((stake1 == stake1))
583+                        then {
584+                            let stake2 = if (containsElement(stakingAssets, strAssetIdB))
585+                                then invoke(this, "stakeUnstake", [true, amountEnrollB, strAssetIdB], nil)
586+                                else 0
587+                            if ((stake2 == stake2))
588+                                then [IntegerEntry(keyBalanceA, (balanceA + amountEnrollA)), IntegerEntry(keyBalanceB, (balanceB + amountEnrollB)), IntegerEntry(("last_income_" + strAssetIdA), amountEnrollA), IntegerEntry(("last_income_" + strAssetIdB), amountEnrollB)]
589+                                else throw("Strict value is not equal to itself.")
590+                            }
591+                        else throw("Strict value is not equal to itself.")
592+                    }
593+    })
594+
595+
596+
597+@Callable(i)
598+func stakeUnstake (stake,amount,assetIdString) = if ((i.caller != this))
599+    then throw("Only contract itself can invoke this function")
600+    else if ((assetIdString == "WAVES"))
601+        then {
602+            let pool = addressFromStringValue(valueOrErrorMessage(getString(oracle, keyLeasingPool), "No leasing pool in oracle"))
603+            let leasingId = getBinary(this, keyLeasingId)
604+            let leasingAmount = valueOrElse(getInteger(this, keyLeasingAmount), 0)
605+            let newLeaseAmount = if (stake)
606+                then (leasingAmount + amount)
607+                else (leasingAmount - amount)
608+            let newLease = Lease(pool, newLeaseAmount)
609+            let newLeaseId = calculateLeaseId(newLease)
610+            let baseEtry = [newLease, BinaryEntry(keyLeasingId, newLeaseId), IntegerEntry(keyLeasingAmount, newLeaseAmount)]
611+            match leasingId {
612+                case lId: ByteVector => 
613+                    ([LeaseCancel(lId)] ++ baseEtry)
614+                case _ => 
615+                    baseEtry
616+            }
617+            }
618+        else {
619+            let $t02377823881 = calcStakingParams(stake, amount, fromBase58String(assetIdString))
620+            let call = $t02377823881._1
621+            let addr = $t02377823881._2
622+            let params = $t02377823881._3
623+            let payments = $t02377823881._4
624+            let inv = invoke(addr, call, params, payments)
625+            if ((inv == inv))
626+                then nil
627+                else throw("Strict value is not equal to itself.")
628+            }
629+
630+
631+
632+@Callable(i)
633+func stakeAll () = valueOrElse(isActive(), if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop], i.callerPublicKey)))
634+    then throw("Only admin can call this function")
635+    else {
636+        let stake1 = if (containsElement(stakingAssets, strAssetIdA))
637+            then {
638+                let amountA = (balanceA - stakedAmountA)
639+                if ((amountA > 0))
640+                    then invoke(this, "stakeUnstake", [true, amountA, strAssetIdA], nil)
641+                    else 0
642+                }
643+            else 0
644+        if ((stake1 == stake1))
645+            then {
646+                let stake2 = if (containsElement(stakingAssets, strAssetIdB))
647+                    then {
648+                        let amountB = (balanceB - stakedAmountB)
649+                        if ((amountB > 0))
650+                            then invoke(this, "stakeUnstake", [true, amountB, strAssetIdB], nil)
651+                            else 0
652+                        }
653+                    else 0
654+                if ((stake2 == stake2))
655+                    then nil
656+                    else throw("Strict value is not equal to itself.")
657+                }
658+            else throw("Strict value is not equal to itself.")
659+        })
660+
661+
662+@Verifier(tx)
663+func verify () = {
664+    let multiSignedByAdmins = {
665+        let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
666+            then 1
667+            else 0
668+        let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
669+            then 1
670+            else 0
671+        let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
672+            then 1
673+            else 0
674+        (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
675+        }
676+    match tx {
677+        case inv: InvokeScriptTransaction => 
678+            let callTakeIntoAccount = if ((inv.dApp == this))
679+                then (inv.function == "takeIntoAccountExtraFunds")
680+                else false
681+            let exchangeToWaves = if (if (if ((inv.dApp == USDNToWavesExchanger))
682+                then (inv.function == "exchange")
683+                else false)
684+                then (assetIdA == USDN)
685+                else false)
686+                then true
687+                else if (if ((assetIdB == USDN))
688+                    then (size(inv.payments) == 1)
689+                    else false)
690+                    then (inv.payments[0].assetId == USDN)
691+                    else false
692+            let exchangeToNSBTs = if (if (if ((inv.dApp == USDNToNSBTExchanger))
693+                then (inv.function == "exchange")
694+                else false)
695+                then (assetIdA == NSBT)
696+                else false)
697+                then true
698+                else if (if ((assetIdB == NSBT))
699+                    then (size(inv.payments) == 1)
700+                    else false)
701+                    then (inv.payments[0].assetId == USDN)
702+                    else false
703+            let signedByAdmin = if (if (if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
704+                then true
705+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey2))
706+                then true
707+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey3))
708+                then true
709+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKeyStaking)
710+            if (if (if (if (callTakeIntoAccount)
711+                then true
712+                else exchangeToWaves)
713+                then true
714+                else exchangeToNSBTs)
715+                then signedByAdmin
716+                else false)
717+                then true
718+                else multiSignedByAdmins
719+        case _ => 
720+            multiSignedByAdmins
721+    }
722+    }
723+
github/deemru/w8io/169f3d6 
37.54 ms ◑