tx · DxTsQpeXN57omYE6pTTEZ5hZtBuGGo5gq33VvVEAcjCe

3N8rwRVNrxgqwFiVCNyX2Zyy6Lzgd1fDctN:  -0.01000000 Waves

2021.12.29 11:04 [1855245] smart account 3N8rwRVNrxgqwFiVCNyX2Zyy6Lzgd1fDctN > SELF 0.00000000 Waves

{ "type": 13, "id": "DxTsQpeXN57omYE6pTTEZ5hZtBuGGo5gq33VvVEAcjCe", "fee": 1000000, "feeAssetId": null, "timestamp": 1640765105440, "version": 2, "chainId": 84, "sender": "3N8rwRVNrxgqwFiVCNyX2Zyy6Lzgd1fDctN", "senderPublicKey": "2SGdJb3x9Ak59xjRyHMHFxLvh6dC5m37urdsBJy3f6TU", "proofs": [ "4SqHgJ4PwX8fW8fNgfYzHbMaBsy7XQo7khdKeWneZZsjXJVahGoPQkExgeqGsNZY3PssJwwjHM3NdPB5RtT9CqvC" ], "script": "base64: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", "height": 1855245, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: FDnfSgeBuZJq2fDt64MpCnXYmTMoB3jLXoQ9ggmaA4BW Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let version = "2.0.0"
5+
6+let kVersion = "version"
7+
8+let kActive = "active"
9+
10+let kAssetIdA = "A_asset_id"
11+
12+let kAssetIdB = "B_asset_id"
13+
14+let kBalanceA = "A_asset_balance"
15+
16+let kBalanceB = "B_asset_balance"
17+
18+let kShareAssetId = "share_asset_id"
19+
20+let kShareAssetSupply = "share_asset_supply"
21+
22+let kFee = "commission"
23+
24+let kFeeScaleDelimiter = "commission_scale_delimiter"
25+
26+let kInvariant = "invariant"
27+
28+let kCause = "shutdown_cause"
29+
30+let keyUSDNNSBTAddress = "staking_usdnnsbt_address"
31+
32+let keyEURNAddress = "staking_eurn_address"
33+
34+let keyAdminPubKey1 = "admin_pub_1"
35+
36+let keyAdminPubKey2 = "admin_pub_2"
37+
38+let keyAdminPubKey3 = "admin_pub_3"
39+
40+let oracle = Address(base58'3NBBWfzZtZtszaXbitTKnrB2xXwv26Bn7H9')
41+
42+func getAdminPub (keyAdminPub) = match getString(oracle, keyAdminPub) {
43+ case string: String =>
44+ fromBase58String(string)
45+ case nothing =>
46+ throw("Admin public key is empty")
47+}
48+
49+
50+let adminPubKey1 = getAdminPub(keyAdminPubKey1)
51+
52+let adminPubKey2 = getAdminPub(keyAdminPubKey2)
53+
54+let adminPubKey3 = getAdminPub(keyAdminPubKey3)
55+
56+let admStartStop = base58'Kn7NpzaG12dLZgcHf2ipUftU6hbJygmrhFqQYE4B7ZK'
57+
58+let admStaking = base58'Kn7NpzaG12dLZgcHf2ipUftU6hbJygmrhFqQYE4B7ZK'
59+
60+let govAddr = Address(base58'3NAGTtZz6WpupSN89NZD5rMZwwziZEg4Kx4')
61+
62+let USDN = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
63+
64+let EURN = base58'ECBCkHS68DckpBrzLeoRgYbFg7sCVqR176mPqbXsj9pA'
65+
66+let stakingAssets = [toBase58String(USDN), toBase58String(EURN)]
67+
68+let stakingUSDNNSBTAddress = Address(fromBase58String(valueOrErrorMessage(getString(oracle, keyUSDNNSBTAddress), "no usdn staking address")))
69+
70+let stakingEURNAddress = Address(fromBase58String(valueOrErrorMessage(getString(oracle, keyEURNAddress), "no usdn staking address")))
71+
72+let isActive = getBooleanValue(this, kActive)
73+
74+let strAssetIdA = getStringValue(this, kAssetIdA)
75+
76+let strAssetIdB = getStringValue(this, kAssetIdB)
77+
78+let assetIdA = if ((strAssetIdA == "WAVES"))
79+ then unit
80+ else fromBase58String(strAssetIdA)
81+
82+let assetIdB = if ((strAssetIdB == "WAVES"))
83+ then unit
84+ else fromBase58String(strAssetIdB)
85+
86+let assetNameA = match assetIdA {
87+ case id: ByteVector =>
88+ value(assetInfo(id)).name
89+ case waves: Unit =>
90+ "WAVES"
91+ case _ =>
92+ throw("Match error")
93+}
94+
95+let assetNameB = match assetIdB {
96+ case id: ByteVector =>
97+ value(assetInfo(id)).name
98+ case waves: Unit =>
99+ "WAVES"
100+ case _ =>
101+ throw("Match error")
102+}
103+
104+let balanceA = getIntegerValue(this, kBalanceA)
105+
106+let balanceB = getIntegerValue(this, kBalanceB)
107+
108+let shareAssetId = fromBase58String(getStringValue(this, kShareAssetId))
109+
110+let shareAssetSupply = getIntegerValue(this, kShareAssetSupply)
111+
112+let invariant = getIntegerValue(this, kInvariant)
113+
114+let fee = 500
115+
116+let feeGovernance = 200
117+
118+let feeScale6 = 1000000
119+
120+let scale3 = 1000
121+
122+let scale8 = 100000000
123+
124+let scale12 = 1000000000000
125+
126+let slippageScale3 = 1000
127+
128+let digits8 = 8
129+
130+let dAppThreshold = 50
131+
132+let dAppThresholdScale2 = 100
133+
134+let exchangeRatioLimitMin = 90000000
135+
136+let exchangeRatioLimitMax = 110000000
137+
138+let alpha = 50
139+
140+let alphaDigits = 2
141+
142+let beta = 46000000
143+
144+func accountBalance (assetId) = match assetId {
145+ case id: ByteVector =>
146+ assetBalance(this, id)
147+ case waves: Unit =>
148+ wavesBalance(this).available
149+ case _ =>
150+ throw("Match error")
151+}
152+
153+
154+func stakedAmount (assetId) = {
155+ let stakedAmountCalculated = match assetId {
156+ case aId: ByteVector =>
157+ if ((aId == USDN))
158+ then getInteger(stakingUSDNNSBTAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(this)))
159+ else if ((aId == EURN))
160+ then getInteger(stakingEURNAddress, ((("%s%s%s__stakingBalance__" + toBase58String(aId)) + "__") + toString(this)))
161+ else 0
162+ case _: Unit =>
163+ 0
164+ case _ =>
165+ throw("Match error")
166+ }
167+ match stakedAmountCalculated {
168+ case i: Int =>
169+ i
170+ case _ =>
171+ 0
172+ }
173+ }
174+
175+
176+let stakedAmountA = stakedAmount(assetIdA)
177+
178+let stakedAmountB = stakedAmount(assetIdB)
179+
180+let availableBalanceA = (balanceA - stakedAmountA)
181+
182+let availableBalanceB = (balanceB - stakedAmountB)
183+
184+let accountBalanceWithStakedA = (accountBalance(assetIdA) + stakedAmountA)
185+
186+let accountBalanceWithStakedB = (accountBalance(assetIdB) + stakedAmountB)
187+
188+let hasEnoughBalance = if ((accountBalanceWithStakedA >= balanceA))
189+ then (accountBalanceWithStakedB >= balanceB)
190+ else false
191+
192+func skewness (x,y) = (((fraction(scale12, x, y) + fraction(scale12, y, x)) / 2) / 10000)
193+
194+
195+func invariantCalc (x,y) = {
196+ let sk = skewness(x, y)
197+ (fraction((x + y), scale8, pow(sk, digits8, alpha, alphaDigits, digits8, CEILING)) + (2 * fraction(pow(fraction(x, y, scale8), 0, 5, 1, (digits8 / 2), DOWN), pow((sk - beta), digits8, alpha, alphaDigits, digits8, DOWN), scale8)))
198+ }
199+
200+
201+func calculateSendAmount (amountToSendEstimated,minTokenReceiveAmount,tokenReceiveAmount,tokenId) = {
202+ let slippageValue = (scale8 - ((scale8 * 1) / 10000000))
203+ let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
204+ let x = (balanceA + tokenReceiveAmount)
205+ let y = (balanceB + tokenReceiveAmount)
206+ let invariantNew = if ((tokenId == assetIdA))
207+ then invariantCalc(x, (balanceB - amountToSendEstimated))
208+ else if ((tokenId == assetIdB))
209+ then invariantCalc((balanceA - amountToSendEstimated), y)
210+ else throw("Wrong asset in payment")
211+ let invariantEstimatedRatio = fraction(scale8, invariant, invariantNew)
212+ func getStepAmount (acc,step) = if ((acc == -1))
213+ then {
214+ let amountToSend = (amountToSendEstimated - ((step * deltaBetweenMaxAndMinSendValue) / 5))
215+ let stepInvariant = if ((tokenId == assetIdA))
216+ then invariantCalc(x, (balanceB - amountToSend))
217+ else invariantCalc((balanceA - amountToSend), y)
218+ if ((stepInvariant > invariant))
219+ then amountToSend
220+ else -1
221+ }
222+ else acc
223+
224+ let stepAmount = {
225+ let $l = [1, 2, 3, 4, 5]
226+ let $s = size($l)
227+ let $acc0 = -1
228+ func $f0_1 ($a,$i) = if (($i >= $s))
229+ then $a
230+ else getStepAmount($a, $l[$i])
231+
232+ func $f0_2 ($a,$i) = if (($i >= $s))
233+ then $a
234+ else throw("List size exceeds 5")
235+
236+ $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
237+ }
238+ if ((0 > stepAmount))
239+ then throw("something went wrong while working with amountToSend")
240+ else if (if ((invariantEstimatedRatio > slippageValue))
241+ then (invariantNew > invariant)
242+ else false)
243+ then amountToSendEstimated
244+ else stepAmount
245+ }
246+
247+
248+func getAssetInfo (assetId) = match assetId {
249+ case id: ByteVector =>
250+ let stringId = toBase58String(id)
251+ let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
252+ $Tuple3(stringId, info.name, info.decimals)
253+ case waves: Unit =>
254+ $Tuple3("WAVES", "WAVES", 8)
255+ case _ =>
256+ throw("Match error")
257+}
258+
259+
260+func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
261+
262+
263+func throwIsActive () = throw("DApp is already active")
264+
265+
266+func throwIsInactive () = throw("DApp is inactive at this moment")
267+
268+
269+func throwOnlyAdmin () = throw("Only admin can call this function")
270+
271+
272+func throwAssets () = throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
273+
274+
275+func throwThreshold (threshold,amountA,amountB) = throw(((((((((("New balance in assets of the DApp is less than threshold " + toString(threshold)) + ": ") + toString(amountA)) + " ") + assetNameA) + ", ") + toString(amountB)) + " ") + assetNameB))
276+
277+
278+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"))
279+
280+
281+func suspendSuspicious () = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB) + ". State: ") + toString(accountBalance(assetIdA))) + " ") + assetNameA) + ", ") + toString(accountBalance(assetIdB))) + " ") + assetNameB))
282+
283+
284+func calcStakingFuncAndAddres (stake,assetId) = if (stake)
285+ then if ((assetId == USDN))
286+ then $Tuple2("lockNeutrino", stakingUSDNNSBTAddress)
287+ else $Tuple2("startStaking", stakingEURNAddress)
288+ else if ((assetId == USDN))
289+ then $Tuple2("unlockNeutrino", stakingUSDNNSBTAddress)
290+ else $Tuple2("stopStaking", stakingEURNAddress)
291+
292+
293+func calcStakingParams (stake,amount,assetId) = if (stake)
294+ then {
295+ let $t095829648 = calcStakingFuncAndAddres(stake, assetId)
296+ let call = $t095829648._1
297+ let stakingAddr = $t095829648._2
298+ $Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
299+ }
300+ else {
301+ let $t097349800 = calcStakingFuncAndAddres(stake, assetId)
302+ let call = $t097349800._1
303+ let stakingAddr = $t097349800._2
304+ $Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
305+ }
306+
307+
308+@Callable(i)
309+func init () = {
310+ let $t099059982 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
311+ let pmtAmountA = $t099059982._1
312+ let pmtAssetIdA = $t099059982._2
313+ let $t0998710064 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
314+ let pmtAmountB = $t0998710064._1
315+ let pmtAssetIdB = $t0998710064._2
316+ let $t01006910146 = getAssetInfo(pmtAssetIdA)
317+ let pmtStrAssetIdA = $t01006910146._1
318+ let pmtAssetNameA = $t01006910146._2
319+ let pmtDecimalsA = $t01006910146._3
320+ let $t01015110228 = getAssetInfo(pmtAssetIdB)
321+ let pmtStrAssetIdB = $t01015110228._1
322+ let pmtAssetNameB = $t01015110228._2
323+ let pmtDecimalsB = $t01015110228._3
324+ if (isDefined(getBoolean(this, kActive)))
325+ then throwIsActive()
326+ else if ((pmtAssetIdA == pmtAssetIdB))
327+ then throw("Assets must be different")
328+ else {
329+ let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
330+ let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
331+ let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
332+ let shareInitialSupply = fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN), pow(10, 0, shareDecimals, 0, 0, DOWN))
333+ let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
334+ let shareIssueId = calculateAssetId(shareIssue)
335+ let invariantCalculated = invariantCalc(pmtAmountA, pmtAmountB)
336+ let stake1 = if (containsElement(stakingAssets, pmtStrAssetIdA))
337+ then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
338+ else 0
339+ if ((stake1 == stake1))
340+ then {
341+ let stake2 = if (containsElement(stakingAssets, pmtStrAssetIdB))
342+ then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
343+ else 0
344+ if ((stake2 == stake2))
345+ then [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceA, pmtAmountA), IntegerEntry(kBalanceB, pmtAmountB), IntegerEntry(kInvariant, invariantCalculated), IntegerEntry(kFee, fee), IntegerEntry(kFeeScaleDelimiter, feeScale6), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
346+ else throw("Strict value is not equal to itself.")
347+ }
348+ else throw("Strict value is not equal to itself.")
349+ }
350+ }
351+
352+
353+
354+@Callable(i)
355+func replenishWithTwoTokens (slippageTolerance) = {
356+ let pmtAssetIdA = i.payments[0].assetId
357+ let pmtAssetIdB = i.payments[1].assetId
358+ let pmtAmountA = i.payments[0].amount
359+ let pmtAmountB = i.payments[1].amount
360+ let $t01274812825 = getAssetInfo(pmtAssetIdA)
361+ let pmtStrAssetIdA = $t01274812825._1
362+ let pmtAssetNameA = $t01274812825._2
363+ let pmtDecimalsA = $t01274812825._3
364+ let $t01283013024 = getAssetInfo(pmtAssetIdB)
365+ let pmtStrAssetIdB = $t01283013024._1
366+ let pmtAssetNameB = $t01283013024._2
367+ let pmtDecimalsB = $t01283013024._3
368+ let tokenRatio = fraction(fraction(scale8, balanceA, pmtAmountA), scale3, fraction(scale8, balanceB, pmtAmountB))
369+ let ratioShareTokensInA = fraction(scale8, pmtAmountA, balanceA)
370+ let ratioShareTokensInB = fraction(scale8, pmtAmountB, balanceB)
371+ let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scale8)
372+ let invariantCalculated = invariantCalc((balanceA + pmtAmountA), (balanceB + pmtAmountB))
373+ if (!(isActive))
374+ then throwIsInactive()
375+ else if (if ((0 > slippageTolerance))
376+ then true
377+ else (slippageTolerance > 10))
378+ then throw("Slippage tolerance must be <= 1%")
379+ else if ((size(i.payments) != 2))
380+ then throw("Two attached assets expected")
381+ else if (if ((pmtAssetIdA != assetIdA))
382+ then true
383+ else (pmtAssetIdB != assetIdB))
384+ then throwAssets()
385+ else if (if ((((scale3 * (slippageScale3 - slippageTolerance)) / slippageScale3) > tokenRatio))
386+ then true
387+ else (tokenRatio > ((scale3 * (slippageScale3 + slippageTolerance)) / slippageScale3)))
388+ then throw("Incorrect assets amount: amounts must have the contract ratio")
389+ else if ((shareTokenToPayAmount == 0))
390+ then throw("Too small amount to replenish")
391+ else if (!(hasEnoughBalance))
392+ then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
393+ else {
394+ let stake1 = if (containsElement(stakingAssets, pmtStrAssetIdA))
395+ then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
396+ else 0
397+ if ((stake1 == stake1))
398+ then {
399+ let stake2 = if (containsElement(stakingAssets, pmtStrAssetIdB))
400+ then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
401+ else 0
402+ if ((stake2 == stake2))
403+ then [IntegerEntry(kBalanceA, (balanceA + pmtAmountA)), IntegerEntry(kBalanceB, (balanceB + pmtAmountB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(kInvariant, invariantCalculated), Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId)]
404+ else throw("Strict value is not equal to itself.")
405+ }
406+ else throw("Strict value is not equal to itself.")
407+ }
408+ }
409+
410+
411+
412+@Callable(i)
413+func replenishWithOneToken (virtualSwapTokenPay,virtualSwapTokenGet) = {
414+ let $t01532315398 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
415+ let pmtAmount = $t01532315398._1
416+ let pmtAssetId = $t01532315398._2
417+ let $t01540315476 = getAssetInfo(pmtAssetId)
418+ let pmtStrAssetId = $t01540315476._1
419+ let pmtAssetName = $t01540315476._2
420+ let pmtDecimals = $t01540315476._3
421+ let pmtMinThreshold = 5000000
422+ let thresholdValueForMinTolerance = 50000000
423+ let tolerance = if ((thresholdValueForMinTolerance > pmtAmount))
424+ then 100000
425+ else 1
426+ let slippageValueMinForReplenish = (scale8 - ((scale8 * tolerance) / 10000000))
427+ let slippageValueMaxForReplenish = (scale8 + ((scale8 * tolerance) / 10000000))
428+ let slippageValueMinForSwap = (scale8 - ((scale8 * 1) / 10000000))
429+ if (!(isActive))
430+ then throwIsInactive()
431+ else if ((pmtMinThreshold > pmtAmount))
432+ then throw((((("Payment amount " + toString(pmtAmount)) + " does not exceed the minimum amount of ") + toString(pmtMinThreshold)) + " tokens"))
433+ else if ((size(i.payments) != 1))
434+ then throw("One attached payment expected")
435+ else if (!(hasEnoughBalance))
436+ then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
437+ else if (if ((pmtAssetId != assetIdA))
438+ then (pmtAssetId != assetIdB)
439+ else false)
440+ then throwAssets()
441+ else {
442+ let $t01648817253 = if ((pmtAssetId == assetIdA))
443+ then $Tuple7((pmtAmount - virtualSwapTokenPay), virtualSwapTokenGet, (balanceA + virtualSwapTokenPay), (balanceB - virtualSwapTokenGet), invariantCalc((balanceA + pmtAmount), balanceB), (balanceA + pmtAmount), balanceB)
444+ else $Tuple7(virtualSwapTokenGet, (pmtAmount - virtualSwapTokenPay), (balanceA - virtualSwapTokenGet), (balanceB + virtualSwapTokenPay), invariantCalc(balanceA, (balanceB + pmtAmount)), balanceA, (balanceB + pmtAmount))
445+ let virtualReplenishA = $t01648817253._1
446+ let virtualReplenishB = $t01648817253._2
447+ let balanceAfterSwapA = $t01648817253._3
448+ let balanceAfterSwapB = $t01648817253._4
449+ let invariantCalculated = $t01648817253._5
450+ let newBalanceA = $t01648817253._6
451+ let newBalanceB = $t01648817253._7
452+ let newBalanceEntry = if ((pmtAssetId == assetIdA))
453+ then IntegerEntry(kBalanceA, newBalanceA)
454+ else IntegerEntry(kBalanceB, newBalanceB)
455+ let invariantNew = invariantCalc(balanceAfterSwapA, balanceAfterSwapB)
456+ let invariantEstimatedRatio = fraction(scale8, invariant, invariantNew)
457+ let ratioVirtualBalanceToVirtualReplenish = (fraction((scale8 * scale8), balanceAfterSwapA, balanceAfterSwapB) / fraction(scale8, virtualReplenishA, virtualReplenishB))
458+ let dAppThresholdAmount = fraction((newBalanceA + newBalanceB), dAppThreshold, (2 * dAppThresholdScale2))
459+ if (if ((slippageValueMinForSwap >= invariantEstimatedRatio))
460+ then true
461+ else (invariant > invariantNew))
462+ then throw("Incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
463+ else if (if ((slippageValueMinForReplenish > ratioVirtualBalanceToVirtualReplenish))
464+ then true
465+ else (ratioVirtualBalanceToVirtualReplenish > slippageValueMaxForReplenish))
466+ then throw("Swap with virtualSwapTokenPay and virtualSwapTokenGet is possible, but ratio after virtual swap is incorrect")
467+ else if (if ((dAppThresholdAmount > newBalanceA))
468+ then true
469+ else (dAppThresholdAmount > newBalanceB))
470+ then throwThreshold(dAppThresholdAmount, newBalanceA, newBalanceB)
471+ else {
472+ let stake1 = if (containsElement(stakingAssets, pmtStrAssetId))
473+ then invoke(this, "stakeUnstake", [true, pmtAmount, pmtStrAssetId], nil)
474+ else 0
475+ if ((stake1 == stake1))
476+ then {
477+ let ratioShareTokensInA = fraction(virtualReplenishA, scale8, balanceAfterSwapA)
478+ let ratioShareTokensInB = fraction(virtualReplenishB, scale8, balanceAfterSwapB)
479+ let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scale8)
480+[Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), newBalanceEntry, IntegerEntry(kInvariant, invariantCalculated)]
481+ }
482+ else throw("Strict value is not equal to itself.")
483+ }
484+ }
485+ }
486+
487+
488+
489+@Callable(i)
490+func withdraw () = {
491+ let $t01947919622 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
492+ let pmtAmount = $t01947919622._1
493+ let pmtAssetId = $t01947919622._2
494+ let amountToPayA = fraction(pmtAmount, balanceA, shareAssetSupply)
495+ let amountToPayB = fraction(pmtAmount, balanceB, shareAssetSupply)
496+ let invariantCalculated = invariantCalc((balanceA - amountToPayA), (balanceB - amountToPayB))
497+ if (!(isActive))
498+ then throwIsInactive()
499+ else if ((size(i.payments) != 1))
500+ then throw("One attached payment expected")
501+ else if ((pmtAssetId != shareAssetId))
502+ then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
503+ else if (!(hasEnoughBalance))
504+ then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
505+ else if (if ((amountToPayA > availableBalanceA))
506+ then true
507+ else (amountToPayB > availableBalanceB))
508+ then throwInsufficientAvailableBalances(amountToPayA, amountToPayB)
509+ else {
510+ let stake1 = if (containsElement(stakingAssets, strAssetIdA))
511+ then invoke(this, "stakeUnstake", [false, amountToPayA, strAssetIdA], nil)
512+ else 0
513+ if ((stake1 == stake1))
514+ then {
515+ let stake2 = if (containsElement(stakingAssets, strAssetIdB))
516+ then invoke(this, "stakeUnstake", [false, amountToPayB, strAssetIdB], nil)
517+ else 0
518+ if ((stake2 == stake2))
519+ then [IntegerEntry(kBalanceA, (balanceA - amountToPayA)), IntegerEntry(kBalanceB, (balanceB - amountToPayB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply - pmtAmount)), IntegerEntry(kInvariant, invariantCalculated), Burn(shareAssetId, pmtAmount), ScriptTransfer(i.caller, amountToPayA, assetIdA), ScriptTransfer(i.caller, amountToPayB, assetIdB)]
520+ else throw("Strict value is not equal to itself.")
521+ }
522+ else throw("Strict value is not equal to itself.")
523+ }
524+ }
525+
526+
527+
528+@Callable(i)
529+func exchange (estimatedAmountToReceive,minAmountToReceive) = {
530+ let $t02129321368 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
531+ let pmtAmount = $t02129321368._1
532+ let pmtAssetId = $t02129321368._2
533+ if (!(isActive))
534+ then throwIsInactive()
535+ else if ((0 >= estimatedAmountToReceive))
536+ then throw(("Estimated amount must be positive. Actual: " + toString(estimatedAmountToReceive)))
537+ else if ((minAmountToReceive > estimatedAmountToReceive))
538+ then throw(((("Minimal amount can't be greater than estimated. Estimated: " + toString(estimatedAmountToReceive)) + ". Minimal: ") + toString(minAmountToReceive)))
539+ else if ((size(i.payments) != 1))
540+ then throw("One attached payment expected")
541+ else if (!(hasEnoughBalance))
542+ then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
543+ else if (if ((pmtAssetId != assetIdA))
544+ then (pmtAssetId != assetIdB)
545+ else false)
546+ then throwAssets()
547+ else if ((10000000 > pmtAmount))
548+ then throw("Only swap of 10.000000 or more tokens is allowed")
549+ else if (if ((exchangeRatioLimitMin > fraction(scale8, minAmountToReceive, pmtAmount)))
550+ then true
551+ else (fraction(scale8, estimatedAmountToReceive, pmtAmount) > exchangeRatioLimitMax))
552+ then throw("Incorrect args and pmt ratio")
553+ else {
554+ let sendAssetId = if ((pmtAssetId == assetIdA))
555+ then assetIdB
556+ else assetIdA
557+ let amount = calculateSendAmount(estimatedAmountToReceive, minAmountToReceive, pmtAmount, pmtAssetId)
558+ let governanceReward = fraction(amount, feeGovernance, feeScale6)
559+ let amountMinusFee = fraction(amount, (feeScale6 - fee), feeScale6)
560+ let $t02279023052 = if ((pmtAssetId == assetIdA))
561+ then $Tuple2((balanceA + pmtAmount), ((balanceB - amountMinusFee) - governanceReward))
562+ else $Tuple2(((balanceA - amountMinusFee) - governanceReward), (balanceB + pmtAmount))
563+ let newBalanceA = $t02279023052._1
564+ let newBalanceB = $t02279023052._2
565+ let dAppThresholdAmount = fraction((newBalanceA + newBalanceB), dAppThreshold, (2 * dAppThresholdScale2))
566+ if (if ((dAppThresholdAmount > newBalanceA))
567+ then true
568+ else (dAppThresholdAmount > newBalanceB))
569+ then throwThreshold(dAppThresholdAmount, newBalanceA, newBalanceB)
570+ else {
571+ let $t02335023423 = getAssetInfo(pmtAssetId)
572+ let pmtStrAssetId = $t02335023423._1
573+ let pmtAssetName = $t02335023423._2
574+ let pmtDecimals = $t02335023423._3
575+ let $t02343623516 = getAssetInfo(sendAssetId)
576+ let sendStrAssetIdB = $t02343623516._1
577+ let sendAssetNameB = $t02343623516._2
578+ let sendDecimalsB = $t02343623516._3
579+ let stake1 = if (containsElement(stakingAssets, pmtStrAssetId))
580+ then invoke(this, "stakeUnstake", [true, pmtAmount, pmtAssetId], nil)
581+ else 0
582+ if ((stake1 == stake1))
583+ then {
584+ let stake2 = if (containsElement(stakingAssets, sendStrAssetIdB))
585+ then invoke(this, "stakeUnstake", [false, (amount + governanceReward), sendAssetId], nil)
586+ else 0
587+ if ((stake2 == stake2))
588+ then [IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), IntegerEntry(kInvariant, invariantCalc(newBalanceA, newBalanceB)), ScriptTransfer(i.caller, amountMinusFee, sendAssetId), ScriptTransfer(govAddr, governanceReward, sendAssetId)]
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+
598+@Callable(i)
599+func shutdown () = if (!(isActive))
600+ then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, kCause), "the cause wasn't specified")))
601+ else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, admStartStop], i.callerPublicKey)))
602+ then throwOnlyAdmin()
603+ else suspend("Paused by admin")
604+
605+
606+
607+@Callable(i)
608+func activate () = if (isActive)
609+ then throwIsActive()
610+ else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, admStartStop], i.callerPublicKey)))
611+ then throwOnlyAdmin()
612+ else [BooleanEntry(kActive, true), DeleteEntry(kCause)]
613+
614+
615+
616+@Callable(i)
617+func takeIntoAccountExtraFunds (amountLeave) = {
618+ let uncountableA = (accountBalanceWithStakedA - balanceA)
619+ let uncountableB = (accountBalanceWithStakedB - balanceB)
620+ let amountEnrollA = (uncountableA - (if ((assetIdA == unit))
621+ then amountLeave
622+ else 0))
623+ let amountEnrollB = (uncountableB - (if ((assetIdB == unit))
624+ then amountLeave
625+ else 0))
626+ let invariantNew = invariantCalc((balanceA + amountEnrollA), (balanceB + amountEnrollB))
627+ if (!(isActive))
628+ then throwIsInactive()
629+ else if ((i.caller != this))
630+ then throwOnlyAdmin()
631+ else if ((0 > amountLeave))
632+ then throw(("Argument 'amountLeave' cannot be negative. Actual: " + toString(amountLeave)))
633+ else if (if ((0 > uncountableA))
634+ then true
635+ else (0 > uncountableB))
636+ then suspend("Enroll amount negative")
637+ else if (if ((0 > amountEnrollA))
638+ then true
639+ else (0 > amountEnrollB))
640+ then throw("Too large amountLeave")
641+ else {
642+ let stake1 = if (if (containsElement(stakingAssets, strAssetIdA))
643+ then (amountEnrollA > 0)
644+ else false)
645+ then invoke(this, "stakeUnstake", [true, amountEnrollA, strAssetIdA], nil)
646+ else 0
647+ if ((stake1 == stake1))
648+ then {
649+ let stake2 = if (if (containsElement(stakingAssets, strAssetIdB))
650+ then (amountEnrollB > 0)
651+ else false)
652+ then invoke(this, "stakeUnstake", [true, amountEnrollB, strAssetIdB], nil)
653+ else 0
654+ if ((stake2 == stake2))
655+ then [IntegerEntry(kInvariant, invariantNew), IntegerEntry(kBalanceA, (balanceA + amountEnrollA)), IntegerEntry(kBalanceB, (balanceB + amountEnrollB)), IntegerEntry(("last_income_" + strAssetIdA), amountEnrollA), IntegerEntry(("last_income_" + strAssetIdB), amountEnrollB)]
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+
663+
664+@Callable(i)
665+func stakeUnstake (stake,amount,assetIdString) = if ((i.caller != this))
666+ then throw("Only contract itself can invoke this function")
667+ else {
668+ let $t02683126934 = calcStakingParams(stake, amount, fromBase58String(assetIdString))
669+ let call = $t02683126934._1
670+ let addr = $t02683126934._2
671+ let params = $t02683126934._3
672+ let payments = $t02683126934._4
673+ let inv = invoke(addr, call, params, payments)
674+ nil
675+ }
676+
677+
678+
679+@Callable(i)
680+func stakeAll () = if (!(isActive))
681+ then throw("DApp is inactive at this moment")
682+ else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, admStartStop], i.callerPublicKey)))
683+ then throw("Only admin can call this function")
684+ else {
685+ let stake1 = if (containsElement(stakingAssets, strAssetIdA))
686+ then {
687+ let amountA = (balanceA - stakedAmountA)
688+ if ((amountA > 0))
689+ then invoke(this, "stakeUnstake", [true, amountA, strAssetIdA], nil)
690+ else 0
691+ }
692+ else 0
693+ if ((stake1 == stake1))
694+ then {
695+ let stake2 = if (containsElement(stakingAssets, strAssetIdB))
696+ then {
697+ let amountB = (balanceB - stakedAmountB)
698+ if ((amountB > 0))
699+ then invoke(this, "stakeUnstake", [true, amountB, strAssetIdB], nil)
700+ else 0
701+ }
702+ else 0
703+ if ((stake2 == stake2))
704+ then nil
705+ else throw("Strict value is not equal to itself.")
706+ }
707+ else throw("Strict value is not equal to itself.")
708+ }
709+
710+
711+@Verifier(tx)
712+func verify () = {
713+ let multiSignedByAdmins = {
714+ let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
715+ then 1
716+ else 0
717+ let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
718+ then 1
719+ else 0
720+ let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
721+ then 1
722+ else 0
723+ (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
724+ }
725+ match tx {
726+ case inv: InvokeScriptTransaction =>
727+ let callTakeIntoAccount = if ((inv.dApp == this))
728+ then (inv.function == "takeIntoAccountExtraFunds")
729+ else false
730+ let signedByAdmin = if (if (if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
731+ then true
732+ else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey2))
733+ then true
734+ else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey3))
735+ then true
736+ else sigVerify(tx.bodyBytes, tx.proofs[0], admStaking)
737+ if (if (callTakeIntoAccount)
738+ then signedByAdmin
739+ else false)
740+ then true
741+ else multiSignedByAdmins
742+ case _ =>
743+ multiSignedByAdmins
744+ }
745+ }
746+

github/deemru/w8io/026f985 
43.40 ms